Add a refactoring between reference and struct tuples

[xperiandri]

Offers Ctrl+. on a tuple expression, pattern or annotated tuple type to switch it between a reference and a struct tuple. The value is followed through annotations, patterns, record fields, function results and call arguments across the solution, so the result still type-checks. What can't be followed (fst, snd, generic collections) is left for the compiler to report.

Not offered for method argument lists, the only argument of a member (that is its parameter list), inside quotations, or when the file has a paired .fsi.

🤖 Generated with Claude Code

[github-actions]

❗ Release notes required

You can open this PR in browser to add release notes: open in github.dev

---

✅ Found changes and release notes in following paths:

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

[github-actions]

🔍 Tooling Safety Check — Affects-Design-Time
Affects-Design-Time: Modifies Visual Studio code executed while projects are open.

Generated by PR Tooling Safety Check · gpt56 1.8M · ◷

[xperiandri]

Covered cases

Converts

• A tuple used nowhere else converts on its own, and back: printfn "%A" (1, 2) → printfn "%A" struct (1, 2); a type argument list<int * int> → list<struct (int * int)>
• A value converts together with the tuple patterns that take it apart and the annotations it flows into, both ways: let pair = (1, 2) + let (a, b) = pair + let copy: int * int = pair → let pair = struct (1, 2) + let struct (a, b) = pair + let copy: struct (int * int) = pair
• A parameter annotation converts the patterns on the parameter and every argument passed to it, both literals and values, both ways: let sum (p: int * int) + let (a, b) = p + let pair = (3, 4) + sum pair + sum (1, 2) → let sum (p: struct (int * int)) + let struct (a, b) = p + let pair = struct (3, 4) + sum pair + sum struct (1, 2)
• A parameter that is not first converts the matching argument of each call, both ways: curried let scale (factor: int) (p: int * int) + scale 2 (1, 2) → scale 2 struct (1, 2); a tuple inside a tupled parameter list let area (p: int * int, factor: int) + area ((2, 3), 4) → area (struct (2, 3), 4)
• The tuple argument of a curried function or member converts with its calls, both ways: let add (a, b) c + add (1, 2) 3 → let add struct (a, b) c + add struct (1, 2) 3; member _.Add (a: int, b: int) (c: int) + Calc().Add (1, 2) 3 → member _.Add struct (a: int, b: int) (c: int) + Calc().Add struct (1, 2) 3
• A space is added between struct and a name the parenthesis directly follows: let add(a, b) c → let add struct (a, b) c
• A return type converts the result and the patterns that take it apart, both ways: let origin () : int * int = (0, 0) + let (x, y) = origin () → let origin () : struct (int * int) = struct (0, 0) + let struct (x, y) = origin ()
• A record field converts only its own values and the patterns on it, both ways: { Start: int * int; Finish: int * int } + { Start = (0, 0); Finish = (1, 1) } + let (sx, sy) = line.Start → only Start becomes struct (int * int), struct (0, 0) and let struct (sx, sy); Finish is not changed
• A value declared in a second file converts in that file: the caret on let (a, b) = A.pair in module B also rewrites let pair = (1, 2) in A to struct (1, 2); the result is checked as a new project and has no errors
• A use the refactoring cannot follow is left for the compiler to report: let pair = (1, 2) + let first = fst pair → let pair = struct (1, 2), fst pair is unchanged and gives exactly one error on its line
• The action titles name the target kind: Convert to struct tuple and Convert to reference tuple
• Every result is re-type-checked and asserted to have no errors

Not offered

• The caret is not on a tuple: let x = 1
• The argument list of a .NET method call: System.Math.Max(1, 2)
• A tuple inside a quotation: <@ (1, 2) @>
• A member's parameter list, here with an optional parameter: member _.Greet(name: string, ?greeting: string)
• A struct tuple that is a member's only parameter: member _.Add struct (a: int, b: int) = a + b
• A constructor's parameter list: new(x: int, y: int, z: int) = Point(x + z, y)