Proper indentation and line breaks for Switch/Case and Closure

Author: evnik

Sources/SwiftSyntaxBuilder/gyb_generated/BuildableCollectionNodes.swift

@@ -1475,7 +1475,7 @@ public struct SwitchCaseList: ExpressibleByArrayLiteral, SyntaxBuildable, Expres
 
   public func buildSwitchCaseList(format: Format, leadingTrivia: Trivia? = nil) -> SwitchCaseListSyntax {
     let result = SyntaxFactory.makeSwitchCaseList(elements.map {
-      $0.buildSyntax(format: format, leadingTrivia: nil)
+      $0.buildSyntax(format: format, leadingTrivia: Trivia.newlines(1) + format._makeIndent())
     })
     if let leadingTrivia = leadingTrivia {
       return result.withLeadingTrivia(leadingTrivia + (result.leadingTrivia ?? []))

Sources/SwiftSyntaxBuilder/gyb_generated/BuildableNodes.swift

@@ -2554,8 +2554,8 @@ public struct ClosureExpr: ExprBuildable, ExpressibleAsClosureExpr {
     let result = SyntaxFactory.makeClosureExpr(
       leftBrace: leftBrace,
       signature: signature?.buildClosureSignature(format: format, leadingTrivia: nil),
-      statements: statements.buildCodeBlockItemList(format: format, leadingTrivia: nil),
-      rightBrace: rightBrace
+      statements: statements.buildCodeBlockItemList(format: format._indented(), leadingTrivia: nil),
+      rightBrace: rightBrace.withLeadingTrivia(.newlines(1) + format._makeIndent() + (rightBrace.leadingTrivia ?? []))
     )
     if let leadingTrivia = leadingTrivia {
       return result.withLeadingTrivia(leadingTrivia + (result.leadingTrivia ?? []))
@@ -9531,7 +9531,7 @@ public struct SwitchStmt: StmtBuildable, ExpressibleAsSwitchStmt {
       expression: expression.buildExpr(format: format, leadingTrivia: nil),
       leftBrace: leftBrace,
       cases: cases.buildSwitchCaseList(format: format, leadingTrivia: nil),
-      rightBrace: rightBrace
+      rightBrace: rightBrace.withLeadingTrivia(.newlines(1) + format._makeIndent() + (rightBrace.leadingTrivia ?? []))
     )
     if let leadingTrivia = leadingTrivia {
       return result.withLeadingTrivia(leadingTrivia + (result.leadingTrivia ?? []))
@@ -10618,7 +10618,7 @@ public struct SwitchCase: SyntaxBuildable, ExpressibleAsSwitchCase {
     let result = SyntaxFactory.makeSwitchCase(
       unknownAttr: unknownAttr?.buildAttribute(format: format, leadingTrivia: nil),
       label: label.buildSyntax(format: format, leadingTrivia: nil),
-      statements: statements.buildCodeBlockItemList(format: format, leadingTrivia: nil)
+      statements: statements.buildCodeBlockItemList(format: format._indented(), leadingTrivia: nil)
     )
     if let leadingTrivia = leadingTrivia {
       return result.withLeadingTrivia(leadingTrivia + (result.leadingTrivia ?? []))

Tests/SwiftSyntaxBuilderTest/ExpressibleBuildablesTests.swift

@@ -51,34 +51,30 @@ final class ExpressibleBuildablesTests: XCTestCase {
 
     let switchStmt = SwitchStmt(labelName: nil,
                                 expression: expression,
-                                leftBrace: .leftBrace.withTrailingTrivia(.newlines(1)),
-                                rightBrace: .rightBrace.withLeadingTrivia(.newlines(1)),
                                 casesBuilder: {
       for (version, semVer) in versions {
         SwitchCase(label: SwitchCaseLabel(caseItemsBuilder: {
           CaseItem(pattern: EnumCasePattern(caseName: version))
         }), statementsBuilder: {
-          ReturnStmt(expression: StringLiteralExpr(semVer, closeQuote: .stringQuote.withTrailingTrivia(.newlines(1))))
+          ReturnStmt(expression: StringLiteralExpr(semVer))
         })
       }
     })
 
     let syntax = switchStmt.buildSyntax(format: Format())
-
-    // The generated code contains whitespace after `:`.
-    // So replacing whitespace with `␣`.
-    XCTAssertEqual(syntax.description.replacingOccurrences(of: " ", with: "␣"), """
-    switch␣version{
-    case␣.version_1:␣
-    return␣"1.0.0"
-    case␣.version_2:␣
-    return␣"2.0.0"
-    case␣.version_3:␣
-    return␣"3.0.0"
-    case␣.version_3_1:␣
-    return␣"3.1.0"
-
-    }
-    """)
+    XCTAssertEqual(
+      syntax.description,
+      """
+      switch version{
+      case .version_1: 
+          return "1.0.0"
+      case .version_2: 
+          return "2.0.0"
+      case .version_3: 
+          return "3.0.0"
+      case .version_3_1: 
+          return "3.1.0"
+      }
+      """)
   }
 }

Tests/SwiftSyntaxBuilderTest/FunctionTests.swift

@@ -72,12 +72,23 @@ final class FunctionTests: XCTestCase {
       TupleExprElement(expression: "42")
     })
     let syntax = buildable.buildSyntax(format: Format())
-    XCTAssertEqual(syntax.description, "test(42){}")
+    XCTAssertEqual(syntax.description, "test(42){\n}")
   }
 
   func testParensOmittedForNoArgumentsAndTrailingClosure() {
-    let buildable = FunctionCallExpr("test", trailingClosure: ClosureExpr())
+    let closure = ClosureExpr(statementsBuilder: {
+      FunctionCallExpr("f", argumentListBuilder: {
+        TupleExprElement(expression: "a")
+      })
+    })
+    let buildable = FunctionCallExpr("test", trailingClosure: closure)
     let syntax = buildable.buildSyntax(format: Format())
-    XCTAssertEqual(syntax.description, "test{}")
+    XCTAssertEqual(
+      syntax.description,
+      """
+      test{
+          f(a)
+      }
+      """)
   }
 }