Check return type info in use! bindings

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

@@ -5,7 +5,8 @@
 * Checking: Fix checking nested fields for records and anonymous ([PR #18964](https://github.com/dotnet/fsharp/pull/18964))
 * Fix name is bound multiple times is not reported in 'as' pattern ([PR #18984](https://github.com/dotnet/fsharp/pull/18984))
 * Fix: warn FS0049 on upper union case label. ([PR #19003](https://github.com/dotnet/fsharp/pull/19003))
-* Type relations cache: handle potentially "infinite" types ([PR #19010](https://github.com/dotnet/fsharp/pull/19010))  
+* Type relations cache: handle potentially "infinite" types ([PR #19010](https://github.com/dotnet/fsharp/pull/19010))
+* Check return type info in use! bindings ([PR #19024](https://github.com/dotnet/fsharp/pull/19024))
 
 ### Added
 

src/Compiler/Checking/Expressions/CheckComputationExpressions.fs

@@ -1885,7 +1885,9 @@ 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.Typed(innerPat, targetType, range) when supportsTypedLetOrUseBang ->
+                        let ident, pat = extractIdentifierFromPattern innerPat
+                        ident, SynPat.Typed(pat, targetType, unionRanges pat.Range range)
                     | 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

@@ -37,11 +37,11 @@ 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)
+        use! res:Disposable = new Disposable(1) 
+        use! __:Disposable = new Disposable(2)
+        use! (res1: Disposable) = new Disposable(3)
+        use! _: Disposable = new Disposable(4)
+        use! (_: Disposable) = new Disposable(5)
         return ()
     } |> Async.RunSynchronously
 

tests/FSharp.Compiler.ComponentTests/Language/ComputationExpressionTests.fs

@@ -2031,6 +2031,50 @@ match test() with
         |> compileAndRun
         |> shouldSucceed
 
+    [<Fact>]
+    let ``Preview: use! unresolved return type`` () =
+        FSharp """
+module Test
+
+open System.IO
+open System.Threading.Tasks
+
+task {
+    use! x: IDisposable = Task.FromResult(new StreamReader(""))
+    ()
+}
+|> ignore
+            """
+        |> withLangVersionPreview
+        |> typecheck
+        |> shouldFail
+        |> withDiagnostics [
+            Error 39, Line 8, Col 13, Line 8, Col 24, "The type 'IDisposable' is not defined."
+        ]
+
+    [<Fact>]
+    let ``Preview: use! return type mismatch error 01`` () =
+        FSharp """
+module Test
+
+open System
+
+task {
+    use! (x: int): IDisposable = failwith ""
+    ()
+}
+|> ignore
+            """
+        |> withLangVersionPreview
+        |> typecheck
+        |> shouldFail
+        |> withDiagnostics [
+            Error 1, Line 7, Col 11, Line 7, Col 17, "This expression was expected to have type
+'IDisposable'   
+but here has type
+'int'   "
+        ]
+
     [<Theory; FileInlineData("tailcalls.fsx")>]
     let ``tail call methods work`` compilation =
         compilation