[xperiandri]

Offers Ctrl+. on a selected expression to bind it to a let in front of the statement that uses it, or, for a constant in a module-level declaration, to a [<Literal>] above that declaration. A caret inside a constant offers the literal; a caret in the fun … -> header of a parenthesized lambda extracts the lambda.

The value is computed at the start of the enclosing statement, so it can run earlier than where it was written, as with C#'s Introduce Local. The selection must match a whole expression; nothing is offered inside quotations, interpolation holes, while conditions or when guards.

🤖 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]

Suggested change

	|> List.ofSeq
	|> Seq.toList

[xperiandri]

Applied in 07b192f.

[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

• An expression inside a statement is bound on the line before it: selecting w * h + 1 in printfn "%d" (w * h + 1) → let extracted = w * h + 1 + printfn "%d" (extracted); selecting (w * h + 1) removes the parentheses: printfn "%d" extracted
• Method-call parentheses stay: selecting (1 + 2) in sb.Append(1 + 2) → sb.Append(extracted)
• A multi-line pipeline on the right of let total = is bound in front of that let as let extracted = + the indented pipeline, and let total = then holds extracted; also when whole lines are selected with their indentation and line break
• A body sharing its line with -> moves to its own lines: | Some v -> v * 2 + offset and (fun x -> x + 1) become -> followed by let extracted = … and extracted
• A right-hand side on the = line keeps its trailing comment: let r = compute a b // slow → let extracted = compute a b + extracted // slow
• Inside a computation expression the binding goes before the statement: return parse raw |> List.length } → let extracted = parse raw |> List.length + return extracted }
• The name avoids existing identifiers: extracted1 when extracted is already used
• CRLF line endings are kept
• Lines inside a multi-line triple-quoted string (String.Format("""Hello … {0}""", name)) are not re-indented
• Extract to literal inserts a declaration in front of the module-level let: "Hello %s" → [<Literal>] let ExtractedConstant = "Hello %s"; a negative number g -1 → let ExtractedConstant = -1
• Which actions appear: for 42 in a module let, both "Extract to let binding" and "Extract to literal"; only the let binding for 42 in member _.M() = 42 and for x + 1
• With no selection, a caret at the start of, inside (llo %s) or at the end of "Hello %s" gives the literal extraction; a caret inside 42 offers only the literal
• With no selection, a caret on fun, the parameter, the arrow or right after it in xs |> List.map (fun x -> x + 1) extracts the whole lambda: let extracted = fun x -> x + 1 + xs |> List.map extracted (only the let binding is offered)

Not offered

• With no selection, a caret in the lambda body (x + 1), + 1)), on the opening (fun parenthesis, or on a lambda without parentheses let f = fun x -> x + 1
• With no selection, a caret on a non-constant g x, on 42 in member _.M() = 42, or on 1 in the interpolation $"{a + 1}"
• A selection that is not a whole expression: w * h + in w * h + 1, or 2 + 3 in 1 + 2 + 3
• A then branch sharing its line with else: x + 1 in if c then x + 1 else y
• Selections inside a while condition i < n, a when guard v > 0, an interpolation $"{a + b}", or the right operand of &&: s.Length > 0
• return id in a computation expression, the argument tuple a, b of sb.Insert(a, b), or a lone identifier x in x.ToString() + ""
• An empty selection outside any constant or parenthesized lambda (let f x = x + 1)

[T-Gro]

🤖 🕵️ Re-reviewed all recent changes as of c2d5181; 2 findings

[T-Gro]

🤖 🕵️ [P1] Keep extraction inside the finally block. Selecting stream.Dispose() inserts let extracted = stream.Dispose() before the try, so this working function throws ObjectDisposedException at WriteByte. Moving cleanup across the finally boundary is different from evaluating a value earlier within its enclosing statement. Give finallyExpr its own anchor, as tryExpr already has, or do not offer extraction there.

open System.IO

let f () =
    use stream = new MemoryStream()
    try
        stream.WriteByte(1uy)
    finally
        stream.Dispose() // Select this expression.

[xperiandri]

Fixed in 07b192f: finallyExpr has its own anchor, so the binding goes inside the finally block. Test: Expression in a finally block is bound inside the block.

[T-Gro]

🤖 🕵️ [P2] Keep the literal inside its enclosing module. Selecting 42 here inserts [<Literal>] let ExtractedConstant = 42 between namespace N and module M, so the valid original becomes a namespace-level value and fails with FS0201, "Namespaces cannot contain values." Inserting at the physical line start escapes the inline module. Split its body correctly or decline this action when the module's let is not line-leading.

namespace N
module M = let f () = 42 // Extract 42 to literal.

[xperiandri]

Fixed in 07b192f: the literal is not offered when the module-level let does not start its line. Test: Literal is not offered where the declaration does not start its line.

[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 38 new code comment lines and 3462 new code comment chars.
• ExtractLetBinding.fs:78-93 reaches at least 3 logical nesting levels.
• Tests would benefit from deduplicated setup or code-as-test reuse: ExtractLetBindingTests.fs contains 21 copied [<Fact>] methods with repeated module M boilerplate that should be parameterized.

[xperiandri]

Compacted in 034e6f2 (production code) and 1711de9 (tests): the F# lines this PR adds against main went from 1731 to 1498, and the comment lines from 38 (3578 chars) to 3 (320 chars: two license headers and one note that the public tokenizer enum does not name the interpolated string states); everything else is now said by names such as Extraction, offsideColumnOf, ElifBranch and hasOrphanedComputationConstruct.
ComputeRefactoringsAsync and tryDeclareInFront went from 5 nested levels to 2, no function in ExtractLetBinding.fs or RefactoringHelpers.fs is nested deeper than 2 now, and the provider and the declaration builders share one Extraction record and one registerRefactoring instead of threading seven arguments around.
The 21 [<Fact>] and 10 [<Theory>] methods (64 cases) are now 6 [<Theory>] methods over 74 named rows (a test that asserted several things became one row per assertion), with the module M wrapper in one helper, fileOf, next to the selection, caret, text and title helpers in RefactorTestFramework.fs.
ExtractLetBindingTests passes 74/74 (64/64 before), the AddReturnTypeTests control 22/22, and FSharp.Editor builds with --optimize+.

[T-Gro]

🤖🕵️ AI review — verify independently.

[T-Gro]

🤖🕵️ Extracted binding shadows an import used in an inactive branch; enabling ALT changes 13 to 6.

module M
open Dependency
let f () =
    let n = (1 + 2)
#if ALT
    n + extracted
#else
    n
#endif