Allow let! and use! binding with type annotation without parentheses. (#18508)

Author: edgarfgp

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

@@ -0,0 +1,3 @@
+### Fixed
+
+* Allow `let!` and `use!` type annotations without requiring parentheses ([PR #18508](https://github.com/dotnet/fsharp/pull/18508))

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

@@ -7,6 +7,7 @@
 * Allow `_` in `use!` bindings values (lift FS1228 restriction) ([PR #18487](https://github.com/dotnet/fsharp/pull/18487))
 * Warn when `unit` is passed to an `obj`-typed argument  ([PR #18330](https://github.com/dotnet/fsharp/pull/18330))
 * 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))
 
 ### Fixed
 

src/Compiler/Checking/Expressions/CheckComputationExpressions.fs

@@ -1793,6 +1793,9 @@ let rec TryTranslateComputationExpression
                 let supportsUseBangBindingValueDiscard =
                     ceenv.cenv.g.langVersion.SupportsFeature LanguageFeature.UseBangBindingValueDiscard
 
+                let supportsTypedLetOrUseBang =
+                    ceenv.cenv.g.langVersion.SupportsFeature LanguageFeature.AllowTypedLetOrUseBang
+
                 //   use! x = ...
                 //   use! (x) = ...
                 //   use! (__) = ...
@@ -1802,6 +1805,7 @@ let rec TryTranslateComputationExpression
                     match pat with
                     | SynPat.Named(ident = SynIdent(id, _); isThisVal = false) -> id, pat
                     | SynPat.LongIdent(longDotId = SynLongIdent(id = [ id ])) -> id, pat
+                    | SynPat.Typed(pat = pat) when supportsTypedLetOrUseBang -> extractIdentifierFromPattern pat
                     | SynPat.Wild(m) when supportsUseBangBindingValueDiscard ->
                         // To properly call the Using(disposable) CE member, we need to convert the wildcard to a SynPat.Named
                         let tmpIdent = mkSynId m "_"

src/Compiler/FSComp.txt

@@ -1800,6 +1800,7 @@ featureSupportValueOptionsAsOptionalParameters,"Support ValueOption as valid typ
 featureSupportWarnWhenUnitPassedToObjArg,"Warn when unit is passed to a member accepting `obj` argument, e.g. `Method(o:obj)` will warn if called via `Method()`."
 featureUseBangBindingValueDiscard,"Allows use! _ = ... in computation expressions"
 featureScopedNowarn,"Support for scoped enabling / disabling of warnings by #warn and #nowarn directives, also inside modules"
+featureAllowLetOrUseBangTypeAnnotationWithoutParens,"Allow let! and use! type annotations without requiring parentheses"
 3874,lexWarnDirectiveMustBeFirst,"#nowarn/#warnon directives must appear as the first non-whitespace characters on a line"
 3875,lexWarnDirectiveMustHaveArgs,"Warn directives must have warning number(s) as argument(s)"
 3876,lexWarnDirectivesMustMatch,"There is another %s for this warning already in line %d."

src/Compiler/Facilities/LanguageFeatures.fs

@@ -101,6 +101,7 @@ type LanguageFeature =
     | WarnWhenUnitPassedToObjArg
     | UseBangBindingValueDiscard
     | ScopedNowarn
+    | AllowTypedLetOrUseBang
 
 /// LanguageVersion management
 type LanguageVersion(versionText) =
@@ -233,6 +234,7 @@ type LanguageVersion(versionText) =
                 LanguageFeature.WarnWhenUnitPassedToObjArg, previewVersion
                 LanguageFeature.UseBangBindingValueDiscard, previewVersion
                 LanguageFeature.ScopedNowarn, previewVersion
+                LanguageFeature.AllowTypedLetOrUseBang, previewVersion
             ]
 
     static let defaultLanguageVersion = LanguageVersion("default")
@@ -397,6 +399,7 @@ type LanguageVersion(versionText) =
         | LanguageFeature.WarnWhenUnitPassedToObjArg -> FSComp.SR.featureSupportWarnWhenUnitPassedToObjArg ()
         | LanguageFeature.UseBangBindingValueDiscard -> FSComp.SR.featureUseBangBindingValueDiscard ()
         | LanguageFeature.ScopedNowarn -> FSComp.SR.featureScopedNowarn ()
+        | LanguageFeature.AllowTypedLetOrUseBang -> FSComp.SR.featureAllowLetOrUseBangTypeAnnotationWithoutParens ()
 
     /// Get a version string associated with the given feature.
     static member GetFeatureVersionString feature =

src/Compiler/Facilities/LanguageFeatures.fsi

@@ -92,6 +92,7 @@ type LanguageFeature =
     | WarnWhenUnitPassedToObjArg
     | UseBangBindingValueDiscard
     | ScopedNowarn
+    | AllowTypedLetOrUseBang
 
 /// LanguageVersion management
 type LanguageVersion =

src/Compiler/pars.fsy

@@ -4466,6 +4466,39 @@ declExpr:
        let trivia: SynExprLetOrUseBangTrivia = { LetOrUseBangKeyword = rhs parseState 1 ; EqualsRange = Some mEquals }
        SynExpr.LetOrUseBang(spBind, ($1 = "use"), true, $2, $4, $7, $8, m, trivia) }
 
+  | BINDER headBindingPattern opt_topReturnTypeWithTypeConstraints EQUALS typedSequentialExprBlock IN opt_OBLOCKSEP moreBinders typedSequentialExprBlock %prec expr_let
+     { // Handle type annotations on patterns in let!/use! bindings
+       // Examples: let! x: int = async { return 1 }
+       //           use! _: IDisposable = async { return new MemoryStream() }
+       let spBind = DebugPointAtBinding.Yes(rhs2 parseState 1 7)
+       let pat = 
+         match $3 with 
+         | None -> $2
+         | Some (_, SynReturnInfo((ty, _), _)) -> 
+           SynPat.Typed($2, ty, unionRanges $2.Range ty.Range)
+       parseState.LexBuffer.CheckLanguageFeatureAndRecover LanguageFeature.AllowTypedLetOrUseBang pat.Range
+       let mEquals = rhs parseState 4
+       let m = unionRanges (rhs parseState 1) $9.Range
+       let trivia: SynExprLetOrUseBangTrivia = { LetOrUseBangKeyword = rhs parseState 1 ; EqualsRange = Some mEquals }
+       SynExpr.LetOrUseBang(spBind, ($1 = "use"), true, pat, $5, $8, $9, m, trivia) }
+
+  | OBINDER headBindingPattern opt_topReturnTypeWithTypeConstraints EQUALS typedSequentialExprBlock hardwhiteDefnBindingsTerminator opt_OBLOCKSEP moreBinders typedSequentialExprBlock %prec expr_let
+     { // Handle type annotations on patterns in let!/use! bindings (offside-sensitive version)
+       // This rule maintains consistent handling of binding constructs across different syntactic contexts
+       let report, mIn, _ = $6
+       report (if $1 = "use" then "use!" else "let!") (rhs parseState 1)  // report unterminated error
+       let spBind = DebugPointAtBinding.Yes(unionRanges (rhs parseState 1) $5.Range)
+       let pat = 
+         match $3 with 
+         | None -> $2
+         | Some (_, SynReturnInfo((ty, _), _)) -> 
+           SynPat.Typed($2, ty, unionRanges $2.Range ty.Range)
+       parseState.LexBuffer.CheckLanguageFeatureAndRecover LanguageFeature.AllowTypedLetOrUseBang pat.Range
+       let mEquals = rhs parseState 4
+       let m = unionRanges (rhs parseState 1) $9.Range
+       let trivia: SynExprLetOrUseBangTrivia = { LetOrUseBangKeyword = rhs parseState 1 ; EqualsRange = Some mEquals }
+       SynExpr.LetOrUseBang(spBind, ($1 = "use"), true, pat, $5, $8, $9, m, trivia) }
+
   | OBINDER headBindingPattern EQUALS typedSequentialExprBlock hardwhiteDefnBindingsTerminator opt_OBLOCKSEP error %prec expr_let
      { // error recovery that allows intellisense when writing incomplete computation expressions
        let spBind = DebugPointAtBinding.Yes(unionRanges (rhs parseState 1) $4.Range)