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

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

@@ -21,6 +21,7 @@
 
 ### Changed
 * Use `errorR` instead of `error` in `CheckDeclarations.fs` when possible. ([PR #18645](https://github.com/dotnet/fsharp/pull/18645))
+* Unify `let`, `let!`, `use` and `use!` AST representation. ([PR #18825](https://github.com/dotnet/fsharp/pull/18825))
 
 ### Breaking Changes
 

src/Compiler/Checking/CheckRecordSyntaxHelpers.fs

@@ -180,4 +180,4 @@ let BindOriginalRecdExpr (withExpr: SynExpr * BlockSeparator) mkRecdExpr =
              None,
              SynBindingTrivia.Zero)
 
-    SynExpr.LetOrUse(false, false, [ binding ], mkRecdExpr (Some withExpr), mOrigExprSynth, SynExprLetOrUseTrivia.Zero)
+    SynExpr.LetOrUse(false, false, false, false, [ binding ], mkRecdExpr (Some withExpr), mOrigExprSynth, SynExprLetOrUseTrivia.Zero)

src/Compiler/Checking/Expressions/CheckComputationExpressions.fs

@@ -20,6 +20,7 @@ open FSharp.Compiler.NameResolution
 open FSharp.Compiler.Syntax.PrettyNaming
 open FSharp.Compiler.Syntax
 open FSharp.Compiler.SyntaxTrivia
+open FSharp.Compiler.Xml
 open FSharp.Compiler.SyntaxTreeOps
 open FSharp.Compiler.Text
 open FSharp.Compiler.Text.Range
@@ -856,29 +857,33 @@ let (|OptionalSequential|) e =
 [<return: Struct>]
 let (|ExprAsUseBang|_|) expr =
     match expr with
-    | SynExpr.LetOrUseBang(
-        bindDebugPoint = spBind
+    | SynExpr.LetOrUse(
         isUse = true
         isFromSource = isFromSource
-        pat = pat
-        rhs = rhsExpr
-        andBangs = andBangs
+        isComputed = true
+        bindings = bindings
         body = innerComp
-        trivia = { LetOrUseKeyword = mBind }) -> ValueSome(spBind, isFromSource, pat, rhsExpr, andBangs, innerComp, mBind)
+        trivia = { LetOrUseKeyword = mBind }) ->
+        match bindings with
+        | SynBinding(debugPoint = spBind; headPat = pat; expr = rhsExpr) :: andBangs ->
+            ValueSome(spBind, isFromSource, pat, rhsExpr, andBangs, innerComp, mBind)
+        | _ -> ValueNone
     | _ -> ValueNone
 
 [<return: Struct>]
 let (|ExprAsLetBang|_|) expr =
     match expr with
-    | SynExpr.LetOrUseBang(
-        bindDebugPoint = spBind
+    | SynExpr.LetOrUse(
         isUse = false
         isFromSource = isFromSource
-        pat = letPat
-        rhs = letRhsExpr
-        andBangs = andBangBindings
+        isComputed = true
+        bindings = bindings
         body = innerComp
-        trivia = { LetOrUseKeyword = mBind }) -> ValueSome(spBind, isFromSource, letPat, letRhsExpr, andBangBindings, innerComp, mBind)
+        trivia = { LetOrUseKeyword = mBind }) ->
+        match bindings with
+        | SynBinding(debugPoint = spBind; headPat = letPat; expr = letRhsExpr) :: andBangBindings ->
+            ValueSome(spBind, isFromSource, letPat, letRhsExpr, andBangBindings, innerComp, mBind)
+        | _ -> ValueNone
     | _ -> ValueNone
 
 // "cexpr; cexpr" is treated as builder.Combine(cexpr1, cexpr1)
@@ -1392,19 +1397,26 @@ let rec TryTranslateComputationExpression
 
                     let setCondExpr = SynExpr.Set(SynExpr.Ident idCond, SynExpr.Ident idFirst, mGuard)
 
-                    let bindCondExpr =
-                        SynExpr.LetOrUseBang(
-                            DebugPointAtBinding.NoneAtSticky,
-                            false,
-                            true,
-                            patFirst,
-                            guardExpr,
-                            [],
-                            setCondExpr,
-                            mGuard,
-                            SynExprLetOrUseTrivia.Zero
+                    let binding =
+                        SynBinding(
+                            accessibility = None,
+                            kind = SynBindingKind.Normal,
+                            isInline = false,
+                            isMutable = false,
+                            attributes = [],
+                            xmlDoc = PreXmlDoc.Empty,
+                            valData = SynInfo.emptySynValData,
+                            headPat = patFirst,
+                            returnInfo = None,
+                            expr = guardExpr,
+                            range = guardExpr.Range,
+                            debugPoint = DebugPointAtBinding.NoneAtSticky,
+                            trivia = SynBindingTrivia.Zero
                         )
 
+                    let bindCondExpr =
+                        SynExpr.LetOrUse(false, false, true, true, [ binding ], setCondExpr, mGuard, SynExprLetOrUseTrivia.Zero)
+
                     let whileExpr =
                         SynExpr.While(
                             DebugPointAtWhile.No,
@@ -1420,19 +1432,26 @@ let rec TryTranslateComputationExpression
                             mOrig
                         )
 
-                    SynExpr.LetOrUse(false, false, [ condBinding ], whileExpr, mGuard, SynExprLetOrUseTrivia.Zero)
+                    SynExpr.LetOrUse(false, false, false, false, [ condBinding ], whileExpr, mGuard, SynExprLetOrUseTrivia.Zero)
+
+                let binding =
+                    SynBinding(
+                        accessibility = None,
+                        kind = SynBindingKind.Normal,
+                        isInline = false,
+                        isMutable = false,
+                        attributes = [],
+                        xmlDoc = PreXmlDoc.Empty,
+                        valData = SynInfo.emptySynValData,
+                        headPat = patFirst,
+                        returnInfo = None,
+                        expr = guardExpr,
+                        range = guardExpr.Range,
+                        debugPoint = DebugPointAtBinding.NoneAtSticky,
+                        trivia = SynBindingTrivia.Zero
+                    )
 
-                SynExpr.LetOrUseBang(
-                    DebugPointAtBinding.NoneAtSticky,
-                    false,
-                    true,
-                    patFirst,
-                    guardExpr,
-                    [],
-                    body,
-                    mGuard,
-                    SynExprLetOrUseTrivia.Zero
-                )
+                SynExpr.LetOrUse(false, false, true, true, [ binding ], body, mGuard, SynExprLetOrUseTrivia.Zero)
 
             TryTranslateComputationExpression ceenv CompExprTranslationPass.Initial q varSpace rewrittenWhileExpr translatedCtxt
 
@@ -1620,23 +1639,30 @@ let rec TryTranslateComputationExpression
                             | DebugPointAtSequential.SuppressStmt -> DebugPointAtBinding.Yes m
                             | DebugPointAtSequential.SuppressNeither -> DebugPointAtBinding.Yes m
 
+                        let binding =
+                            SynBinding(
+                                accessibility = None,
+                                kind = SynBindingKind.Normal,
+                                isInline = false,
+                                isMutable = false,
+                                attributes = [],
+                                xmlDoc = PreXmlDoc.Empty,
+                                valData = SynInfo.emptySynValData,
+                                headPat = SynPat.Const(SynConst.Unit, rhsExpr.Range),
+                                returnInfo = None,
+                                expr = rhsExpr,
+                                range = rhsExpr.Range,
+                                debugPoint = sp,
+                                trivia = SynBindingTrivia.Zero
+                            )
+
                         Some(
                             TranslateComputationExpression
                                 ceenv
                                 CompExprTranslationPass.Initial
                                 q
                                 varSpace
-                                (SynExpr.LetOrUseBang(
-                                    sp,
-                                    false,
-                                    true,
-                                    SynPat.Const(SynConst.Unit, rhsExpr.Range),
-                                    rhsExpr,
-                                    [],
-                                    innerComp2,
-                                    m,
-                                    SynExprLetOrUseTrivia.Zero
-                                ))
+                                (SynExpr.LetOrUse(false, false, true, true, [ binding ], innerComp2, m, SynExprLetOrUseTrivia.Zero))
                                 translatedCtxt
                         )
 
@@ -1704,7 +1730,7 @@ let rec TryTranslateComputationExpression
                 )
 
         // 'let binds in expr'
-        | SynExpr.LetOrUse(isRec, false, binds, innerComp, m, trivia) ->
+        | SynExpr.LetOrUse(isRec, false, isFromSource, false, binds, innerComp, m, trivia) ->
 
             // For 'query' check immediately
             if ceenv.isQuery then
@@ -1737,12 +1763,13 @@ let rec TryTranslateComputationExpression
 
             Some(
                 TranslateComputationExpression ceenv CompExprTranslationPass.Initial q varSpace innerComp (fun holeFill ->
-                    translatedCtxt (SynExpr.LetOrUse(isRec, false, binds, holeFill, m, trivia)))
+                    translatedCtxt (SynExpr.LetOrUse(isRec, false, isFromSource, false, binds, holeFill, m, trivia)))
             )
 
         // 'use x = expr in expr'
         | SynExpr.LetOrUse(
             isUse = true
+            isComputed = false
             bindings = [ SynBinding(kind = SynBindingKind.Normal; headPat = pat; expr = rhsExpr; debugPoint = spBind) ]
             body = innerComp
             trivia = { LetOrUseKeyword = mBind }) ->
@@ -2365,17 +2392,24 @@ and ConsumeCustomOpClauses
                     // Rebind using either for ... or let!....
                     let rebind =
                         if maintainsVarSpaceUsingBind then
-                            SynExpr.LetOrUseBang(
-                                DebugPointAtBinding.NoneAtLet,
-                                false,
-                                false,
-                                intoPat,
-                                dataCompAfterOp,
-                                [],
-                                contExpr,
-                                intoPat.Range,
-                                SynExprLetOrUseTrivia.Zero
-                            )
+                            let binding =
+                                SynBinding(
+                                    accessibility = None,
+                                    kind = SynBindingKind.Normal,
+                                    isInline = false,
+                                    isMutable = false,
+                                    attributes = [],
+                                    xmlDoc = PreXmlDoc.Empty,
+                                    valData = SynInfo.emptySynValData,
+                                    headPat = intoPat,
+                                    returnInfo = None,
+                                    expr = dataCompAfterOp,
+                                    range = dataCompAfterOp.Range,
+                                    debugPoint = DebugPointAtBinding.NoneAtLet,
+                                    trivia = SynBindingTrivia.Zero
+                                )
+
+                            SynExpr.LetOrUse(false, false, false, true, [ binding ], contExpr, intoPat.Range, SynExprLetOrUseTrivia.Zero)
                         else
                             SynExpr.ForEach(
                                 DebugPointAtFor.No,
@@ -2406,17 +2440,24 @@ and ConsumeCustomOpClauses
         // Rebind using either for ... or let!....
         let rebind =
             if lastUsesBind then
-                SynExpr.LetOrUseBang(
-                    DebugPointAtBinding.NoneAtLet,
-                    false,
-                    false,
-                    varSpacePat,
-                    dataCompPrior,
-                    [],
-                    compClausesExpr,
-                    compClausesExpr.Range,
-                    SynExprLetOrUseTrivia.Zero
-                )
+                let binding =
+                    SynBinding(
+                        accessibility = None,
+                        kind = SynBindingKind.Normal,
+                        isInline = false,
+                        isMutable = false,
+                        attributes = [],
+                        xmlDoc = PreXmlDoc.Empty,
+                        valData = SynInfo.emptySynValData,
+                        headPat = varSpacePat,
+                        returnInfo = None,
+                        expr = dataCompPrior,
+                        range = dataCompPrior.Range,
+                        debugPoint = DebugPointAtBinding.NoneAtLet,
+                        trivia = SynBindingTrivia.Zero
+                    )
+
+                SynExpr.LetOrUse(false, false, false, true, [ binding ], compClausesExpr, compClausesExpr.Range, SynExprLetOrUseTrivia.Zero)
             else
                 SynExpr.ForEach(
                     DebugPointAtFor.No,
@@ -2546,11 +2587,11 @@ and convertSimpleReturnToExpr (ceenv: ComputationExpressionContext<'a>) comp var
             | Some elseExprOpt ->
                 Some(SynExpr.IfThenElse(guardExpr, thenExpr, elseExprOpt, spIfToThen, isRecovery, mIfToEndOfElseBranch, trivia), None)
 
-    | SynExpr.LetOrUse(isRec, false, binds, innerComp, m, trivia) ->
+    | SynExpr.LetOrUse(isRec, false, isFromSource, false, binds, innerComp, m, trivia) ->
         match convertSimpleReturnToExpr ceenv comp varSpace innerComp with
         | None -> None
         | Some(_, Some _) -> None
-        | Some(innerExpr, None) -> Some(SynExpr.LetOrUse(isRec, false, binds, innerExpr, m, trivia), None)
+        | Some(innerExpr, None) -> Some(SynExpr.LetOrUse(isRec, false, isFromSource, false, binds, innerExpr, m, trivia), None)
 
     | OptionalSequential(CustomOperationClause ceenv (nm, _, _, mClause, _), _) when customOperationMaintainsVarSpaceUsingBind ceenv nm ->
 
@@ -2591,8 +2632,8 @@ and isSimpleExpr ceenv comp =
         && (match elseCompOpt with
             | None -> true
             | Some c -> isSimpleExpr ceenv c)
-    | SynExpr.LetOrUse(body = innerComp) -> isSimpleExpr ceenv innerComp
-    | SynExpr.LetOrUseBang _ -> false
+    | SynExpr.LetOrUse(isComputed = false; body = innerComp) -> isSimpleExpr ceenv innerComp
+    | SynExpr.LetOrUse(isComputed = true) -> false
     | SynExpr.Match(clauses = clauses) ->
         clauses
         |> List.forall (fun (SynMatchClause(resultExpr = innerComp)) -> isSimpleExpr ceenv innerComp)
@@ -2649,17 +2690,24 @@ and TranslateComputationExpression (ceenv: ComputationExpressionContext<'a>) fir
                         | _ -> SynExpr.YieldOrReturn((false, true), SynExpr.Const(SynConst.Unit, m), m, SynExprYieldOrReturnTrivia.Zero)
 
                 let letBangBind =
-                    SynExpr.LetOrUseBang(
-                        DebugPointAtBinding.NoneAtDo,
-                        false,
-                        false,
-                        SynPat.Const(SynConst.Unit, mUnit),
-                        rhsExpr,
-                        [],
-                        bodyExpr,
-                        m,
-                        SynExprLetOrUseTrivia.Zero
-                    )
+                    let binding =
+                        SynBinding(
+                            accessibility = None,
+                            kind = SynBindingKind.Normal,
+                            isInline = false,
+                            isMutable = false,
+                            attributes = [],
+                            xmlDoc = PreXmlDoc.Empty,
+                            valData = SynInfo.emptySynValData,
+                            headPat = SynPat.Const(SynConst.Unit, mUnit),
+                            returnInfo = None,
+                            expr = rhsExpr,
+                            range = rhsExpr.Range,
+                            debugPoint = DebugPointAtBinding.NoneAtDo,
+                            trivia = SynBindingTrivia.Zero
+                        )
+
+                    SynExpr.LetOrUse(false, false, false, true, [ binding ], bodyExpr, m, SynExprLetOrUseTrivia.Zero)
 
                 TranslateComputationExpression ceenv CompExprTranslationPass.Initial q varSpace letBangBind translatedCtxt
 

src/Compiler/Checking/Expressions/CheckExpressions.fs

@@ -6072,7 +6072,7 @@ and TcExprUndelayed (cenv: cenv) (overallTy: OverallTy) env tpenv (synExpr: SynE
     | SynExpr.DoBang (trivia = { DoBangKeyword = m })
     | SynExpr.MatchBang (trivia = { MatchBangKeyword = m })
     | SynExpr.WhileBang (range = m)
-    | SynExpr.LetOrUseBang (trivia = { LetOrUseKeyword = m }) ->
+    | SynExpr.LetOrUse (isComputed = true; trivia = { LetOrUseKeyword = m }) ->
         error(Error(FSComp.SR.tcConstructRequiresComputationExpression(), m))
 
     | SynExpr.IndexFromEnd (rightExpr, m) ->
@@ -9199,7 +9199,7 @@ and TcImplicitOpItemThen (cenv: cenv) overallTy env id sln tpenv mItem delayed =
         | SynExpr.YieldOrReturn _
         | SynExpr.YieldOrReturnFrom _
         | SynExpr.MatchBang _
-        | SynExpr.LetOrUseBang _
+        | SynExpr.LetOrUse (isComputed = true)
         | SynExpr.DoBang _
         | SynExpr.WhileBang _
         | SynExpr.TraitCall _
@@ -10614,7 +10614,7 @@ and TcLinearExprs bodyChecker cenv env overallTy tpenv isCompExpr synExpr cont =
         TcLinearExprs bodyChecker cenv env2 overallTy tpenv isCompExpr expr2 (fun (expr2R, tpenv) ->
             cont (Expr.Sequential (expr1R, expr2R, NormalSeq, m), tpenv))
 
-    | SynExpr.LetOrUse (isRec, isUse, binds, body, m, _) when not (isUse && isCompExpr) ->
+    | SynExpr.LetOrUse (isRec, isUse, _, _, binds, body, m, _) when not (isUse && isCompExpr) ->
         if isRec then
             // TcLinearExprs processes at most one recursive binding, this is not tailcalling
             CheckRecursiveBindingIds binds

src/Compiler/Checking/Expressions/CheckExpressionsOps.fs

@@ -202,9 +202,6 @@ let YieldFree (cenv: TcFileState) expr =
             | SynExpr.While(doExpr = body)
             | SynExpr.WhileBang(doExpr = body)
             | SynExpr.ForEach(bodyExpr = body) -> YieldFree body
-
-            | SynExpr.LetOrUseBang(body = body) -> YieldFree body
-
             | SynExpr.YieldOrReturn(flags = (true, _)) -> false
 
             | _ -> true
@@ -232,7 +229,7 @@ let YieldFree (cenv: TcFileState) expr =
             | SynExpr.WhileBang(doExpr = body)
             | SynExpr.ForEach(bodyExpr = body) -> YieldFree body
 
-            | SynExpr.LetOrUseBang _
+            | SynExpr.LetOrUse(isComputed = true)
             | SynExpr.YieldOrReturnFrom _
             | SynExpr.YieldOrReturn _
             | SynExpr.ImplicitZero _
@@ -256,7 +253,6 @@ let inline IsSimpleSemicolonSequenceElement expr cenv acceptDeprecated =
     | SynExpr.LetOrUse _
     | SynExpr.Do _
     | SynExpr.MatchBang _
-    | SynExpr.LetOrUseBang _
     | SynExpr.While _
     | SynExpr.WhileBang _ -> false
     | _ -> true