[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.

[abonie]

🤖🕵️ AI review — verify independently.

[abonie]

🤖🕵️ Inserting this import rebinds untouched CharSet.None, changing result from 123 to 1 while both versions compile. Fully qualify the generated attributes instead of adding a broad import.

// User.fs — preceding file
namespace User
type CharSet = | None = 123

// Main.fs
module Main
open User
type C =
    static member M(?x: int) = defaultArg x 7
let result = int CharSet.None
let omitted = C.M()

[xperiandri]

Fixed in 008e3f9: no open is inserted any more. The attributes are written as System.Runtime.InteropServices.Optional and System.Runtime.InteropServices.DefaultParameterValue, unless that namespace is already open at the member. Tests: Attributes are fully qualified where System.Runtime.InteropServices is not open and Open in another module does not count as in scope.

[abonie]

🤖🕵️ Separate [<ParamArray>] list escapes validation and survives on the generated option/voption parameter. Both reverse actions break the previously valid omitted and packed calls with FS0501. Validate all parameter attributes, not only lists containing optional attributes.

open System
open System.Runtime.InteropServices

type C =
    static member M([<ParamArray>] [<Optional>] x: int[]) =
        if isNull x then -1 else x.Length

printfn "%A" [C.M(); C.M(1, 2)]

[xperiandri]

Fixed in 008e3f9: every attribute list of the parameter is checked now, and the parameter's symbol may carry no attribute other than Optional and DefaultParameterValue. Test: the [<ParamArray>] [<Optional>] case of No action.

[abonie]

🤖🕵️ Fixed SRTP caller contract left incompatible: both reverse actions change the physical parameter type but retain int -> int, producing FS0001. The option/voption conversion in #20546 has the same failure.

open System.Runtime.InteropServices

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

let inline call (t: ^T) =
    ((^T) : (static member M : int -> int) 2)

printfn "%d" (call Unchecked.defaultof<C>)

[T-Gro]

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

[abonie]

🤖🕵️ AI review — verify independently.

[abonie]

🤖🕵️ Escaped parameter spelling lost in generated expressions: forward conversion emits bare type, and reverse conversion emits let type = defaultArg type 7, producing syntax errors. Preserve or correctly escape the identifier in both directions.

open System.Runtime.InteropServices
type C =
    static member M(?``type``: int) = defaultArg ``type`` 7
printfn "%d" (C.M())

[xperiandri]

Fixed in 008e3f9: the parameter name is taken from the source text in both directions, so its backticks stay. Test: Escaped parameter name keeps its backticks.

[abonie]

🤖🕵️ Prefix insertion corrupts a valid escaped builtin case: the struct action generates Value``Some``, producing FS0039. Replace the complete identifier token rather than inserting text before its backticks.

open System.Runtime.InteropServices
type C =
    static member M([<Optional; DefaultParameterValue(7)>] x: int) = x
printfn "%d" (C.M(?x = ``Some`` 2))

[xperiandri]

Fixed in 008e3f9: the whole identifier is replaced with ValueSome or ValueNone. Test: the Some case of Converting to a struct optional parameter converts optional arguments to value options.

[abonie]

🤖🕵️ Declaring-project gate does not protect dependent callers: the struct action rewrites the F#9 caller to ValueSome 2, then it fails FS0001/FS0193 against the converted member. Check every affected project’s feature support; #20546 has the same gap.

// Project A: F#10
module A
open System.Runtime.InteropServices
type C =
    static member M([<Optional; DefaultParameterValue(7)>] x: int) = x

// Project B: F#9, references A
module B
let result = A.C.M(?x = Some 2)

[xperiandri]

Fixed in 008e3f9: the struct form is offered only when the member's project and every F# project that depends on it support value options as optional parameters. Test: Struct optional parameter is offered only when every dependent F# project supports it.

[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