Remove LetOrUseKeyword from SynExprLetOrUseTrivia

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

@@ -26,5 +26,6 @@
 * Parallel compilation features: ref resolution, graph based checking, ILXGen and optimization enabled by default ([PR #18998](https://github.com/dotnet/fsharp/pull/18998))
 * Make graph based type checking and parallel optimizations deterministic ([PR #19028](https://github.com/dotnet/fsharp/pull/19028))
 
-
 ### Breaking Changes
+
+* Remove LetOrUseKeyword from SynExprLetOrUseTrivia. Information is now captured by SynLeadingKeyword in SynBinding. ([PR #19090](https://github.com/dotnet/fsharp/pull/19090)) 

src/Compiler/Checking/Expressions/CheckComputationExpressions.fs

@@ -862,34 +862,22 @@ let private mkTypedHeadPat (SynBinding(headPat = headPattern; returnInfo = retur
 [<return: Struct>]
 let (|ExprAsUseBang|_|) expr =
     match expr with
-    | SynExpr.LetOrUse(
-        isUse = true
-        isFromSource = isFromSource
-        isBang = true
-        bindings = bindings
-        body = innerComp
-        trivia = { LetOrUseKeyword = mBind }) ->
+    | SynExpr.LetOrUse(isUse = true; isFromSource = isFromSource; isBang = true; bindings = bindings; body = innerComp) ->
         match bindings with
-        | SynBinding(debugPoint = spBind; expr = rhsExpr) as binding :: andBangs ->
+        | SynBinding(debugPoint = spBind; expr = rhsExpr; trivia = { LeadingKeyword = leadingKeyword }) as binding :: andBangs ->
             let pat = mkTypedHeadPat binding
-            ValueSome(spBind, isFromSource, pat, rhsExpr, andBangs, innerComp, mBind)
+            ValueSome(spBind, isFromSource, pat, rhsExpr, andBangs, innerComp, leadingKeyword.Range)
         | _ -> ValueNone
     | _ -> ValueNone
 
 [<return: Struct>]
 let (|ExprAsLetBang|_|) expr =
     match expr with
-    | SynExpr.LetOrUse(
-        isUse = false
-        isFromSource = isFromSource
-        isBang = true
-        bindings = bindings
-        body = innerComp
-        trivia = { LetOrUseKeyword = mBind }) ->
+    | SynExpr.LetOrUse(isUse = false; isFromSource = isFromSource; isBang = true; bindings = bindings; body = innerComp) ->
         match bindings with
-        | SynBinding(debugPoint = spBind; expr = letRhsExpr) as binding :: andBangBindings ->
+        | SynBinding(debugPoint = spBind; expr = letRhsExpr; trivia = { LeadingKeyword = leadingKeyword }) as binding :: andBangBindings ->
             let letPat = mkTypedHeadPat binding
-            ValueSome(spBind, isFromSource, letPat, letRhsExpr, andBangBindings, innerComp, mBind)
+            ValueSome(spBind, isFromSource, letPat, letRhsExpr, andBangBindings, innerComp, leadingKeyword.Range)
         | _ -> ValueNone
     | _ -> ValueNone
 
@@ -1832,12 +1820,16 @@ let rec TryTranslateComputationExpression
         | SynExpr.LetOrUse(
             isUse = true
             isBang = false
-            bindings = [ SynBinding(kind = SynBindingKind.Normal; headPat = pat; expr = rhsExpr; debugPoint = spBind) ]
-            body = innerComp
-            trivia = { LetOrUseKeyword = mBind }) ->
+            bindings = [ SynBinding(
+                             kind = SynBindingKind.Normal
+                             headPat = pat
+                             expr = rhsExpr
+                             debugPoint = spBind
+                             trivia = { LeadingKeyword = leadingKeyword }) ]
+            body = innerComp) ->
 
             if ceenv.isQuery then
-                error (Error(FSComp.SR.tcUseMayNotBeUsedInQueries (), mBind))
+                error (Error(FSComp.SR.tcUseMayNotBeUsedInQueries (), leadingKeyword.Range))
 
             let innerCompRange = innerComp.Range
 
@@ -1859,10 +1851,10 @@ let rec TryTranslateComputationExpression
                     innerCompRange
                 )
 
-            requireBuilderMethod "Using" ceenv mBind mBind
+            requireBuilderMethod "Using" ceenv leadingKeyword.Range leadingKeyword.Range
 
             Some(
-                translatedCtxt (mkSynCall "Using" mBind [ rhsExpr; consumeExpr ] ceenv.builderValName)
+                translatedCtxt (mkSynCall "Using" leadingKeyword.Range [ rhsExpr; consumeExpr ] ceenv.builderValName)
                 |> addBindDebugPoint spBind
             )
 

src/Compiler/Checking/Expressions/CheckExpressions.fs

@@ -6073,8 +6073,9 @@ 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.LetOrUse (isBang = true; trivia = { LetOrUseKeyword = m }) ->
+    | SynExpr.WhileBang (range = m) ->
+        error(Error(FSComp.SR.tcConstructRequiresComputationExpression(), m))
+    | SynExpr.LetOrUse (isBang = true; range = m) ->
         error(Error(FSComp.SR.tcConstructRequiresComputationExpression(), m))
 
     | SynExpr.IndexFromEnd (rightExpr, m) ->

src/Compiler/Checking/Expressions/CheckSequenceExpressions.fs

@@ -231,10 +231,10 @@ let TcSequenceExpression (cenv: TcFileState) env tpenv comp (overallTy: OverallT
         // 'use x = expr in expr'
         | SynExpr.LetOrUse(
             isUse = true
-            bindings = [ SynBinding(kind = SynBindingKind.Normal; headPat = pat; expr = rhsExpr) ]
+            bindings = [ SynBinding(
+                             kind = SynBindingKind.Normal; headPat = pat; expr = rhsExpr; trivia = { LeadingKeyword = leadingKeyword }) ]
             body = innerComp
-            range = wholeExprMark
-            trivia = { LetOrUseKeyword = mBind }) ->
+            range = wholeExprMark) ->
 
             let bindPatTy = NewInferenceType g
             let inputExprTy = NewInferenceType g
@@ -257,9 +257,9 @@ let TcSequenceExpression (cenv: TcFileState) env tpenv comp (overallTy: OverallT
             let matchv, matchExpr =
                 compileSeqExprMatchClauses cenv envinner inputExprMark (pat', vspecs) innerExpr (Some inputExpr) bindPatTy genOuterTy
 
-            let consumeExpr = mkLambda mBind matchv (matchExpr, genOuterTy)
+            let consumeExpr = mkLambda leadingKeyword.Range matchv (matchExpr, genOuterTy)
 
-            // The 'mBind' is attached to the lambda
+            // The 'leadingKeyword.Range' is attached to the lambda
             Some(mkSeqUsing cenv env wholeExprMark bindPatTy genOuterTy inputExpr consumeExpr, tpenv)
 
         | SynExpr.LetOrUse(isBang = true; range = m) -> error (Error(FSComp.SR.tcUseForInSequenceExpression (), m))

src/Compiler/SyntaxTree/ParseHelpers.fs

@@ -875,7 +875,7 @@ let mkAndBang
 
     let trivia: SynBindingTrivia =
         {
-            LeadingKeyword = SynLeadingKeyword.And mKeyword
+            LeadingKeyword = SynLeadingKeyword.AndBang mKeyword
             InlineKeyword = mIn
             EqualsRange = Some mEquals
         }
@@ -1077,20 +1077,16 @@ let mkLetExpression
         mWhole: range,
         body: SynExpr,
         bindingInfo: BindingSet option,
-        bangInfo: (SynPat * SynBindingReturnInfo option * SynExpr * SynBinding list * range * range option * bool) option
+        bangInfo: (SynPat * SynBindingReturnInfo option * SynExpr * SynBinding list * SynLeadingKeyword * range option * bool) option
     ) =
     if isBang then
         match bangInfo with
-        | Some(pat, returnInfo, rhs, andBangs, mKeyword, mEquals, isUse) ->
-            let spBind = DebugPointAtBinding.Yes(unionRanges mKeyword rhs.Range)
+        | Some(pat, returnInfo, rhs, andBangs, leadingKeyword, mEquals, isUse) ->
+            let spBind = DebugPointAtBinding.Yes(unionRanges leadingKeyword.Range rhs.Range)
 
             let trivia: SynBindingTrivia =
                 {
-                    LeadingKeyword =
-                        if isUse then
-                            SynLeadingKeyword.Use mKeyword
-                        else
-                            SynLeadingKeyword.Let mKeyword
+                    LeadingKeyword = leadingKeyword
                     InlineKeyword = mIn
                     EqualsRange = mEquals
                 }
@@ -1107,7 +1103,7 @@ let mkLetExpression
                     headPat = pat,
                     returnInfo = returnInfo,
                     expr = rhs,
-                    range = unionRanges mKeyword rhs.Range,
+                    range = unionRanges leadingKeyword.Range rhs.Range,
                     debugPoint = spBind,
                     trivia = trivia
                 )
@@ -1122,7 +1118,6 @@ let mkLetExpression
                 range = mWhole,
                 trivia =
                     {
-                        LetOrUseKeyword = mKeyword
                         InKeyword = mIn
                         EqualsRange = mEquals
                     }
@@ -1146,11 +1141,6 @@ let mkLetExpression
                 mIn
                 |> Option.bind (fun (mIn: range) -> if posEq mIn.Start body.Range.Start then None else Some mIn)
 
-            let mLetOrUse =
-                match decls with
-                | SynBinding(trivia = trivia) :: _ -> trivia.LeadingKeyword.Range
-                | _ -> range0
-
             let mEquals =
                 match decls with
                 | SynBinding(trivia = trivia) :: _ -> trivia.EqualsRange
@@ -1166,7 +1156,6 @@ let mkLetExpression
                 range = mWhole,
                 trivia =
                     {
-                        LetOrUseKeyword = mLetOrUse
                         InKeyword = mIn'
                         EqualsRange = mEquals
                     }

src/Compiler/SyntaxTree/ParseHelpers.fsi

@@ -204,7 +204,8 @@ val mkLetExpression:
     mWhole: range *
     body: SynExpr *
     bindingInfo: BindingSet option *
-    bangInfo: (SynPat * SynBindingReturnInfo option * SynExpr * SynBinding list * range * range option * bool) option ->
+    bangInfo:
+        (SynPat * SynBindingReturnInfo option * SynExpr * SynBinding list * SynLeadingKeyword * range option * bool) option ->
         SynExpr
 
 val mkAndBang:

src/Compiler/SyntaxTree/SyntaxTrivia.fs

@@ -89,20 +89,80 @@ type SynExprDotLambdaTrivia =
         DotRange: range
     }
 
+[<NoEquality; NoComparison; RequireQualifiedAccess>]
+type SynLeadingKeyword =
+    | Let of letRange: range
+    | LetBang of letBangRange: range
+    | LetRec of letRange: range * recRange: range
+    | And of andRange: range
+    | AndBang of andBangRange: range
+    | Use of useRange: range
+    | UseBang of useBangRange: range
+    | UseRec of useRange: range * recRange: range
+    | Extern of externRange: range
+    | Member of memberRange: range
+    | MemberVal of memberRange: range * valRange: range
+    | Override of overrideRange: range
+    | OverrideVal of overrideRange: range * valRange: range
+    | Abstract of abstractRange: range
+    | AbstractMember of abstractRange: range * memberRange: range
+    | Static of staticRange: range
+    | StaticMember of staticRange: range * memberRange: range
+    | StaticMemberVal of staticRange: range * memberRange: range * valRange: range
+    | StaticAbstract of staticRange: range * abstractRange: range
+    | StaticAbstractMember of staticRange: range * abstractMember: range * memberRange: range
+    | StaticVal of staticRange: range * valRange: range
+    | StaticLet of staticRange: range * letRange: range
+    | StaticLetRec of staticRange: range * letRange: range * recRange: range
+    | StaticDo of staticRange: range * doRange: range
+    | Default of defaultRange: range
+    | DefaultVal of defaultRange: range * valRange: range
+    | Val of valRange: range
+    | New of newRange: range
+    | Do of doRange: range
+    | Synthetic
+
+    member this.Range =
+        match this with
+        | Let m
+        | LetBang m
+        | And m
+        | AndBang m
+        | Use m
+        | UseBang m
+        | Extern m
+        | Member m
+        | Override m
+        | Abstract m
+        | Default m
+        | Val m
+        | New m
+        | Do m
+        | Static m -> m
+        | LetRec(m1, m2)
+        | UseRec(m1, m2)
+        | AbstractMember(m1, m2)
+        | StaticMember(m1, m2)
+        | StaticAbstract(m1, m2)
+        | StaticAbstractMember(m1, _, m2)
+        | StaticVal(m1, m2)
+        | StaticLet(m1, m2)
+        | StaticLetRec(m1, _, m2)
+        | StaticDo(m1, m2)
+        | DefaultVal(m1, m2)
+        | MemberVal(m1, m2)
+        | OverrideVal(m1, m2)
+        | StaticMemberVal(m1, _, m2) -> unionRanges m1 m2
+        | Synthetic -> range0
+
 [<NoEquality; NoComparison>]
 type SynExprLetOrUseTrivia =
     {
-        LetOrUseKeyword: range
         InKeyword: range option
         EqualsRange: range option
     }
 
-    static member Zero: SynExprLetOrUseTrivia =
-        {
-            InKeyword = None
-            LetOrUseKeyword = range0
-            EqualsRange = None
-        }
+    static member Zero: SynExprLetOrUseTrivia = { InKeyword = None; EqualsRange = None }
 
 [<NoEquality; NoComparison>]
 type SynExprMatchTrivia =
@@ -217,66 +277,6 @@ type SynTypeDefnSigTrivia =
             WithKeyword = None
         }
 
-[<NoEquality; NoComparison; RequireQualifiedAccess>]
-type SynLeadingKeyword =
-    | Let of letRange: range
-    | LetRec of letRange: range * recRange: range
-    | And of andRange: range
-    | Use of useRange: range
-    | UseRec of useRange: range * recRange: range
-    | Extern of externRange: range
-    | Member of memberRange: range
-    | MemberVal of memberRange: range * valRange: range
-    | Override of overrideRange: range
-    | OverrideVal of overrideRange: range * valRange: range
-    | Abstract of abstractRange: range
-    | AbstractMember of abstractRange: range * memberRange: range
-    | Static of staticRange: range
-    | StaticMember of staticRange: range * memberRange: range
-    | StaticMemberVal of staticRange: range * memberRange: range * valRange: range
-    | StaticAbstract of staticRange: range * abstractRange: range
-    | StaticAbstractMember of staticRange: range * abstractMember: range * memberRange: range
-    | StaticVal of staticRange: range * valRange: range
-    | StaticLet of staticRange: range * letRange: range
-    | StaticLetRec of staticRange: range * letRange: range * recRange: range
-    | StaticDo of staticRange: range * doRange: range
-    | Default of defaultRange: range
-    | DefaultVal of defaultRange: range * valRange: range
-    | Val of valRange: range
-    | New of newRange: range
-    | Do of doRange: range
-    | Synthetic
-
-    member this.Range =
-        match this with
-        | Let m
-        | And m
-        | Use m
-        | Extern m
-        | Member m
-        | Override m
-        | Abstract m
-        | Default m
-        | Val m
-        | New m
-        | Do m
-        | Static m -> m
-        | LetRec(m1, m2)
-        | UseRec(m1, m2)
-        | AbstractMember(m1, m2)
-        | StaticMember(m1, m2)
-        | StaticAbstract(m1, m2)
-        | StaticAbstractMember(m1, _, m2)
-        | StaticVal(m1, m2)
-        | StaticLet(m1, m2)
-        | StaticLetRec(m1, _, m2)
-        | StaticDo(m1, m2)
-        | DefaultVal(m1, m2)
-        | MemberVal(m1, m2)
-        | OverrideVal(m1, m2)
-        | StaticMemberVal(m1, _, m2) -> unionRanges m1 m2
-        | Synthetic -> range0
-
 [<NoEquality; NoComparison>]
 type SynBindingTrivia =
     {