Allow typed bindings(and!) in CE without parentheses (#18682)

Author: edgarfgp

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

@@ -9,7 +9,7 @@
 * Fix parsing errors using anonymous records and code quotations ([PR #18603](https://github.com/dotnet/fsharp/pull/18603))
 * Better error message for attribute targets. ([PR #18641](https://github.com/dotnet/fsharp/pull/18641))
 * Fixed: Allow `return`, `return!`, `yield`, `yield!` type annotations without parentheses ([PR #18533](https://github.com/dotnet/fsharp/pull/18533))
-* Allow `let!` and `use!` type annotations without requiring parentheses ([PR #18508](https://github.com/dotnet/fsharp/pull/18508))
+* Allow `let!`, `use!`, `and!` type annotations without requiring parentheses (([PR #18508](https://github.com/dotnet/fsharp/pull/18508) and [PR #18682](https://github.com/dotnet/fsharp/pull/18682)))
 * Fix find all references for F# exceptions ([PR #18565](https://github.com/dotnet/fsharp/pull/18565))
 * Shorthand lambda: fix completion for chained calls and analysis for unfinished expression ([PR #18560](https://github.com/dotnet/fsharp/pull/18560))
 * Completion: fix previous namespace considered opened [PR #18609](https://github.com/dotnet/fsharp/pull/18609)

docs/release-notes/.Language/preview.md

@@ -8,7 +8,7 @@
 * Warn when `unit` is passed to an `obj`-typed argument  ([PR #18330](https://github.com/dotnet/fsharp/pull/18330))
 * Fix parsing errors using anonymous records and units of measures ([PR #18543](https://github.com/dotnet/fsharp/pull/18543))
 * Scoped Nowarn: added the #warnon compiler directive ([Language suggestion #278](https://github.com/fsharp/fslang-suggestions/issues/278), [RFC FS-1146 PR](https://github.com/fsharp/fslang-design/pull/782), [PR #18049](https://github.com/dotnet/fsharp/pull/18049))
-* Allow `let!` and `use!` type annotations without requiring parentheses. ([PR #18508](https://github.com/dotnet/fsharp/pull/18508))
+* Allow `let!`, `use!`, `and!` type annotations without requiring parentheses (([PR #18508](https://github.com/dotnet/fsharp/pull/18508) and [PR #18682](https://github.com/dotnet/fsharp/pull/18682)))
 * Exception names are now validated for illegal characters using the same mechanism as types/modules/namespaces ([Issue #18763](https://github.com/dotnet/fsharp/issues/18763))
 
 ### Fixed

src/Compiler/Checking/Expressions/CheckComputationExpressions.fs

@@ -1794,7 +1794,7 @@ let rec TryTranslateComputationExpression
                     ceenv.cenv.g.langVersion.SupportsFeature LanguageFeature.UseBangBindingValueDiscard
 
                 let supportsTypedLetOrUseBang =
-                    ceenv.cenv.g.langVersion.SupportsFeature LanguageFeature.AllowTypedLetOrUseBang
+                    ceenv.cenv.g.langVersion.SupportsFeature LanguageFeature.AllowTypedLetUseAndBang
 
                 //   use! x = ...
                 //   use! (x) = ...

src/Compiler/Facilities/LanguageFeatures.fs

@@ -102,7 +102,7 @@ type LanguageFeature =
     | UseBangBindingValueDiscard
     | BetterAnonymousRecordParsing
     | ScopedNowarn
-    | AllowTypedLetOrUseBang
+    | AllowTypedLetUseAndBang
 
 /// LanguageVersion management
 type LanguageVersion(versionText) =
@@ -235,7 +235,7 @@ type LanguageVersion(versionText) =
                 LanguageFeature.UseBangBindingValueDiscard, languageVersion100
                 LanguageFeature.BetterAnonymousRecordParsing, languageVersion100
                 LanguageFeature.ScopedNowarn, languageVersion100
-                LanguageFeature.AllowTypedLetOrUseBang, languageVersion100
+                LanguageFeature.AllowTypedLetUseAndBang, languageVersion100
                 LanguageFeature.UnmanagedConstraintCsharpInterop, languageVersion100
                 LanguageFeature.AllowAccessModifiersToAutoPropertiesGettersAndSetters, languageVersion100
 
@@ -408,7 +408,7 @@ type LanguageVersion(versionText) =
         | LanguageFeature.UseBangBindingValueDiscard -> FSComp.SR.featureUseBangBindingValueDiscard ()
         | LanguageFeature.BetterAnonymousRecordParsing -> FSComp.SR.featureBetterAnonymousRecordParsing ()
         | LanguageFeature.ScopedNowarn -> FSComp.SR.featureScopedNowarn ()
-        | LanguageFeature.AllowTypedLetOrUseBang -> FSComp.SR.featureAllowLetOrUseBangTypeAnnotationWithoutParens ()
+        | LanguageFeature.AllowTypedLetUseAndBang -> FSComp.SR.featureAllowLetOrUseBangTypeAnnotationWithoutParens ()
 
     /// Get a version string associated with the given feature.
     static member GetFeatureVersionString feature =

src/Compiler/Facilities/LanguageFeatures.fsi

@@ -93,7 +93,7 @@ type LanguageFeature =
     | UseBangBindingValueDiscard
     | BetterAnonymousRecordParsing
     | ScopedNowarn
-    | AllowTypedLetOrUseBang
+    | AllowTypedLetUseAndBang
 
 /// LanguageVersion management
 type LanguageVersion =

src/Compiler/SyntaxTree/ParseHelpers.fs

@@ -867,41 +867,19 @@ let mkClassMemberLocalBindings
 
     SynMemberDefn.LetBindings(decls, isStatic, isRec, mWhole)
 
-let mkLocalBindings (mWhole, BindingSetPreAttrs(_, isRec, isUse, declsPreAttrs, _), mIn, body: SynExpr) =
-    let ignoredFreeAttrs, decls = declsPreAttrs [] None
+/// Creates a SynExprAndBang node for and! bindings in computation expressions
+let mkAndBang (mKeyword: range, pat: SynPat, rhs: SynExpr, mWhole: range, mEquals: range, mIn: range option) =
+    let spBind = DebugPointAtBinding.Yes(unionRanges mKeyword rhs.Range)
 
-    let mWhole =
-        match decls with
-        | SynBinding(xmlDoc = xmlDoc) :: _ -> unionRangeWithXmlDoc xmlDoc mWhole
-        | _ -> mWhole
-
-    if not (isNil ignoredFreeAttrs) then
-        warning (Error(FSComp.SR.parsAttributesIgnored (), mWhole))
-
-    let mIn =
-        mIn
-        |> Option.bind (fun (mIn: range) ->
-            if Position.posEq mIn.Start body.Range.Start then
-                None
-            else
-                Some mIn)
-
-    let mLetOrUse =
-        match decls with
-        | SynBinding(trivia = trivia) :: _ -> trivia.LeadingKeyword.Range
-        | _ -> range0
-
-    SynExpr.LetOrUse(
-        isRec,
-        isUse,
-        decls,
-        body,
-        mWhole,
+    let trivia: SynExprAndBangTrivia =
         {
-            LetOrUseKeyword = mLetOrUse
+            AndBangKeyword = mKeyword
+            EqualsRange = mEquals
             InKeyword = mIn
         }
-    )
+
+    // For and!, isUse is always true, isFromSource is always true
+    SynExprAndBang(spBind, false, true, pat, rhs, mWhole, trivia)
 
 let mkDefnBindings (mWhole, BindingSetPreAttrs(_, isRec, isUse, declsPreAttrs, _bindingSetRange), attrs, vis, attrsm) =
     if isUse then
@@ -1073,3 +1051,70 @@ let leadingKeywordIsAbstract =
     | SynLeadingKeyword.StaticAbstract _
     | SynLeadingKeyword.StaticAbstractMember _ -> true
     | _ -> false
+
+/// Unified helper for creating let/let!/use/use! expressions
+/// Creates either SynExpr.LetOrUse or SynExpr.LetOrUseBang based on isBang parameter
+/// Handles all four cases: 'let', 'let!', 'use', and 'use!'
+let mkLetExpression
+    (
+        isBang: bool,
+        mKeyword: range,
+        mIn: Option<range>,
+        mWhole: range,
+        body: SynExpr,
+        bindingInfo: (bool * BindingSet) option,
+        bangInfo: (SynPat * SynExpr * SynExprAndBang list * range option * bool) option
+    ) =
+    if isBang then
+        match bangInfo with
+        | Some(pat, rhs, andBangs, mEquals, isUse) ->
+            // Create let! or use! expression
+            let spBind = DebugPointAtBinding.Yes(unionRanges mKeyword rhs.Range)
+
+            let trivia: SynExprLetOrUseBangTrivia =
+                {
+                    LetOrUseBangKeyword = mKeyword
+                    EqualsRange = mEquals
+                }
+            // isFromSource is true for user-written code
+            SynExpr.LetOrUseBang(spBind, isUse, true, pat, rhs, andBangs, body, mWhole, trivia)
+        | None -> SynExpr.FromParseError(body, mWhole)
+    else
+        match bindingInfo with
+        | Some(isRec, BindingSetPreAttrs(_, _, isUse, declsPreAttrs, _)) ->
+            // Create regular let or use expression
+            let ignoredFreeAttrs, decls = declsPreAttrs [] None
+
+            let mWhole' =
+                match decls with
+                | SynBinding(xmlDoc = xmlDoc) :: _ -> unionRangeWithXmlDoc xmlDoc mWhole
+                | _ -> mWhole
+
+            if not (isNil ignoredFreeAttrs) then
+                warning (Error(FSComp.SR.parsAttributesIgnored (), mWhole'))
+
+            let mIn' =
+                mIn
+                |> Option.bind (fun (mIn: range) ->
+                    if Position.posEq mIn.Start body.Range.Start then
+                        None
+                    else
+                        Some mIn)
+
+            let mLetOrUse =
+                match decls with
+                | SynBinding(trivia = trivia) :: _ -> trivia.LeadingKeyword.Range
+                | _ -> range0
+
+            SynExpr.LetOrUse(
+                isRec,
+                isUse, // Pass through the isUse flag from binding info
+                decls,
+                body,
+                mWhole',
+                {
+                    LetOrUseKeyword = mLetOrUse
+                    InKeyword = mIn'
+                }
+            )
+        | None -> SynExpr.FromParseError(body, mWhole)

src/Compiler/SyntaxTree/ParseHelpers.fsi

@@ -196,7 +196,20 @@ val mkClassMemberLocalBindings:
     isStatic: bool * initialRangeOpt: range option * attrs: SynAttributes * vis: SynAccess option * BindingSet ->
         SynMemberDefn
 
-val mkLocalBindings: mWhole: range * BindingSet * mIn: range option * body: SynExpr -> SynExpr
+/// Creates either SynExpr.LetOrUse or SynExpr.LetOrUseBang based on isBang parameter
+/// Handles all four cases: 'let', 'let!', 'use', and 'use!'
+val mkLetExpression:
+    isBang: bool *
+    mKeyword: range *
+    mIn: range option *
+    mWhole: range *
+    body: SynExpr *
+    bindingInfo: (bool * BindingSet) option *
+    bangInfo: (SynPat * SynExpr * SynExprAndBang list * range option * bool) option ->
+        SynExpr
+
+val mkAndBang:
+    mKeyword: range * pat: SynPat * rhs: SynExpr * mWhole: range * mEquals: range * mIn: range option -> SynExprAndBang
 
 val mkDefnBindings:
     mWhole: range * BindingSet * attrs: SynAttributes * vis: SynAccess option * attrsm: range -> SynModuleDecl list