[xperiandri]

Offers Ctrl+. to switch between ?x: T with defaultArg x c in the body and [<Optional; DefaultParameterValue(c)>] x: T, which C# and VB callers can omit too. Converting back offers ?x with defaultArg and, from F# 10, [<Struct>] ?x with defaultValueArg. F# call sites compile against both forms, so only the member is edited.

Not offered unless every use is defaultArg x c with one constant of the parameter's type, or for overrides, abstract slots, constructors, or a file with a paired .fsi.

🤖 Generated with Claude Code

[github-actions]

✅ Release notes checked

---

✅ Found changes and release notes in following paths:

Change path	Release notes path	Description
`vsintegration/src`	docs/release-notes/.VisualStudio/18.vNext.md

[xperiandri]

Covered cases

Converts

• Shadowing default, adding the missing open: ?greeting: string with let greeting = defaultArg greeting "Hello" → [<Optional; DefaultParameterValue("Hello")>] greeting: string, the let line removed, open System.Runtime.InteropServices inserted; calls Greet("Ada") and greeting = "Hi" stay as they are
• Shadowing default round trip, both ways, when the open already exists: ?step: int + let step = defaultArg step 1 ⟷ [<Optional; DefaultParameterValue(1)>] step: int; the same for a second parameter ?step: float with 0.5
• Inline default: value + defaultArg step 1 → [<Optional; DefaultParameterValue(1)>] step: int) = value + step
• Back with a body on the member line: step: int) = value + step → ?step: int) =, then let step = defaultArg step 1 and value + step on their own lines
• Parameter with no default use: ?flag: bool (unused) → [<Optional>] flag: bool
• Back with no DefaultParameterValue: [<Optional>] step: int → ?step: int + let step = defaultArg step Unchecked.defaultof<_>
• Back to a struct optional parameter: [<Optional; DefaultParameterValue(1)>] step: int → [<Struct>] ?step: int + let step = defaultValueArg step 1; [<Optional>] step: int → … defaultValueArg step Unchecked.defaultof<_>
• Action titles: the F# form offers only Use [<Optional; DefaultParameterValue>] for optional parameter; the .NET form offers Use F# '?' optional parameter, then Use F# '[<Struct>] ?' optional parameter
• Language version gate: before F# 10 (--langversion:9.0), the .NET form offers only Use F# '?' optional parameter
• Each converted document type-checks without errors

Not offered

• Different defaults: defaultArg x 0 + defaultArg x 1
• A use other than defaultArg: static member M(?x: int) = x.IsSome
• Default that is not a constant: ?x: obj with defaultArg x (box 1)
• Constant whose type does not match the parameter: ?x: int with defaultArg x 1.0
• Parameter with no type annotation: static member M(?x) = defaultArg x 0
• Struct optional parameter: [<Struct>] ?x: int with defaultValueArg x 0
• Extra attribute in the list: [<Optional; In>] x: int
• Override of an abstract slot: abstract M: ?x: int -> int with default _.M(?x: int) = defaultArg x 0
• Ordinary parameter: static member M(x: int) = x
• File that has a signature file: static member M: ?x: int -> int

[T-Gro]

🤖 🕵️ AI review — verify independently.

[T-Gro]

🤖 🕵️ [P2] Converting x to F# ?x changes C.M() from true to false — an omitted obj receives null instead of Missing.Value.

open System.Runtime.InteropServices

type C() =
    static member M([<Optional>] x: obj) =
        obj.ReferenceEquals(x, System.Reflection.Missing.Value)

printfn "%b" (C.M())

[xperiandri]

Fixed in 6a6a694: for an F# member, [<Optional>] without DefaultParameterValue passes Missing.Value only when the parameter type is obj (infos.fs, isObjTyAnyNullness). Every other type gets DefaultValue, which matches Unchecked.defaultof. So the conversion is no longer offered when the parameter's type, with abbreviations stripped, is System.Object. Test: the [<Optional>] x: obj case of No action.

[T-Gro]

🤖 🕵️ [P2] Converting ?x to .NET optional changes C.M() from 99 to 0 — matching defaultArg by spelling removes a call to a different function.

let defaultArg (_: int option) (_: int) = 99

type C() =
    static member M(?x: int) = defaultArg x 0

printfn "%d" (C.M())

[xperiandri]

Fixed in 6a6a694: defaultArg must now resolve by symbol to Microsoft.FSharp.Core.Operators.defaultArg. The check goes through an isFSharpCoreSymbol helper that is also in #20545/#20546, and it will move into a shared helper module later. Test: the user-defined defaultArg case of No action.

[T-Gro]

🤖 🕵️ [P2] Converting only ?y to .NET optional produces FS1212 — the remaining F# optional ?x precedes the converted parameter.

type C() =
    static member M(?x: int, ?y: int) =
        defaultArg x 1 + defaultArg y 2

[xperiandri]

Fixed in 6a6a694: the .NET form is no longer offered when a ? parameter comes before the target in the same member. Test: the M(?x: int, ?y: int) case of No action.

[T-Gro]

🤖 🕵️ [P2] Converting x to [<Struct>] ?x leaves a formerly valid caller failing with FS0001 — Some 1 supplies option, but the parameter now requires voption.

open System.Runtime.InteropServices

type C =
    static member M([<Optional; DefaultParameterValue(0)>] x: int) = x

let result = C.M(?x = Some 1)

[xperiandri]

Fixed in 6a6a694 by rewriting the callers, as #20546 does. Deciding not to offer it would need the same solution-wide reference search at lightbulb time; rewriting does that search only when the action runs. The struct action now changes the solution. ?x = Some v/None become ValueSome v/ValueNone when they are the FSharp.Core cases, and any other value is wrapped in ValueOption.ofOption. Test: Converting to a struct optional parameter converts optional arguments to value options.

[T-Gro]

🤖 🕵️ [P2] Converting ?x to .NET optional deletes let mutable x, leaving x <- x + 1 failing with FS0027 because the parameter is immutable.

type C() =
    static member M(?x: int) =
        let mutable x = defaultArg x 0
        x <- x + 1
        x

[xperiandri]

Fixed in 6a6a694: a let mutable shadow is no longer removed. It becomes let mutable x = x. Test: Mutable shadowing keeps its binding.

[T-Gro]

🤖 🕵️ [P2] Converting ?x to .NET optional produces FS0039 for both attributes — an open in another module suppresses the import needed at C.M.

module Other =
    open System.Runtime.InteropServices
    let x = 1

type C() =
    static member M(?x: int) = defaultArg x 0

[xperiandri]

Fixed in 6a6a694: an open System.Runtime.InteropServices counts only when it ends before the member, inside a module or namespace that encloses the member. Otherwise the open is inserted. Tests: Open in another module does not count as in scope, Open in an enclosing module counts as in scope.

[T-Gro]

🤖 🕵️ Re-reviewed all recent changes as of 891d0c5; LGTM

[T-Gro]

🤖 🕵️ Re-reviewed all recent changes as of 22767fd; LGTM

[T-Gro]

The diff is still way too big - apply the NoBloat instructions and CodeCompaction skill.

Especially the massive code comments would benefit not just with drastic reduction, but ideally with well named functions/arguments/bindings/types making the intention clear.

If a well named piece of code just tells what the comment says - delete the comment.

• This diff adds 32 new code comment lines and 2999 new code comment chars.
• Comments bypass the type system and become stale maintenance state. Keep only durable public contracts; express implementation intent through names, functions, active patterns, discriminated unions, and types.

[xperiandri]

Commits ddb5850 (source) and d52a564 (tests) apply the compaction: added comment lines 32 -> 1 and comment characters 2999 -> 123, the one left being the license header, with the explanations now carried by names such as FSharpOptional and DotNetOptional, fsharpCoreNameAt, tryAnnotatedParameter, hasOnlyOptionalAttributes, passesMissingValueWhenOmitted and assertCompilesAsProject. ComputeRefactoringsAsync went from nine nested levels of control flow to three (actionsFor and changedSolution are their own functions), tryForm and tryParameter from four levels to two, and the repeated symbol lookup and the two document actions became tryGetSymbolUse and documentAction. The tests went from 17 methods to 12 and from 976 to 658 lines with the same 47 cases (every input and expected result is kept, the module M header and the System.Runtime.InteropServices open come from two helpers, and each theory row has a name), so the PR now adds 1709 lines instead of 2041. Left as is: tryParameter still folds the whole tree, since ParsedInput.tryPick stops at the caret with different edge rules and would change behaviour.

[T-Gro]

🤖🕵️ AI review — verify independently.

[T-Gro]

🤖🕵️ Local attribute capture changes an omitted argument from 7 to 0.

open System.Runtime.InteropServices
type DefaultParameterValueAttribute(value: int) = inherit System.Attribute()
type C =
    static member M(?x: int) = defaultArg x 7
let result = C.M()

[T-Gro]

🤖🕵️ Generated binding lands inside a block comment; the expression fails with FS0001/FS0043.

static member M([<Optional; DefaultParameterValue(7)>] x: int) =
    (* first
       second *) x + 1

[T-Gro]

🤖 🕵️ Re-reviewed all recent changes as of eedf260; LGTM