Allow _ in use! bindings values

Author: edgarfgp

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

@@ -25,6 +25,7 @@
 * Fixed [#18433](https://github.com/dotnet/fsharp/issues/18433), a rare case of an internal error in xml comment processing. ([PR #18436](https://github.com/dotnet/fsharp/pull/18436))
 * Fix confusing type inference error in task expression ([Issue #13789](https://github.com/dotnet/fsharp/issues/13789), [PR #18450](https://github.com/dotnet/fsharp/pull/18450))
 * Fix missing `null` highlighting in tooltips ([PR #18457](https://github.com/dotnet/fsharp/pull/18457))
+* Allow `_` in `use!` bindings values (lift FS1228 restriction) ([PR #18189](https://github.com/dotnet/fsharp/pull/18189))
 * Make `[<CallerMemberName; Struct>]` combination work([PR #18444](https://github.com/dotnet/fsharp/pull/18444/))
 
 ### Added

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

@@ -4,6 +4,7 @@
 * Deprecate places where `seq` can be omitted. ([Language suggestion #1033](https://github.com/fsharp/fslang-suggestions/issues/1033), [PR #17772](https://github.com/dotnet/fsharp/pull/17772))
 * Added type conversions cache, only enabled for compiler runs ([PR#17668](https://github.com/dotnet/fsharp/pull/17668))
 * Support ValueOption + Struct attribute as optional parameter for methods ([Language suggestion #1136](https://github.com/fsharp/fslang-suggestions/issues/1136), [PR #18098](https://github.com/dotnet/fsharp/pull/18098))
+* Allow `_` in `use!` bindings values (lift FS1228 restriction) ([PR #18189](https://github.com/dotnet/fsharp/pull/18189))
 * Warn when `unit` is passed to an `obj`-typed argument  ([PR #18330](https://github.com/dotnet/fsharp/pull/18330))
 
 ### Fixed

src/Compiler/Checking/Expressions/CheckComputationExpressions.fs

@@ -4,6 +4,7 @@
 /// with generalization at appropriate points.
 module internal FSharp.Compiler.CheckComputationExpressions
 
+open FSharp.Compiler.TcGlobals
 open Internal.Utilities.Library
 open FSharp.Compiler.AccessibilityLogic
 open FSharp.Compiler.AttributeChecking
@@ -1809,17 +1810,29 @@ let rec TryTranslateComputationExpression
                     translatedCtxt
             )
 
-        // 'use! pat = e1 in e2' --> build.Bind(e1, (function  _argN -> match _argN with pat -> build.Using(x, (fun _argN -> match _argN with pat -> e2))))
+        // 'use! pat = e1 in e2' --> build.Bind(e1, (function _argN -> match _argN with pat -> build.Using(x, (fun _argN -> match _argN with pat -> e2))))
+        // or
+        // 'use! _ = e1 in e2' --> build.Bind(e1, (fun _argN -> e2))
         | ExprAsUseBang(spBind, isFromSource, pat, rhsExpr, andBangs, innerComp, mBind) ->
             if ceenv.isQuery then
                 error (Error(FSComp.SR.tcBindMayNotBeUsedInQueries (), mBind))
 
-            match pat, andBangs with
-            | (SynPat.Named(ident = SynIdent(id, _); isThisVal = false) | SynPat.LongIdent(longDotId = SynLongIdent(id = [ id ]))), [] ->
+            match andBangs with
+            | [] ->
                 // Valid pattern case - handle with Using + Bind
                 requireBuilderMethod "Using" mBind cenv ceenv.env ceenv.ad ceenv.builderTy mBind
                 requireBuilderMethod "Bind" mBind cenv ceenv.env ceenv.ad ceenv.builderTy mBind
 
+                let ident, pat =
+                    match pat with
+                    | SynPat.Named(ident = SynIdent(id, _); isThisVal = false) -> id, pat
+                    | SynPat.LongIdent(longDotId = SynLongIdent(id = [ id ])) -> id, pat
+                    | SynPat.Wild(m) when ceenv.cenv.g.langVersion.SupportsFeature LanguageFeature.UseBangBindingValueDiscard ->
+                        // Special handling for wildcard (_) patterns
+                        let tmpIdent = mkSynId m "_"
+                        tmpIdent, SynPat.Named(SynIdent(tmpIdent, None), false, None, m)
+                    | _ -> error (Error(FSComp.SR.tcInvalidUseBangBinding (), pat.Range))
+
                 let bindExpr =
                     let consumeExpr =
                         SynExpr.MatchLambda(
@@ -1840,14 +1853,14 @@ let rec TryTranslateComputationExpression
                         )
 
                     let consumeExpr =
-                        mkSynCall "Using" mBind [ SynExpr.Ident id; consumeExpr ] ceenv.builderValName
+                        mkSynCall "Using" mBind [ SynExpr.Ident ident; consumeExpr ] ceenv.builderValName
 
                     let consumeExpr =
                         SynExpr.MatchLambda(
                             false,
                             mBind,
                             [
-                                SynMatchClause(pat, None, consumeExpr, id.idRange, DebugPointAtTarget.No, SynMatchClauseTrivia.Zero)
+                                SynMatchClause(pat, None, consumeExpr, ident.idRange, DebugPointAtTarget.No, SynMatchClauseTrivia.Zero)
                             ],
                             DebugPointAtBinding.NoneAtInvisible,
                             mBind
@@ -1860,8 +1873,7 @@ let rec TryTranslateComputationExpression
                     |> addBindDebugPoint spBind
 
                 Some(translatedCtxt bindExpr)
-            | _pat, [] -> error (Error(FSComp.SR.tcInvalidUseBangBinding (), mBind))
-            | _pat, _ands ->
+            | _ ->
                 // Has andBangs
                 let m =
                     match andBangs with

src/Compiler/FSComp.txt

@@ -1798,3 +1798,4 @@ featureDontWarnOnUppercaseIdentifiersInBindingPatterns,"Don't warn on uppercase
 featureDeprecatePlacesWhereSeqCanBeOmitted,"Deprecate places where 'seq' can be omitted"
 featureSupportValueOptionsAsOptionalParameters,"Support ValueOption as valid type for optional member parameters"
 featureSupportWarnWhenUnitPassedToObjArg,"Warn when unit is passed to a member accepting `obj` argument, e.g. `Method(o:obj)` will warn if called via `Method()`."
+featureUseBangBindingValueDiscard,"Use bang binding with value discard"

src/Compiler/Facilities/LanguageFeatures.fs

@@ -99,6 +99,7 @@ type LanguageFeature =
     | DeprecatePlacesWhereSeqCanBeOmitted
     | SupportValueOptionsAsOptionalParameters
     | WarnWhenUnitPassedToObjArg
+    | UseBangBindingValueDiscard
 
 /// LanguageVersion management
 type LanguageVersion(versionText) =
@@ -229,6 +230,7 @@ type LanguageVersion(versionText) =
                 LanguageFeature.DeprecatePlacesWhereSeqCanBeOmitted, previewVersion
                 LanguageFeature.SupportValueOptionsAsOptionalParameters, previewVersion
                 LanguageFeature.WarnWhenUnitPassedToObjArg, previewVersion
+                LanguageFeature.UseBangBindingValueDiscard, previewVersion
             ]
 
     static let defaultLanguageVersion = LanguageVersion("default")
@@ -391,6 +393,7 @@ type LanguageVersion(versionText) =
         | LanguageFeature.DeprecatePlacesWhereSeqCanBeOmitted -> FSComp.SR.featureDeprecatePlacesWhereSeqCanBeOmitted ()
         | LanguageFeature.SupportValueOptionsAsOptionalParameters -> FSComp.SR.featureSupportValueOptionsAsOptionalParameters ()
         | LanguageFeature.WarnWhenUnitPassedToObjArg -> FSComp.SR.featureSupportWarnWhenUnitPassedToObjArg ()
+        | LanguageFeature.UseBangBindingValueDiscard -> FSComp.SR.featureUseBangBindingValueDiscard ()
 
     /// Get a version string associated with the given feature.
     static member GetFeatureVersionString feature =

src/Compiler/Facilities/LanguageFeatures.fsi

@@ -90,6 +90,7 @@ type LanguageFeature =
     | DeprecatePlacesWhereSeqCanBeOmitted
     | SupportValueOptionsAsOptionalParameters
     | WarnWhenUnitPassedToObjArg
+    | UseBangBindingValueDiscard
 
 /// LanguageVersion management
 type LanguageVersion =

src/Compiler/pars.fsy

@@ -3755,13 +3755,23 @@ atomicPattern:
       { SynPat.ArrayOrList(true, $2, lhs parseState) }
 
   | UNDERSCORE
-      { SynPat.Wild(lhs parseState) }
+      { (* Underscore pattern ('_') is represented as SynPat.Wild
+           This wild pattern is used in all binding forms:
+           - let _ = ...
+           - use _ = ...
+           - let! _ = ...
+           - use! _ = ...
+           This ensures consistent representation of wildcard bindings in the AST *)
+        SynPat.Wild(lhs parseState) }
 
   | QMARK ident
       { SynPat.OptionalVal($2, lhs parseState) }
 
   | atomicPatternLongIdent %prec prec_atompat_pathop
-      { let vis, lidwd = $1
+      { (* This rule handles identifiers in patterns like 'use! __' *)
+        (* For simple identifiers (like '__'), it creates a SynPat.Named AST node *)
+        (* For complex paths (A.B.C) or uppercase ids, it calls mkSynPatMaybeVar *)
+        let vis, lidwd = $1
         if not (isNilOrSingleton lidwd.LongIdent) || String.isLeadingIdentifierCharacterUpperCase (List.head lidwd.LongIdent).idText then
             mkSynPatMaybeVar lidwd vis (lhs parseState)
         else
@@ -4431,7 +4441,13 @@ declExpr:
        SynExpr.YieldOrReturnFrom(($1, not $1), arbExpr ("yield!", mYieldAll), mYieldAll, trivia) }
 
   | BINDER headBindingPattern EQUALS typedSequentialExprBlock IN opt_OBLOCKSEP moreBinders typedSequentialExprBlock %prec expr_let
-     { let spBind = DebugPointAtBinding.Yes(rhs2 parseState 1 5)
+     { (* This rule handles the 'use!' and 'let!' binding expressions in computation expressions *)
+       (* The BINDER token represents keywords like 'use!' or 'let!' *)
+       (* headBindingPattern represents patterns in the binding:
+          - Underscore ('_') patterns are preserved as SynPat.Wild
+          - Named patterns ('__') are represented as SynPat.Named
+          - Identifiers (like 'value') are represented as SynPat.LongIdent *)
+       let spBind = DebugPointAtBinding.Yes(rhs2 parseState 1 5)
        let mEquals = rhs parseState 3
        let m = unionRanges (rhs parseState 1) $8.Range
        let trivia: SynExprLetOrUseBangTrivia = { LetOrUseBangKeyword = rhs parseState 1 ; EqualsRange = Some mEquals }