[xperiandri]

Stacked on #20548.

Offers Ctrl+. to switch between {| … |} and struct {| … |}, following the value the same way as the tuple refactoring. A copy-and-update {| r with … |} has its own form, so it converts independently of r.

🤖 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

• An anonymous record used nowhere else converts on its own, and back: printfn "%A" {| A = 1 |} → printfn "%A" struct {| A = 1 |}; a type argument list<{| A: int |}> → list<struct {| A: int |}>; a multi-line {| … |} → struct {| … |}
• A value converts together with the annotations it flows into, and field access is left as is, both ways: let person = {| Name = "Ada"; Age = 36 |} + let copy: {| Name: string; Age: int |} = person + person.Age → struct {| Name = "Ada"; Age = 36 |} + let copy: struct {| Name: string; Age: int |} = person
• A parameter annotation converts every argument passed to it, both literals and values, both ways: let greet (p: {| Name: string |}) + let ada = {| Name = "Ada" |} + greet ada; greet {| Name = "Bob" |} → let greet (p: struct {| Name: string |}) + let ada = struct {| Name = "Ada" |} + greet struct {| Name = "Bob" |}
• A return type converts the result and the annotated values it is bound to, both ways: let origin () : {| X: int; Y: int |} = {| X = 0; Y = 0 |} + let start: {| X: int; Y: int |} = origin () → struct {| X: int; Y: int |} in all three places
• A record field converts only its own values and the annotations that read it, both ways: { Info: {| Age: int |}; Tags: {| Count: int |} } + { Info = {| Age = 30 |}; Tags = {| Count = 0 |} } + let info: {| Age: int |} = person.Info → only Info becomes struct {| Age: int |}, struct {| Age = 30 |} and let info: struct {| Age: int |}; Tags is not changed
• A copy-and-update expression converts separately from its source, both ways: the caret on let point = {| X = 1 |} gives struct {| X = 1 |} and leaves {| point with Y = 2 |} alone; the caret on with gives struct {| point with Y = 2 |} and leaves point alone
• A value declared in a second file converts in that file: the caret on let name (p: {| Name: string |}) + name A.person in module B also rewrites let person = {| Name = "Ada" |} in A to struct {| Name = "Ada" |}; the result is checked as a new project and has no errors
• The action titles name the target kind: Convert to struct anonymous record and Convert to reference anonymous record
• Every result is re-type-checked and asserted to have no errors

Not offered

• The caret is not on an anonymous record: let x = 1
• A normal record: type Point = { X: int } + let point = { X = 1 }
• An anonymous record inside a quotation: <@ {| A = 1 |} @>

[T-Gro]

🤖 🕵️ AI review — verify independently.

[T-Gro]

🤖 🕵️ Converting a also converts the independent b argument, producing FS0001 against its explicit reference-record type.

module M

let identity<'T> (x: 'T) = x
let a = identity {| A = 1 |}  // Invoke conversion on A = 1.
let b = identity<{| B: int |}> {| B = 2 |}

[xperiandri]

Fixed in 3021452: propagation stops at a parameter, result or value whose declared type involves a generic type parameter, so converting a leaves b alone. Test: Generic parameter stops the conversion.

[T-Gro]

🤖🕵️ New alias forwarding bypasses the fixed generic boundary and converts independent b, producing FS0001.

let identity<'T> (x: 'T) = x
let alias = identity
let a = alias {| A = 1 |} // Convert this record to struct.
let b: {| B: int |} = alias {| B = 2 |}

[T-Gro]

🤖 🕵️ Converting this valid adjacent application produces idstruct {| A = 1 |}, causing FS0039.

module M

let x = id{| A = 1 |}  // Invoke conversion on A = 1.

[xperiandri]

Fixed in 3021452: struct inserted before {| gets a leading space after an identifier character (by the lexer's categories) or a closing bracket, using the helper shared with tuples. Test: Struct keyword is separated from a name the record follows (id{| A = 1 |} and a name ending in U+0301).

[T-Gro]

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