Minor improvements to BasicFormat

Author: ahoppen

Sources/SwiftBasicFormat/BasicFormat.swift

@@ -216,6 +216,7 @@ open class BasicFormat: SyntaxRewriter {
       (.regexLiteralPattern, _),
       (.regexSlash, .extendedRegexDelimiter),  // closing extended regex delimiter should never be separate by a space
       (.rightAngle, .leftParen),  // func foo<T>(x: T)
+      (.rightBrace, .leftParen),  // { return 1 }()
       (.rightParen, .leftParen),  // returnsClosure()()
       (.rightParen, .period),  // foo().bar
       (.rightSquareBracket, .period),  // myArray[1].someProperty
@@ -310,6 +311,14 @@ open class BasicFormat: SyntaxRewriter {
       return false
     }()
 
+    lazy var nextTokenWillStartWithWhitespace: Bool = {
+      guard let nextToken = nextToken else {
+        return false
+      }
+      return nextToken.leadingTrivia.startsWithWhitespace
+        || (requiresLeadingNewline(nextToken) && isMutable(nextToken))
+    }()
+
     lazy var nextTokenWillStartWithNewline: Bool = {
       guard let nextToken = nextToken else {
         return false
@@ -359,7 +368,7 @@ open class BasicFormat: SyntaxRewriter {
     //    because newlines should be preferred to spaces as a whitespace
     if requiresWhitespace(between: token, and: nextToken)
       && !trailingTrivia.endsWithWhitespace
-      && !nextTokenWillStartWithNewline
+      && !nextTokenWillStartWithWhitespace
     {
       trailingTrivia += .space
     }

Tests/SwiftBasicFormatTest/BasicFormatTests.swift

@@ -18,13 +18,30 @@ import SwiftSyntax
 import XCTest
 import _SwiftSyntaxTestSupport
 
+fileprivate func assertFormatted<T: SyntaxProtocol>(
+  tree: T,
+  expected: String,
+  using format: BasicFormat = BasicFormat(indentationWidth: .spaces(4)),
+  file: StaticString = #file,
+  line: UInt = #line
+) {
+  assertStringsEqualWithDiff(tree.formatted(using: format).description, expected, file: file, line: line)
+}
+
 fileprivate func assertFormatted(
   source: String,
   expected: String,
+  using format: BasicFormat = BasicFormat(indentationWidth: .spaces(4)),
   file: StaticString = #file,
   line: UInt = #line
 ) {
-  assertStringsEqualWithDiff(Parser.parse(source: source).formatted().description, expected, file: file, line: line)
+  assertFormatted(
+    tree: Parser.parse(source: source),
+    expected: expected,
+    using: format,
+    file: file,
+    line: line
+  )
 }
 
 final class BasicFormatTest: XCTestCase {
@@ -257,4 +274,57 @@ final class BasicFormatTest: XCTestCase {
         """
     )
   }
+
+  func testDontInsertTrailingWhitespaceIfNextTokenStartsWithLeadingWhitespace() {
+    let tree = VariableDeclSyntax(
+      bindingKeyword: .keyword(.var),
+      bindings: PatternBindingListSyntax([
+        PatternBindingSyntax(
+          pattern: PatternSyntax(IdentifierPatternSyntax(identifier: .identifier("x"))),
+          typeAnnotation: TypeAnnotationSyntax(
+            colon: .colonToken(trailingTrivia: .space),
+            type: TypeSyntax(SimpleTypeIdentifierSyntax(name: .identifier("Int")))
+          ),
+          accessor: PatternBindingSyntax.Accessor(
+            AccessorBlockSyntax(
+              leftBrace: .leftBraceToken(leadingTrivia: .space),
+              accessors: AccessorListSyntax([]),
+              rightBrace: .rightBraceToken(leadingTrivia: .newline)
+            )
+          )
+        )
+      ])
+    )
+    assertFormatted(
+      tree: tree,
+      expected: """
+        var x: Int {
+        }
+        """
+    )
+  }
+
+  func testAccessor() {
+    let source = """
+      struct Point {
+        var computed: Int {
+          get { 0 }
+        }
+      }
+      """
+
+    assertFormatted(
+      source: source,
+      expected: """
+        struct Point {
+          var computed: Int {
+            get {
+              0
+            }
+          }
+        }
+        """,
+      using: BasicFormat(indentationWidth: .spaces(2))
+    )
+  }
 }