more tests

Author: edgarfgp

src/Compiler/Checking/Expressions/CheckComputationExpressions.fs

@@ -1802,6 +1802,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) -> 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 "_"

tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/UseBindings/UseBang05.fs

@@ -0,0 +1,58 @@
+open System
+
+open System
+
+type Disposable(id: int) =
+    static let mutable disposedIds = Set.empty<int>
+    static let mutable constructedIds = Set.empty<int>
+    
+    do constructedIds <- constructedIds.Add(id)
+    
+    member _.Id = id
+    
+    static member GetDisposed() = disposedIds
+    static member GetConstructed() = constructedIds
+    static member Reset() =
+        disposedIds <- Set.empty
+        constructedIds <- Set.empty
+        
+    interface IDisposable with
+        member this.Dispose() = disposedIds <- disposedIds.Add(this.Id)
+
+type DisposableBuilder() =
+    member _.Using(resource: #IDisposable, f) =
+        async {
+            use res = resource
+            return! f res
+        }
+        
+    member _.Bind(disposable: Disposable, f) = async.Bind(async.Return(disposable), f)
+    member _.Return(x) = async.Return x
+    member _.ReturnFrom(x) = x
+    member _.Bind(task, f) = async.Bind(task, f)
+
+let counterDisposable = DisposableBuilder()
+
+let testBindingPatterns() =
+    Disposable.Reset()
+    
+    counterDisposable {
+        use! res:IDisposable = new Disposable(1) 
+        use! __:IDisposable = new Disposable(2)
+        use! (res1: IDisposable) = new Disposable(3)
+        use! _: IDisposable = new Disposable(4)
+        use! (_: IDisposable) = new Disposable(5)
+        return ()
+    } |> Async.RunSynchronously
+    
+    let constructed = Disposable.GetConstructed()
+    let disposed = Disposable.GetDisposed()
+    let undisposed = constructed - disposed
+    
+    if not undisposed.IsEmpty then
+        printfn $"Undisposed instances: %A{undisposed}"
+        failwithf "Not all disposables were properly disposed"
+    else
+        printfn $"Success! All %d{constructed.Count} disposables were properly disposed"
+
+testBindingPatterns()

tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/UseBindings/UseBangBindings.fs

@@ -50,6 +50,17 @@ module UseBangBindingsVersion9 =
         |> withDiagnostics [
             (Error 1228, Line 47, Col 14, Line 47, Col 15, "'use!' bindings must be of the form 'use! <var> = <expr>'")
         ]
+        
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"UseBang05.fs"|])>]
+    let ``UseBangBindings - UseBang05_fs - Current LangVersion`` compilation =
+        compilation
+        |> asFsx
+        |> withLangVersion90
+        |> typecheck
+        |> shouldFail
+        |> withDiagnostics [
+            (Error 1228, Line 43, Col 14, Line 43, Col 15, "'use!' bindings must be of the form 'use! <var> = <expr>'")
+        ]
 
 module UseBangBindingsPreview =
     [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"UseBang01.fs"|])>]
@@ -83,4 +94,13 @@ module UseBangBindingsPreview =
         |> withLangVersionPreview
         |> compileAndRun
         |> shouldSucceed
+        
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"UseBang05.fs"|])>]
+    let ``UseBangBindings - UseBang05_fs - Preview LangVersion`` compilation =
+        compilation
+        |> asExe
+        |> withLangVersionPreview
+        |> compileAndRun
+        |> shouldSucceed
+