Extract keyword for SingleExpr expressions. (fsprojects#2045)

Fixes fsprojects#1875.

src/Fantomas.Tests/Fantomas.Tests.fsproj

@@ -91,6 +91,7 @@
     <Compile Include="LibraryOnlySynExprTests.fs" />
     <Compile Include="IndexSyntaxTests.fs" />
     <Compile Include="InsertFinalNewlineTests.fs" />
+    <Compile Include="SingleExprTests.fs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Fantomas.Extras\Fantomas.Extras.fsproj" />

src/Fantomas.Tests/LazyTests.fs

@@ -76,3 +76,35 @@ let setup =
          let value = 1
          value)
 """
+
+[<Test>]
+let ``comment after lazy keyword`` () =
+    formatSourceString
+        false
+        """
+lazy // comment
+    foobar
+"""
+        config
+    |> prepend newline
+    |> should
+        equal
+        """
+lazy // comment
+    foobar
+"""
+
+[<Test>]
+let ``lazy with long indent expr should not get any additional parenthesis`` () =
+    formatSourceString
+        false
+        """
+let theme = lazy Application.Current.RequestedTheme
+"""
+        config
+    |> prepend newline
+    |> should
+        equal
+        """
+let theme = lazy Application.Current.RequestedTheme
+"""

src/Fantomas.Tests/SingleExprTests.fs

@@ -0,0 +1,215 @@
+module Fantomas.Tests.SingleExprTests
+
+open NUnit.Framework
+open FsUnit
+open Fantomas.Tests.TestHelper
+
+[<Test>]
+let ``comment after do keyword, 1875`` () =
+    formatSourceString
+        false
+        """
+do  // Comment DO
+        let x = 1
+        f (x) 
+"""
+        config
+    |> prepend newline
+    |> should
+        equal
+        """
+do // Comment DO
+    let x = 1
+    f (x)
+"""
+
+[<Test>]
+let ``comment after do bang keyword`` () =
+    formatSourceString
+        false
+        """
+async {
+    do!  // Comment DO BANG
+            let x = 1
+            f (x) }
+"""
+        config
+    |> prepend newline
+    |> should
+        equal
+        """
+async {
+    do! // Comment DO BANG
+        let x = 1
+        f (x)
+}
+"""
+
+[<Test>]
+let ``comment after return bang keyword`` () =
+    formatSourceString
+        false
+        """
+async {
+    return!  // Comment RETURN BANG
+        foobar()
+}
+"""
+        config
+    |> prepend newline
+    |> should
+        equal
+        """
+async {
+    return! // Comment RETURN BANG
+        foobar ()
+}
+"""
+
+[<Test>]
+let ``comment after yield bang keyword`` () =
+    formatSourceString
+        false
+        """
+seq {
+    yield!  // Comment YIELD BANG
+        foobar()
+}
+"""
+        config
+    |> prepend newline
+    |> should
+        equal
+        """
+seq {
+    yield! // Comment YIELD BANG
+        foobar ()
+}
+"""
+
+[<Test>]
+let ``comment after return keyword`` () =
+    formatSourceString
+        false
+        """
+async {
+    return  // Comment RETURN
+        foobar()
+}
+"""
+        config
+    |> prepend newline
+    |> should
+        equal
+        """
+async {
+    return // Comment RETURN
+        foobar ()
+}
+"""
+
+[<Test>]
+let ``comment after yield keyword`` () =
+    formatSourceString
+        false
+        """
+seq {
+    yield  // Comment YIELD
+        foobar()
+}
+"""
+        config
+    |> prepend newline
+    |> should
+        equal
+        """
+seq {
+    yield // Comment YIELD
+        foobar ()
+}
+"""
+
+[<Test>]
+let ``comment after assert keyword`` () =
+    formatSourceString
+        false
+        """
+assert // comment
+    foobar
+"""
+        config
+    |> prepend newline
+    |> should
+        equal
+        """
+assert // comment
+    foobar
+"""
+
+[<Test>]
+let ``comment after downcast keyword`` () =
+    formatSourceString
+        false
+        """
+downcast // comment
+    foobar
+"""
+        config
+    |> prepend newline
+    |> should
+        equal
+        """
+downcast // comment
+    foobar
+"""
+
+[<Test>]
+let ``comment after upcast keyword`` () =
+    formatSourceString
+        false
+        """
+upcast // comment
+    foobar
+"""
+        config
+    |> prepend newline
+    |> should
+        equal
+        """
+upcast // comment
+    foobar
+"""
+
+[<Test>]
+let ``comment after address of token`` () =
+    formatSourceString
+        false
+        """
+& // comment
+    foobar
+"""
+        config
+    |> prepend newline
+    |> should
+        equal
+        """
+& // comment
+    foobar
+"""
+
+[<Test>]
+let ``comment after address of tokens`` () =
+    formatSourceString
+        false
+        """
+&& // comment
+    foobar
+"""
+        config
+    |> prepend newline
+    |> should
+        equal
+        """
+&& // comment
+    foobar
+"""

src/Fantomas/AstTransformer.fs

@@ -227,13 +227,17 @@ module private Ast =
                       yield! nodes
                       yield! (List.collect visitSynMatchClause clauses) ]
                     |> finalContinuation)
-            | SynExpr.Do (expr, range) ->
+            | SynExpr.Do (expr, StartRange 2 (doKeyword, range)) ->
                 visit expr (fun nodes ->
-                    mkNode SynExpr_Do range :: nodes
+                    [ yield mkNode SynExpr_Do range
+                      yield mkNode SynExpr_Do_Do doKeyword
+                      yield! nodes ]
                     |> finalContinuation)
-            | SynExpr.Assert (expr, range) ->
+            | SynExpr.Assert (expr, StartRange 6 (assertKeyword, range)) ->
                 visit expr (fun nodes ->
-                    mkNode SynExpr_Assert range :: nodes
+                    [ yield mkNode SynExpr_Assert range
+                      yield mkNode SynExpr_Assert_Assert assertKeyword
+                      yield! nodes ]
                     |> finalContinuation)
             | SynExpr.App (_, _, funcExpr, argExpr, range) ->
                 let continuations: ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list =
@@ -272,9 +276,11 @@ module private Ast =
                     |> finalContinuation
 
                 Continuation.sequence continuations finalContinuation
-            | SynExpr.Lazy (ex, range) ->
+            | SynExpr.Lazy (ex, StartRange 4 (lazyKeyword, range)) ->
                 visit ex (fun nodes ->
-                    mkNode SynExpr_Lazy range :: nodes
+                    [ yield mkNode SynExpr_Lazy range
+                      yield mkNode SynExpr_Lazy_Lazy lazyKeyword
+                      yield! nodes ]
                     |> finalContinuation)
             | SynExpr.Sequential (_, _, expr1, expr2, _) ->
                 visit expr2 (fun nodes1 -> visit expr1 (fun nodes2 -> nodes1 @ nodes2 |> finalContinuation))
@@ -456,21 +462,33 @@ module private Ast =
                       yield! nodes
                       yield! visitSynType typeName ]
                     |> finalContinuation)
-            | SynExpr.InferredUpcast (expr, range) ->
+            | SynExpr.InferredUpcast (expr, StartRange 6 (upcastKeyword, range)) ->
                 visit expr (fun nodes ->
-                    mkNode SynExpr_InferredUpcast range :: nodes
+                    [ yield mkNode SynExpr_InferredUpcast range
+                      yield mkNode SynExpr_InferredUpcast_Upcast upcastKeyword
+                      yield! nodes ]
                     |> finalContinuation)
-            | SynExpr.InferredDowncast (expr, range) ->
+            | SynExpr.InferredDowncast (expr, StartRange 8 (downcastKeyword, range)) ->
                 visit expr (fun nodes ->
-                    mkNode SynExpr_InferredDowncast range :: nodes
+                    [ yield mkNode SynExpr_InferredDowncast range
+                      yield mkNode SynExpr_InferredDowncast_Downcast downcastKeyword
+                      yield! nodes ]
                     |> finalContinuation)
             | SynExpr.Null range ->
                 mkNode SynExpr_Null range
                 |> List.singleton
                 |> finalContinuation
-            | SynExpr.AddressOf (_, expr, _, range) ->
+            | SynExpr.AddressOf (isByRef, expr, _, range) ->
+                let ampersandRange, ampersandType =
+                    if isByRef then
+                        RangeHelpers.mkStartRange 1 range, SynExpr_AddressOf_SingleAmpersand
+                    else
+                        RangeHelpers.mkStartRange 2 range, SynExpr_AddressOf_DoubleAmpersand
+
                 visit expr (fun nodes ->
-                    mkNode SynExpr_AddressOf range :: nodes
+                    [ yield mkNode SynExpr_AddressOf range
+                      yield mkNode ampersandType ampersandRange
+                      yield! nodes ]
                     |> finalContinuation)
             | SynExpr.TraitCall (_typars, sign, expr, range) ->
                 visit expr (fun nodes ->
@@ -492,13 +510,29 @@ module private Ast =
                 mkNode SynExpr_ImplicitZero range
                 |> List.singleton
                 |> finalContinuation
-            | SynExpr.YieldOrReturn (_, expr, range) ->
+            | SynExpr.YieldOrReturn ((isYield, _), expr, range) ->
+                let keywordType, keywordRange =
+                    if isYield then
+                        SynExpr_YieldOrReturn_Yield, RangeHelpers.mkStartRange 5 range
+                    else
+                        SynExpr_YieldOrReturn_Return, RangeHelpers.mkStartRange 6 range
+
                 visit expr (fun nodes ->
-                    mkNode SynExpr_YieldOrReturn range :: nodes
+                    [ yield mkNode SynExpr_YieldOrReturn range
+                      yield mkNode keywordType keywordRange
+                      yield! nodes ]
                     |> finalContinuation)
-            | SynExpr.YieldOrReturnFrom (_, expr, range) ->
+            | SynExpr.YieldOrReturnFrom ((isYield, _), expr, range) ->
+                let keywordType, keywordRange =
+                    if isYield then
+                        SynExpr_YieldOrReturnFrom_YieldBang, RangeHelpers.mkStartRange 6 range
+                    else
+                        SynExpr_YieldOrReturnFrom_ReturnBang, RangeHelpers.mkStartRange 7 range
+
                 visit expr (fun nodes ->
-                    mkNode SynExpr_YieldOrReturnFrom range :: nodes
+                    [ yield mkNode SynExpr_YieldOrReturnFrom range
+                      yield mkNode keywordType keywordRange
+                      yield! nodes ]
                     |> finalContinuation)
             | SynExpr.LetOrUseBang (_, _, _, pat, rhsExpr, andBangs, body, range) ->
                 let continuations: ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list =
@@ -522,9 +556,11 @@ module private Ast =
                       yield! nodes
                       yield! clauses |> List.collect visitSynMatchClause ]
                     |> finalContinuation)
-            | SynExpr.DoBang (expr, range) ->
+            | SynExpr.DoBang (expr, StartRange 3 (doBangKeyword, range)) ->
                 visit expr (fun nodes ->
-                    mkNode SynExpr_DoBang range :: nodes
+                    [ yield mkNode SynExpr_DoBang range
+                      yield mkNode SynExpr_DoBang_DoBang doBangKeyword
+                      yield! nodes ]
                     |> finalContinuation)
             | SynExpr.LibraryOnlyILAssembly (_, _, _, _, range) ->
                 mkNode SynExpr_LibraryOnlyILAssembly range