[xperiandri]

Stacked on #20537.

Offers Ctrl+. on a selected expression to move it into a local function, a module function, or, when it uses this or base, a private member. Values the selection reads from the enclosing function become parameters in first-use order.

Parameters are annotated by default because the new function is its own generalization point; the new Parameter types in Extract to function option under Code Fixes can relax that. Not offered when the selection assigns to a captured mutable or reads a byref value.

🤖 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

[T-Gro]

🤖🕵️ Please shorten the description using this guidance. Focus on the problem and why the change is needed, in simplified technical English. Leave the implementation inventory to the Files tab and retain necessary caveats.

[xperiandri]

Covered cases

Offered

• Values the selection uses from the enclosing declaration become parameters of a local function: printfn "%d" (w * h + 1) → let extractedFunction (w: int) (h: int) = w * h + 1 + printfn "%d" (extractedFunction w h)
• The module function is inserted before the declaration that uses it: let private extractedFunction (w: int) (h: int) = w * h + 1 above let area …
• Selecting (w * h + 1) with its parentheses gives the same result, and the call stays parenthesized
• A selection that uses no outside values becomes a function of unit: 1 + 2 → let extractedFunction () = 1 + 2 + extractedFunction ()
• A selection that uses this becomes a private member after the enclosing member: l * this.Rate in List.sumBy (fun l -> l * this.Rate) → this.ExtractedMethod(l) + member private this.ExtractedMethod(l: int) = l * this.Rate
• The parameter-annotation option: Always → let extractedFunction (s: string) (n: int) =, WhenNeeded → (s: string) n (only the receiver of s.ToUpper() is annotated), Never → s n
• Which actions appear: a plain selection (w * h + 1) offers "Extract to local function" and "Extract to module function"; a selection using base (base.ToString() + "!") offers only "Extract to private member"
• A caret in the header of a parenthesized lambda (x -> in (fun x -> x + n)) offers the same actions, with the same results, as selecting the whole (fun x -> x + n)

Not offered

• With no selection, a caret in the lambda body: x + n in (fun x -> x + n)
• The selection assigns to a captured mutable local: for i in 1 .. 3 do n <- n + i
• The selection reads a byref parameter: x + 1 with x: byref<int>

[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 63 new code comment lines and 5702 new code comment chars.
• ComputeRefactoringsAsync in ExtractFunction.fs:370-465 reaches 6 nested control-flow levels.
• Tests would benefit from deduplicated setup or code-as-test reuse: ExtractFunctionTests.fs and ExtractLetBindingTests.fs copy dozens of single-case [<Fact>] methods with repeated module M setup instead of using parameterized tests.

[xperiandri]

Merged the compacted base of #20537 (1711de9) in 5aabbc8 and compacted this PR's own code in 204be8f (ExtractFunction.fs) and b4cccb8 (tests): against main the F# lines this PR adds went from 2766 to 2378, and the comment lines from 63 (5996 chars) to 4 (445 chars: three license headers and one note that the public tokenizer enum does not name the interpolated string states); the rest is said by names such as CapturedLocal, TypeParameterDeclaredOutside, closureCannotCapture, readsMutableInDelayedCode and assignsCapturedValue.
ComputeRefactoringsAsync went from 7 nested levels by my indentation count (6 in the review) to 2 and now only hands the selection to FunctionExtraction.offer; tryCaptures (4), positionsNeedingType and curriedParameters (3 each) are at 2 as well, and the registration, padding and state gathering that duplicated ExtractLetBinding.fs are now the shared registerRefactoring, padding and Extraction.
ExtractFunctionTests went from 17 [<Fact>] plus 4 [<Theory>] methods (35 cases) to 5 [<Theory>] methods and one [<Fact>] over 38 named rows, and ExtractLetBindingTests from 31 methods (64 cases) to 6 theories over 74 rows (a test that asserted several things became one row per assertion), both on the module M helper and the span, text and title helpers in RefactorTestFramework.fs.
ExtractLetBindingTests 74/74, ExtractFunctionTests 38/38 and the AddReturnTypeTests control 22/22 pass, and FSharp.Editor builds with --optimize+.

[T-Gro]

🤖🕵️ AI review — verify independently.

[T-Gro]

🤖🕵️ Default extraction loses the lambda's contextual type and fails type checking.

let f (xs: string list) =
    xs |> List.map (fun x -> x.Length)

[T-Gro]

🤖🕵️ Extraction copies mutable storage; the result changes from 1 to 0.

let f () =
    let mutable n = 0
    let bump () = n <- n + 1
    (bump (); n)

[T-Gro]

🤖🕵️ Extraction copies a mutable struct receiver; the result changes from 2 to 1.

[<Struct>]
type S =
    val mutable X: int
    new(x) = { X = x }
    member self.Inc() = self.X <- self.X + 1