Unify let, let!, use, use! LetOrUse AST representation.

docs/release-notes/.FSharp.Compiler.Service/10.0.100.md

@@ -30,3 +30,135 @@
 * Mark `Range.Zero` as obsolete in favor of `Range.range0` ([PR #18664](https://github.com/dotnet/fsharp/pull/18664))
 * Use `Synbinding` to model `and!` ([PR #18805](https://github.com/dotnet/fsharp/pull/18805))
 * Redesign #line processing. The original positions (unaffected by #line directives) are now kept in the AST, and `__LINE__` and `__SOURCE_LINE__` show the original line numbers / file names. However, all diagnostics and debug information stays the same (shows the position transformed by the #line directives). ([Issue #18553](https://github.com/dotnet/fsharp/issues/18553), [PR #18699](https://github.com/dotnet/fsharp/pull/18699))
+* Unify `let`, `let!`, `use` and `use!` AST representation. ([PR #18825](https://github.com/dotnet/fsharp/pull/18825))[^1]
+
+### Migration Guidance for AST Users
+
+**Note:** The unified AST introduces two new boolean fields:
+- `isFromSource`: Indicates if the binding comes from user-written code (`true`) or is compiler-generated (`false`)
+- `isBang`: Distinguishes computation expression bindings (`let!`/`use!` = `true`) from regular bindings (`let`/`use` = `false`)
+
+### 1. Pattern Matching Updates
+
+**Before:**
+```fsharp
+match expr with
+| SynExpr.LetOrUse(isRec, isUse, bindings, body, range, trivia) ->
+    // Handle regular let/use
+| SynExpr.LetOrUseBang(spBind, isUse, isFromSource, pat, rhs, andBangs, body, range, trivia) ->
+    // Handle let!/use!
+```
+
+**After:**
+```fsharp
+match expr with
+| SynExpr.LetOrUse(isRec, isUse, isFromSource, isBang, bindings, body, range, trivia) ->
+    if isBang then
+        // This is a let!/use! expression
+        match bindings with
+        | firstBinding :: andBangs ->
+            match firstBinding with
+            | SynBinding(headPat = pat; expr = rhs) ->
+                // pat and rhs extracted from first binding
+                // andBangs contains the and! bindings
+        | [] -> // error case
+    else
+        // This is a regular let/use expression
+```
+
+### 2. Construction Updates
+
+**Before:**
+```fsharp
+// Creating a let! expression
+SynExpr.LetOrUseBang(
+    bindDebugPoint,
+    false,  // isUse
+    true,   // isFromSource
+    pat,
+    rhsExpr,
+    andBangs,
+    bodyExpr,
+    range,
+    trivia
+)
+```
+
+**After:**
+```fsharp
+// Creating a let! expression
+let firstBinding = SynBinding(
+    accessibility = None,
+    kind = SynBindingKind.Normal,
+    isInline = false,
+    isMutable = false,
+    attributes = [],
+    xmlDoc = PreXmlDoc.Empty,
+    valData = SynInfo.emptySynValData,
+    headPat = pat,           // Pattern moved here
+    returnInfo = None,
+    expr = rhsExpr,          // RHS moved here
+    range = range,
+    debugPoint = bindDebugPoint,  // Debug point moved here
+    trivia = bindingTrivia
+)
+SynExpr.LetOrUse(
+    false,  // isRecursive
+    false,  // isUse
+    true,   // isFromSource
+    true,   // isBang (indicates let!)
+    firstBinding :: andBangs,  // All bindings in single list
+    bodyExpr,
+    range,
+    trivia
+)
+```
+
+### 3. Common Migration Patterns
+
+**Checking for computation expressions:**
+```fsharp
+// Before
+match expr with
+| SynExpr.LetOrUseBang _ -> true
+| _ -> false
+
+// After
+match expr with
+| SynExpr.LetOrUse(isBang = true) -> true
+| _ -> false
+```
+
+**Extracting pattern and expression from let!:**
+```fsharp
+// Before
+| SynExpr.LetOrUseBang(_, _, _, pat, rhs, _, _, _, _) ->
+    processBinding pat rhs
+
+// After
+| SynExpr.LetOrUse(isBang = true; bindings = binding :: _) ->
+    match binding with
+    | SynBinding(headPat = pat; expr = rhs) ->
+        processBinding pat rhs
+    | _ -> // error
+```
+
+**Processing and! bindings:**
+```fsharp
+// Before
+| SynExpr.LetOrUseBang(_, _, _, firstPat, firstRhs, andBangs, _, _, _) ->
+    processFirst firstPat firstRhs
+    for andBang in andBangs do
+        processAndBang andBang
+
+// After
+| SynExpr.LetOrUse(isBang = true; bindings = bindings) ->
+    match bindings with
+    | first :: rest ->
+        processBinding first
+        for andBang in rest do
+            processAndBang andBang
+    | [] -> // error
+```
+
+[^1]: See [Migration Guidance for AST Users](#migration-guidance-for-ast-users) section for detailed information on how to update your code to work with the unified AST representation.

src/Compiler/Checking/CheckRecordSyntaxHelpers.fs

@@ -180,4 +180,13 @@ let BindOriginalRecdExpr (withExpr: SynExpr * BlockSeparator) mkRecdExpr =
              None,
              SynBindingTrivia.Zero)
 
-    SynExpr.LetOrUse(false, false, [ binding ], mkRecdExpr (Some withExpr), mOrigExprSynth, SynExprLetOrUseTrivia.Zero)
+    SynExpr.LetOrUse(
+        isRecursive = false,
+        isUse = false,
+        isFromSource = false, // compiler generated during desugaring
+        isBang = false,
+        bindings = [ binding ],
+        body = mkRecdExpr (Some withExpr),
+        range = mOrigExprSynth,
+        trivia = SynExprLetOrUseTrivia.Zero
+    )