Correctly handle use binding follow by let bang

src/Fantomas.Tests/ComputationExpressionTests.fs

@@ -1224,4 +1224,95 @@ let valueTwo =
         do! d
         return! getE ()
     }
+"""
+
+[<Test>]
+let ``use and let bang, 876`` () =
+    formatSourceString false """let private getAST log (req: HttpRequest) =
+        async {
+            use stream = new StreamReader(req.Body)
+            let! json = stream.ReadToEndAsync() |> Async.AwaitTask
+            let parseRequest = Decoders.decodeInputRequest json
+
+            match parseRequest with
+            | Result.Ok input when (input.SourceCode.Length < Const.sourceSizeLimit) ->
+                let! astResult = parseAST log input
+                match astResult with
+                | Result.Ok ast ->
+                    let node =
+                        match ast with
+                        | ParsedInput.ImplFile (ParsedImplFileInput.ParsedImplFileInput (_, _, _, _, hds, mns, _)) ->
+                            Fantomas.AstTransformer.astToNode hds mns
+
+                        | ParsedInput.SigFile (ParsedSigFileInput.ParsedSigFileInput (_, _, _, _, mns)) ->
+                            Fantomas.AstTransformer.sigAstToNode mns
+                        |> Encoders.nodeEncoder
+
+                    let responseJson =
+                        Encoders.encodeResponse node (sprintf "%A" ast)
+                        |> Thoth.Json.Net.Encode.toString 2
+
+                    return sendJson responseJson
+
+                | Error error -> return sendBadRequest (sprintf "%A" error)
+
+            | Result.Ok _ -> return sendTooLargeError ()
+
+            | Error err -> return sendInternalError (sprintf "%A" err)
+        }
+"""  config
+    |> prepend newline
+    |> should equal """
+let private getAST log (req: HttpRequest) =
+    async {
+        use stream = new StreamReader(req.Body)
+        let! json = stream.ReadToEndAsync() |> Async.AwaitTask
+        let parseRequest = Decoders.decodeInputRequest json
+
+        match parseRequest with
+        | Result.Ok input when (input.SourceCode.Length < Const.sourceSizeLimit) ->
+            let! astResult = parseAST log input
+
+            match astResult with
+            | Result.Ok ast ->
+                let node =
+                    match ast with
+                    | ParsedInput.ImplFile (ParsedImplFileInput.ParsedImplFileInput (_, _, _, _, hds, mns, _)) ->
+                        Fantomas.AstTransformer.astToNode hds mns
+
+                    | ParsedInput.SigFile (ParsedSigFileInput.ParsedSigFileInput (_, _, _, _, mns)) ->
+                        Fantomas.AstTransformer.sigAstToNode mns
+                    |> Encoders.nodeEncoder
+
+                let responseJson =
+                    Encoders.encodeResponse node (sprintf "%A" ast)
+                    |> Thoth.Json.Net.Encode.toString 2
+
+                return sendJson responseJson
+
+            | Error error -> return sendBadRequest (sprintf "%A" error)
+
+        | Result.Ok _ -> return sendTooLargeError ()
+
+        | Error err -> return sendInternalError (sprintf "%A" err)
+    }
+"""
+
+[<Test>]
+let ``let rec + let bang`` () =
+    formatSourceString false """let a =
+    async {
+        let rec foo a = foo a
+        let! bar = async { return foo a }
+        return bar
+    }
+"""  config
+    |> prepend newline
+    |> should equal """
+let a =
+    async {
+        let rec foo a = foo a
+        let! bar = async { return foo a }
+        return bar
+    }
 """

src/Fantomas/CodePrinter.fs

@@ -963,8 +963,10 @@ and genExpr astContext synExpr =
 
         let genCompExprStatement astContext ces =
             match ces with
-            | LetStatement(isRecursive, binding) ->
-                let prefix = if isRecursive then "let rec " else "let "
+            | LetOrUseStatement(isRecursive, isUse, binding) ->
+                let prefix =
+                    sprintf "%s%s" (if isUse then "use " else "let ") (if isRecursive then "rec " else "")
+
                 genLetBinding astContext prefix binding
             | LetOrUseBangStatement(isUse, pat, expr, _) ->
                 ifElse isUse (!- "use! ") (!- "let! ")
@@ -977,7 +979,7 @@ and genExpr astContext synExpr =
 
         let getRangeOfCompExprStatement ces =
             match ces with
-            | LetStatement(_, binding) -> binding.RangeOfBindingSansRhs
+            | LetOrUseStatement(_, _, binding) -> binding.RangeOfBindingSansRhs
             | LetOrUseBangStatement(_, _, _, r) -> r
             | AndBangStatement (pat, _) -> pat.Range
             | OtherStatement expr -> expr.Range

src/Fantomas/SourceParser.fs

@@ -780,17 +780,17 @@ let rec (|LetOrUses|_|) = function
     | _ -> None
 
 type ComputationExpressionStatement =
-    | LetStatement of recursive:bool * SynBinding
+    | LetOrUseStatement of recursive:bool * isUse:bool * SynBinding
     | LetOrUseBangStatement of isUse:bool * SynPat * SynExpr * range
     | AndBangStatement of SynPat * SynExpr
     | OtherStatement of SynExpr
 
 let rec collectComputationExpressionStatements e : ComputationExpressionStatement list =
     match e with
-    | SynExpr.LetOrUse(isRecursive, isUse, bindings, body, _) when (not(isUse)) ->
+    | SynExpr.LetOrUse(isRecursive, isUse, bindings, body, _) ->
         let bindings =
             bindings
-            |> List.map (fun b -> LetStatement(isRecursive, b))
+            |> List.map (fun b -> LetOrUseStatement(isRecursive, isUse, b))
         let returnExpr = collectComputationExpressionStatements body
         [yield! bindings; yield! returnExpr]
     | SynExpr.LetOrUseBang(_,isUse,_,pat,expr, andBangs, body, r) ->