Add a buildSyntax function on SyntaxProtocol that uses the default Format

ahoppen · ahoppen · commit f5527590db9d · 2022-09-26T09:55:47.000+02:00
diff --git a/CodeGeneration/Sources/generate-swiftsyntaxbuilder/BuildableBaseProtocolsFile.swift b/CodeGeneration/Sources/generate-swiftsyntaxbuilder/BuildableBaseProtocolsFile.swift
@@ -131,4 +131,17 @@ let buildableBaseProtocolsFile = SourceFile {
       }
     }
   }
+  createBuildSyntaxExtensionWithDefaultFormat()
+}
+
+func createBuildSyntaxExtensionWithDefaultFormat() -> ExtensionDecl {
+  return ExtensionDecl(modifiers: [Token.public], extendedType: "SyntaxBuildable") {
+    FunctionDecl(
+      identifier: .identifier("buildSyntax"),
+      signature: FunctionSignature(input: ParameterClause(parameterList: []), output: "Syntax")) {
+        ReturnStmt(expression: FunctionCallExpr("buildSyntax") {
+          TupleExprElement(label: "format", expression: FunctionCallExpr("Format"))
+        })
+      }
+  }
 }
diff --git a/Sources/SwiftSyntaxBuilder/generated/BuildableBaseProtocols.swift b/Sources/SwiftSyntaxBuilder/generated/BuildableBaseProtocols.swift
@@ -192,3 +192,8 @@ public extension TypeBuildable {
     return Syntax(buildType(format: format))
   }
 }
+public extension SyntaxBuildable {
+  func buildSyntax() -> Syntax {
+    return buildSyntax(format: Format())
+  }
+}
diff --git a/Tests/SwiftSyntaxBuilderTest/ArrayExprTests.swift b/Tests/SwiftSyntaxBuilderTest/ArrayExprTests.swift
@@ -13,7 +13,7 @@ final class ArrayExprTests: XCTestCase {
     for (line, testCase) in testCases {
       let (builder, expected) = testCase
       let arrowExpr = builder.createArrayExpr()
-      let syntax = arrowExpr.buildSyntax(format: Format())
+      let syntax = arrowExpr.buildSyntax()
       
       var text = ""
       syntax.write(to: &text)
diff --git a/Tests/SwiftSyntaxBuilderTest/ArrayExpressibleAsTests.swift b/Tests/SwiftSyntaxBuilderTest/ArrayExpressibleAsTests.swift
@@ -7,15 +7,15 @@ final class ArrayExpressibleAsTests: XCTestCase {
     let modifiers: ExpressibleAsModifierList = [Token.public, Token.static]
 
     var result = ""
-    modifiers.createModifierList().buildSyntax(format: Format()).write(to: &result)
+    modifiers.createModifierList().buildSyntax().write(to: &result)
     XCTAssertEqual(result, "public static ")
   }
 
   func testHeterogeneousList() {
     let modifiers: ExpressibleAsModifierList = [Token.open, DeclModifier(name: Token.internal)]
 
     var result = ""
-    modifiers.createModifierList().buildSyntax(format: Format()).write(to: &result)
+    modifiers.createModifierList().buildSyntax().write(to: &result)
     XCTAssertEqual(result, "open internal ")
   }
 
@@ -24,7 +24,7 @@ final class ArrayExpressibleAsTests: XCTestCase {
     let expressible: ExpressibleAsModifierList = modifiers as [ExpressibleAsDeclModifier]
 
     var result = ""
-    expressible.createModifierList().buildSyntax(format: Format()).write(to: &result)
+    expressible.createModifierList().buildSyntax().write(to: &result)
     XCTAssertEqual(result, "private ")
   }
 
@@ -43,7 +43,7 @@ final class ArrayExpressibleAsTests: XCTestCase {
     )
 
     var result = ""
-    signature.buildSyntax(format: Format()).write(to: &result)
+    signature.buildSyntax().write(to: &result)
     XCTAssertEqual(result, "(_ args: [String]) -> Int")
   }
 }
diff --git a/Tests/SwiftSyntaxBuilderTest/ArrowExprTests.swift b/Tests/SwiftSyntaxBuilderTest/ArrowExprTests.swift
@@ -12,7 +12,7 @@ final class ArrowExprTests: XCTestCase {
     for (line, testCase) in testCases {
       let (builder, expected) = testCase
       let arrowExpr = builder.createArrowExpr()
-      let syntax = arrowExpr.buildSyntax(format: Format())
+      let syntax = arrowExpr.buildSyntax()
 
       var text = ""
       syntax.write(to: &text)
diff --git a/Tests/SwiftSyntaxBuilderTest/BinaryOperatorExprTests.swift b/Tests/SwiftSyntaxBuilderTest/BinaryOperatorExprTests.swift
@@ -13,7 +13,7 @@ final class BinaryOperatorExprTests: XCTestCase {
     for (line, testCase) in testCases {
       let (builder, expected) = testCase
       let binaryOperatorExpr = builder.createBinaryOperatorExpr()
-      let syntax = binaryOperatorExpr.buildSyntax(format: Format())
+      let syntax = binaryOperatorExpr.buildSyntax()
 
       var text = ""
       syntax.write(to: &text)
diff --git a/Tests/SwiftSyntaxBuilderTest/BooleanLiteralTests.swift b/Tests/SwiftSyntaxBuilderTest/BooleanLiteralTests.swift
@@ -15,7 +15,7 @@ final class BooleanLiteralTests: XCTestCase {
 
     for (line, testCase) in testCases {
       let (builder, expected) = testCase
-      let syntax = builder.buildSyntax(format: Format())
+      let syntax = builder.buildSyntax()
 
       var text = ""
       syntax.write(to: &text)
diff --git a/Tests/SwiftSyntaxBuilderTest/CollectionNodeFlatteningTests.swift b/Tests/SwiftSyntaxBuilderTest/CollectionNodeFlatteningTests.swift
@@ -24,7 +24,7 @@ final class CollectionNodeFlatteningTests: XCTestCase {
       buildOuterCodeBlockItemList()
     }
 
-    let test = codeBlock.buildSyntax(format: Format())
+    let test = codeBlock.buildSyntax()
 
     var result = ""
     test.write(to: &result)
@@ -63,7 +63,7 @@ final class CollectionNodeFlatteningTests: XCTestCase {
       )
     )
     
-    let test = codeBlock.buildSyntax(format: Format())
+    let test = codeBlock.buildSyntax()
     
     var result = ""
     test.write(to: &result)
diff --git a/Tests/SwiftSyntaxBuilderTest/CustomAttributeTests.swift b/Tests/SwiftSyntaxBuilderTest/CustomAttributeTests.swift
@@ -15,7 +15,7 @@ final class CustomAttributeTests: XCTestCase {
 
     for (line, testCase) in testCases {
       let (builder, expected) = testCase
-      let syntax = builder.buildSyntax(format: Format())
+      let syntax = builder.buildSyntax()
 
       var text = ""
       syntax.write(to: &text)
diff --git a/Tests/SwiftSyntaxBuilderTest/DoStmtTests.swift b/Tests/SwiftSyntaxBuilderTest/DoStmtTests.swift
@@ -29,7 +29,7 @@ final class DoStmtTests: XCTestCase {
         }
       ])
 
-    let syntax = buildable.buildSyntax(format: Format())
+    let syntax = buildable.buildSyntax()
     XCTAssertEqual(
       syntax.description,
       """
diff --git a/Tests/SwiftSyntaxBuilderTest/EnumCaseElementTests.swift b/Tests/SwiftSyntaxBuilderTest/EnumCaseElementTests.swift
@@ -24,7 +24,7 @@ final class EnumCaseElementTests: XCTestCase {
         EnumCaseElement(identifier: "hi")
       }
     }
-    let syntax = buildable.buildSyntax(format: Format())
+    let syntax = buildable.buildSyntax()
 
     XCTAssertEqual(syntax.description,
       """
diff --git a/Tests/SwiftSyntaxBuilderTest/ExprListTests.swift b/Tests/SwiftSyntaxBuilderTest/ExprListTests.swift
@@ -11,7 +11,7 @@ final class ExprListTests: XCTestCase {
 
     for (line, testCase) in testCases {
       let (builder, expected) = testCase
-      let syntax = builder.buildSyntax(format: Format())
+      let syntax = builder.buildSyntax()
 
       var text = ""
       syntax.write(to: &text)
diff --git a/Tests/SwiftSyntaxBuilderTest/ExpressibleBuildablesTests.swift b/Tests/SwiftSyntaxBuilderTest/ExpressibleBuildablesTests.swift
@@ -15,7 +15,7 @@ final class ExpressibleBuildablesTests: XCTestCase {
       StructDecl(identifier: "InnerStruct") {}
     }
 
-    let syntax = myStruct.buildSyntax(format: Format())
+    let syntax = myStruct.buildSyntax()
     XCTAssertEqual(syntax.description, """
     struct MyStruct {
         var myFirstVar: Int
@@ -33,7 +33,7 @@ final class ExpressibleBuildablesTests: XCTestCase {
       StructDecl(identifier: "MyStruct2") {}
     }
 
-    let syntax = myCodeBlock.buildSyntax(format: Format())
+    let syntax = myCodeBlock.buildSyntax()
     XCTAssertEqual(syntax.description, """
 
     struct MyStruct1 {
@@ -50,7 +50,7 @@ final class ExpressibleBuildablesTests: XCTestCase {
       "someIdentifier"
     }
     
-    let syntax = myCodeBlock.buildSyntax(format: Format())
+    let syntax = myCodeBlock.buildSyntax()
     XCTAssertEqual(syntax.description, """
     {
         print("Hello world")
@@ -76,7 +76,7 @@ final class ExpressibleBuildablesTests: XCTestCase {
       }
     }
 
-    let syntax = switchStmt.buildSyntax(format: Format())
+    let syntax = switchStmt.buildSyntax()
     XCTAssertEqual(
       syntax.description,
       """
diff --git a/Tests/SwiftSyntaxBuilderTest/ExtensionDeclTests.swift b/Tests/SwiftSyntaxBuilderTest/ExtensionDeclTests.swift
@@ -26,7 +26,7 @@ final class ExtensionDeclTests: XCTestCase {
                                   extendedType: "TokenSyntax",
                                   members: members)
 
-    let syntax = buildable.buildSyntax(format: Format())
+    let syntax = buildable.buildSyntax()
 
     var text = ""
     syntax.write(to: &text)
diff --git a/Tests/SwiftSyntaxBuilderTest/FloatLiteralTests.swift b/Tests/SwiftSyntaxBuilderTest/FloatLiteralTests.swift
@@ -17,7 +17,7 @@ final class FloatLiteralTests: XCTestCase {
 
     for (line, testCase) in testCases {
       let (builder, expected) = testCase
-      let syntax = builder.buildSyntax(format: Format())
+      let syntax = builder.buildSyntax()
 
       var text = ""
       syntax.write(to: &text)
diff --git a/Tests/SwiftSyntaxBuilderTest/FunctionTests.swift b/Tests/SwiftSyntaxBuilderTest/FunctionTests.swift
@@ -43,7 +43,7 @@ final class FunctionTests: XCTestCase {
         }
       })
     }
-    let syntax = buildable.buildSyntax(format: Format())
+    let syntax = buildable.buildSyntax()
 
     XCTAssertEqual(syntax.description, """
       ␣func fibonacci(_ n: Int) -> Int {
@@ -61,21 +61,21 @@ final class FunctionTests: XCTestCase {
         TupleExprElement(label: param.isMultiple(of: 2) ? "p\(param)" : nil, expression: "value\(param)")
       }
     }
-    let syntax = buildable.buildSyntax(format: Format())
+    let syntax = buildable.buildSyntax()
     XCTAssertEqual(syntax.description, "test(value1, p2: value2, value3, p4: value4, value5)")
   }
 
   func testParensEmittedForNoArgumentsAndNoTrailingClosure() {
     let buildable = FunctionCallExpr("test")
-    let syntax = buildable.buildSyntax(format: Format())
+    let syntax = buildable.buildSyntax()
     XCTAssertEqual(syntax.description, "test()")
   }
 
   func testParensEmittedForArgumentAndTrailingClosure() {
     let buildable = FunctionCallExpr("test", trailingClosure: ClosureExpr()) {
       TupleExprElement(expression: "42")
     }
-    let syntax = buildable.buildSyntax(format: Format())
+    let syntax = buildable.buildSyntax()
     XCTAssertEqual(syntax.description, "test(42) {\n}")
   }
 
@@ -86,7 +86,7 @@ final class FunctionTests: XCTestCase {
       }
     })
     let buildable = FunctionCallExpr("test", trailingClosure: closure)
-    let syntax = buildable.buildSyntax(format: Format())
+    let syntax = buildable.buildSyntax()
     XCTAssertEqual(
       syntax.description,
       """
diff --git a/Tests/SwiftSyntaxBuilderTest/IdentifierExprTests.swift b/Tests/SwiftSyntaxBuilderTest/IdentifierExprTests.swift
@@ -13,7 +13,7 @@ final class IdentifierExprTests: XCTestCase {
     for (line, testCase) in testCases {
       let (builder, expected) = testCase
       let identifierExpr = builder.createIdentifierExpr()
-      let syntax = identifierExpr.buildSyntax(format: Format())
+      let syntax = identifierExpr.buildSyntax()
 
       var text = ""
       syntax.write(to: &text)
diff --git a/Tests/SwiftSyntaxBuilderTest/IdentifierPatternTests.swift b/Tests/SwiftSyntaxBuilderTest/IdentifierPatternTests.swift
@@ -13,7 +13,7 @@ final class IdentifierPatternTests: XCTestCase {
     for (line, testCase) in testCases {
       let (builder, expected) = testCase
       let identifierPattern = builder.createIdentifierPattern()
-      let syntax = identifierPattern.buildSyntax(format: Format())
+      let syntax = identifierPattern.buildSyntax()
 
       var text = ""
       syntax.write(to: &text)
diff --git a/Tests/SwiftSyntaxBuilderTest/IfStmtTests.swift b/Tests/SwiftSyntaxBuilderTest/IfStmtTests.swift
@@ -8,7 +8,7 @@ final class IfStmtTests: XCTestCase {
     // disambiguated by the absence of a labelName parameter and the use of a
     // trailing closure.
     let buildable = IfStmt(conditions: ExprList([BooleanLiteralExpr(false)])) {}
-    let syntax = buildable.buildSyntax(format: Format())
+    let syntax = buildable.buildSyntax()
     XCTAssertEqual(syntax.description, """
       if false {
       }
@@ -27,7 +27,7 @@ final class IfStmtTests: XCTestCase {
         TupleExprElement(expression: StringLiteralExpr("Hello from the else-branch!"))
       }
     }
-    let syntax = buildable.buildSyntax(format: Format())
+    let syntax = buildable.buildSyntax()
     XCTAssertEqual(syntax.description, """
       if true {
           print("Hello from the if-branch!")
@@ -45,7 +45,7 @@ final class IfStmtTests: XCTestCase {
         initializer: InitializerClause(value: "y")
       )
     ) {}
-    let syntax = buildable.buildSyntax(format: Format())
+    let syntax = buildable.buildSyntax()
     XCTAssertEqual(syntax.description, """
       if let x = y {
       }
@@ -59,7 +59,7 @@ final class IfStmtTests: XCTestCase {
         initializer: InitializerClause(value: "y")
       )
     ) {}
-    let syntax = buildable.buildSyntax(format: Format())
+    let syntax = buildable.buildSyntax()
     XCTAssertEqual(syntax.description, """
       if case .x = y {
       }
diff --git a/Tests/SwiftSyntaxBuilderTest/ImportTests.swift b/Tests/SwiftSyntaxBuilderTest/ImportTests.swift
@@ -12,7 +12,7 @@ final class ImportTests: XCTestCase {
       path: AccessPath([AccessPathComponent(name: identifier)])
     )
 
-    let syntax = importDecl.buildDecl(format: Format())
+    let syntax = importDecl.buildSyntax()
 
     var text = ""
     syntax.write(to: &text)
diff --git a/Tests/SwiftSyntaxBuilderTest/IntegerLiteralTests.swift b/Tests/SwiftSyntaxBuilderTest/IntegerLiteralTests.swift
@@ -17,7 +17,7 @@ final class IntegerLiteralTests: XCTestCase {
 
     for (line, testCase) in testCases {
       let (builder, expected) = testCase
-      let syntax = builder.buildSyntax(format: Format())
+      let syntax = builder.buildSyntax()
 
       var text = ""
       syntax.write(to: &text)
diff --git a/Tests/SwiftSyntaxBuilderTest/MemberAccessTests.swift b/Tests/SwiftSyntaxBuilderTest/MemberAccessTests.swift
@@ -5,7 +5,7 @@ import SwiftSyntaxBuilder
 final class MemberAccessTests: XCTestCase {
   func testMemberAccessExprConvenienceInitializers() {
     let builder = MemberAccessExpr( base: "Foo", name: "bar")
-    let syntax = builder.buildSyntax(format: Format())
+    let syntax = builder.buildSyntax()
 
     var text = ""
     syntax.write(to: &text)
diff --git a/Tests/SwiftSyntaxBuilderTest/PrefixOperatorExprTests.swift b/Tests/SwiftSyntaxBuilderTest/PrefixOperatorExprTests.swift
@@ -13,7 +13,7 @@ final class PrefixOperatorExprTests: XCTestCase {
     for (line, testCase) in testCases {
       let (builder, expected) = testCase
       let expr = builder.createPrefixOperatorExpr()
-      let syntax = expr.buildSyntax(format: Format())
+      let syntax = expr.buildSyntax()
 
       var text = ""
       syntax.write(to: &text)
diff --git a/Tests/SwiftSyntaxBuilderTest/ProtocolDeclTests.swift b/Tests/SwiftSyntaxBuilderTest/ProtocolDeclTests.swift
@@ -15,7 +15,7 @@ final class ProtocolDeclTests: XCTestCase {
       FunctionDecl(identifier: .identifier("buildDeclList"), signature: functionSignature, body: nil)
     }
 
-    let syntax = buildable.buildSyntax(format: Format())
+    let syntax = buildable.buildSyntax()
 
     var text = ""
     syntax.write(to: &text)
diff --git a/Tests/SwiftSyntaxBuilderTest/ReturnClauseTests.swift b/Tests/SwiftSyntaxBuilderTest/ReturnClauseTests.swift
@@ -13,7 +13,7 @@ final class ReturnClauseTests: XCTestCase {
     for (line, testCase) in testCases {
       let (builder, expected) = testCase
       let returnClause = builder.createReturnClause()
-      let syntax = returnClause.buildSyntax(format: Format())
+      let syntax = returnClause.buildSyntax()
 
       var text = ""
       syntax.write(to: &text)
diff --git a/Tests/SwiftSyntaxBuilderTest/SimpleTypeIdentifierTests.swift b/Tests/SwiftSyntaxBuilderTest/SimpleTypeIdentifierTests.swift
@@ -13,7 +13,7 @@ final class SimpleTypeIdentifierTests: XCTestCase {
     for (line, testCase) in testCases {
       let (builder, expected) = testCase
       let identifier = builder.createSimpleTypeIdentifier()
-      let syntax = identifier.buildSyntax(format: Format())
+      let syntax = identifier.buildSyntax()
 
       var text = ""
       syntax.write(to: &text)
diff --git a/Tests/SwiftSyntaxBuilderTest/SourceFileTests.swift b/Tests/SwiftSyntaxBuilderTest/SourceFileTests.swift
@@ -12,7 +12,7 @@ final class SourceFileTests: XCTestCase {
       })
     }
 
-    let syntax = source.buildSyntax(format: Format())
+    let syntax = source.buildSyntax()
 
     var text = ""
     syntax.write(to: &text)
diff --git a/Tests/SwiftSyntaxBuilderTest/StringLiteralTests.swift b/Tests/SwiftSyntaxBuilderTest/StringLiteralTests.swift
@@ -18,7 +18,7 @@ final class StringLiteralTests: XCTestCase {
                                       openQuote: .stringQuote,
                                       segments: StringLiteralSegments([segment]),
                                       closeQuote: .stringQuote)
-      let syntax = builder.buildSyntax(format: Format())
+      let syntax = builder.buildSyntax()
 
       var text = ""
       syntax.write(to: &text)
@@ -44,7 +44,7 @@ final class StringLiteralTests: XCTestCase {
     for (line, testCase) in testCases {
       let (builder, expected) = testCase
       let stringLiteralExpr = builder.createStringLiteralExpr()
-      let syntax = stringLiteralExpr.buildSyntax(format: Format())
+      let syntax = stringLiteralExpr.buildSyntax()
 
       var text = ""
       syntax.write(to: &text)
diff --git a/Tests/SwiftSyntaxBuilderTest/StructTests.swift b/Tests/SwiftSyntaxBuilderTest/StructTests.swift
diff --git a/Tests/SwiftSyntaxBuilderTest/TernaryExprTests.swift b/Tests/SwiftSyntaxBuilderTest/TernaryExprTests.swift
diff --git a/Tests/SwiftSyntaxBuilderTest/TriviaTests.swift b/Tests/SwiftSyntaxBuilderTest/TriviaTests.swift
diff --git a/Tests/SwiftSyntaxBuilderTest/TypeAnnotationTests.swift b/Tests/SwiftSyntaxBuilderTest/TypeAnnotationTests.swift
diff --git a/Tests/SwiftSyntaxBuilderTest/TypeInitializerClauseTests.swift b/Tests/SwiftSyntaxBuilderTest/TypeInitializerClauseTests.swift
diff --git a/Tests/SwiftSyntaxBuilderTest/VariableTests.swift b/Tests/SwiftSyntaxBuilderTest/VariableTests.swift

Original file line number	Diff line number	Diff line change
`@@ -131,4 +131,17 @@ let buildableBaseProtocolsFile = SourceFile {`
`131`	`131`	`}`
`132`	`132`	`}`
`133`	`133`	`}`
	`134`	`+ createBuildSyntaxExtensionWithDefaultFormat()`
	`135`	`+}`
	`136`	`+`
	`137`	`+func createBuildSyntaxExtensionWithDefaultFormat() -> ExtensionDecl {`
	`138`	`+ return ExtensionDecl(modifiers: [Token.public], extendedType: "SyntaxBuildable") {`
	`139`	`+ FunctionDecl(`
	`140`	`+ identifier: .identifier("buildSyntax"),`
	`141`	`+ signature: FunctionSignature(input: ParameterClause(parameterList: []), output: "Syntax")) {`
	`142`	`+ ReturnStmt(expression: FunctionCallExpr("buildSyntax") {`
	`143`	`+ TupleExprElement(label: "format", expression: FunctionCallExpr("Format"))`
	`144`	`+ })`
	`145`	`+ }`
	`146`	`+ }`
`134`	`147`	`}`
Original file line number	Diff line number	Diff line change
`@@ -192,3 +192,8 @@ public extension TypeBuildable {`
`192`	`192`	`return Syntax(buildType(format: format))`
`193`	`193`	`}`
`194`	`194`	`}`
	`195`	`+public extension SyntaxBuildable {`
	`196`	`+ func buildSyntax() -> Syntax {`
	`197`	`+ return buildSyntax(format: Format())`
	`198`	`+ }`
	`199`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -7,15 +7,15 @@ final class ArrayExpressibleAsTests: XCTestCase {`
`7`	`7`	`let modifiers: ExpressibleAsModifierList = [Token.public, Token.static]`
`8`	`8`
`9`	`9`	`var result = ""`
`10`		`- modifiers.createModifierList().buildSyntax(format: Format()).write(to: &result)`
	`10`	`+ modifiers.createModifierList().buildSyntax().write(to: &result)`
`11`	`11`	`XCTAssertEqual(result, "public static ")`
`12`	`12`	`}`
`13`	`13`
`14`	`14`	`func testHeterogeneousList() {`
`15`	`15`	`let modifiers: ExpressibleAsModifierList = [Token.open, DeclModifier(name: Token.internal)]`
`16`	`16`
`17`	`17`	`var result = ""`
`18`		`- modifiers.createModifierList().buildSyntax(format: Format()).write(to: &result)`
	`18`	`+ modifiers.createModifierList().buildSyntax().write(to: &result)`
`19`	`19`	`XCTAssertEqual(result, "open internal ")`
`20`	`20`	`}`
`21`	`21`
`@@ -24,7 +24,7 @@ final class ArrayExpressibleAsTests: XCTestCase {`
`24`	`24`	`let expressible: ExpressibleAsModifierList = modifiers as [ExpressibleAsDeclModifier]`
`25`	`25`
`26`	`26`	`var result = ""`
`27`		`- expressible.createModifierList().buildSyntax(format: Format()).write(to: &result)`
	`27`	`+ expressible.createModifierList().buildSyntax().write(to: &result)`
`28`	`28`	`XCTAssertEqual(result, "private ")`
`29`	`29`	`}`
`30`	`30`
`@@ -43,7 +43,7 @@ final class ArrayExpressibleAsTests: XCTestCase {`
`43`	`43`	`)`
`44`	`44`
`45`	`45`	`var result = ""`
`46`		`- signature.buildSyntax(format: Format()).write(to: &result)`
	`46`	`+ signature.buildSyntax().write(to: &result)`
`47`	`47`	`XCTAssertEqual(result, "(_ args: [String]) -> Int")`
`48`	`48`	`}`
`49`	`49`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ final class CollectionNodeFlatteningTests: XCTestCase {`
`24`	`24`	`buildOuterCodeBlockItemList()`
`25`	`25`	`}`
`26`	`26`
`27`		`- let test = codeBlock.buildSyntax(format: Format())`
	`27`	`+ let test = codeBlock.buildSyntax()`
`28`	`28`
`29`	`29`	`var result = ""`
`30`	`30`	`test.write(to: &result)`
`@@ -63,7 +63,7 @@ final class CollectionNodeFlatteningTests: XCTestCase {`
`63`	`63`	`)`
`64`	`64`	`)`
`65`	`65`
`66`		`- let test = codeBlock.buildSyntax(format: Format())`
	`66`	`+ let test = codeBlock.buildSyntax()`
`67`	`67`
`68`	`68`	`var result = ""`
`69`	`69`	`test.write(to: &result)`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ final class DoStmtTests: XCTestCase {`
`29`	`29`	`}`
`30`	`30`	`])`
`31`	`31`
`32`		`- let syntax = buildable.buildSyntax(format: Format())`
	`32`	`+ let syntax = buildable.buildSyntax()`
`33`	`33`	`XCTAssertEqual(`
`34`	`34`	`syntax.description,`
`35`	`35`	`"""`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ final class EnumCaseElementTests: XCTestCase {`
`24`	`24`	`EnumCaseElement(identifier: "hi")`
`25`	`25`	`}`
`26`	`26`	`}`
`27`		`- let syntax = buildable.buildSyntax(format: Format())`
	`27`	`+ let syntax = buildable.buildSyntax()`
`28`	`28`
`29`	`29`	`XCTAssertEqual(syntax.description,`
`30`	`30`	`"""`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ final class ExpressibleBuildablesTests: XCTestCase {`
`15`	`15`	`StructDecl(identifier: "InnerStruct") {}`
`16`	`16`	`}`
`17`	`17`
`18`		`- let syntax = myStruct.buildSyntax(format: Format())`
	`18`	`+ let syntax = myStruct.buildSyntax()`
`19`	`19`	`XCTAssertEqual(syntax.description, """`
`20`	`20`	`struct MyStruct {`
`21`	`21`	`var myFirstVar: Int`
`@@ -33,7 +33,7 @@ final class ExpressibleBuildablesTests: XCTestCase {`
`33`	`33`	`StructDecl(identifier: "MyStruct2") {}`
`34`	`34`	`}`
`35`	`35`
`36`		`- let syntax = myCodeBlock.buildSyntax(format: Format())`
	`36`	`+ let syntax = myCodeBlock.buildSyntax()`
`37`	`37`	`XCTAssertEqual(syntax.description, """`
`38`	`38`
`39`	`39`	`struct MyStruct1 {`
`@@ -50,7 +50,7 @@ final class ExpressibleBuildablesTests: XCTestCase {`
`50`	`50`	`"someIdentifier"`
`51`	`51`	`}`
`52`	`52`
`53`		`- let syntax = myCodeBlock.buildSyntax(format: Format())`
	`53`	`+ let syntax = myCodeBlock.buildSyntax()`
`54`	`54`	`XCTAssertEqual(syntax.description, """`
`55`	`55`	`{`
`56`	`56`	`print("Hello world")`
`@@ -76,7 +76,7 @@ final class ExpressibleBuildablesTests: XCTestCase {`
`76`	`76`	`}`
`77`	`77`	`}`
`78`	`78`
`79`		`- let syntax = switchStmt.buildSyntax(format: Format())`
	`79`	`+ let syntax = switchStmt.buildSyntax()`
`80`	`80`	`XCTAssertEqual(`
`81`	`81`	`syntax.description,`
`82`	`82`	`"""`
Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ final class FunctionTests: XCTestCase {`
`43`	`43`	`}`
`44`	`44`	`})`
`45`	`45`	`}`
`46`		`- let syntax = buildable.buildSyntax(format: Format())`
	`46`	`+ let syntax = buildable.buildSyntax()`
`47`	`47`
`48`	`48`	`XCTAssertEqual(syntax.description, """`
`49`	`49`	`␣func fibonacci(_ n: Int) -> Int {`
`@@ -61,21 +61,21 @@ final class FunctionTests: XCTestCase {`
`61`	`61`	`TupleExprElement(label: param.isMultiple(of: 2) ? "p\(param)" : nil, expression: "value\(param)")`
`62`	`62`	`}`
`63`	`63`	`}`
`64`		`- let syntax = buildable.buildSyntax(format: Format())`
	`64`	`+ let syntax = buildable.buildSyntax()`
`65`	`65`	`XCTAssertEqual(syntax.description, "test(value1, p2: value2, value3, p4: value4, value5)")`
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`func testParensEmittedForNoArgumentsAndNoTrailingClosure() {`
`69`	`69`	`let buildable = FunctionCallExpr("test")`
`70`		`- let syntax = buildable.buildSyntax(format: Format())`
	`70`	`+ let syntax = buildable.buildSyntax()`
`71`	`71`	`XCTAssertEqual(syntax.description, "test()")`
`72`	`72`	`}`
`73`	`73`
`74`	`74`	`func testParensEmittedForArgumentAndTrailingClosure() {`
`75`	`75`	`let buildable = FunctionCallExpr("test", trailingClosure: ClosureExpr()) {`
`76`	`76`	`TupleExprElement(expression: "42")`
`77`	`77`	`}`
`78`		`- let syntax = buildable.buildSyntax(format: Format())`
	`78`	`+ let syntax = buildable.buildSyntax()`
`79`	`79`	`XCTAssertEqual(syntax.description, "test(42) {\n}")`
`80`	`80`	`}`
`81`	`81`
`@@ -86,7 +86,7 @@ final class FunctionTests: XCTestCase {`
`86`	`86`	`}`
`87`	`87`	`})`
`88`	`88`	`let buildable = FunctionCallExpr("test", trailingClosure: closure)`
`89`		`- let syntax = buildable.buildSyntax(format: Format())`
	`89`	`+ let syntax = buildable.buildSyntax()`
`90`	`90`	`XCTAssertEqual(`
`91`	`91`	`syntax.description,`
`92`	`92`	`"""`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ final class IfStmtTests: XCTestCase {`
`8`	`8`	`// disambiguated by the absence of a labelName parameter and the use of a`
`9`	`9`	`// trailing closure.`
`10`	`10`	`let buildable = IfStmt(conditions: ExprList([BooleanLiteralExpr(false)])) {}`
`11`		`- let syntax = buildable.buildSyntax(format: Format())`
	`11`	`+ let syntax = buildable.buildSyntax()`
`12`	`12`	`XCTAssertEqual(syntax.description, """`
`13`	`13`	`if false {`
`14`	`14`	`}`
`@@ -27,7 +27,7 @@ final class IfStmtTests: XCTestCase {`
`27`	`27`	`TupleExprElement(expression: StringLiteralExpr("Hello from the else-branch!"))`
`28`	`28`	`}`
`29`	`29`	`}`
`30`		`- let syntax = buildable.buildSyntax(format: Format())`
	`30`	`+ let syntax = buildable.buildSyntax()`
`31`	`31`	`XCTAssertEqual(syntax.description, """`
`32`	`32`	`if true {`
`33`	`33`	`print("Hello from the if-branch!")`
`@@ -45,7 +45,7 @@ final class IfStmtTests: XCTestCase {`
`45`	`45`	`initializer: InitializerClause(value: "y")`
`46`	`46`	`)`
`47`	`47`	`) {}`
`48`		`- let syntax = buildable.buildSyntax(format: Format())`
	`48`	`+ let syntax = buildable.buildSyntax()`
`49`	`49`	`XCTAssertEqual(syntax.description, """`
`50`	`50`	`if let x = y {`
`51`	`51`	`}`
`@@ -59,7 +59,7 @@ final class IfStmtTests: XCTestCase {`
`59`	`59`	`initializer: InitializerClause(value: "y")`
`60`	`60`	`)`
`61`	`61`	`) {}`
`62`		`- let syntax = buildable.buildSyntax(format: Format())`
	`62`	`+ let syntax = buildable.buildSyntax()`
`63`	`63`	`XCTAssertEqual(syntax.description, """`
`64`	`64`	`if case .x = y {`
`65`	`65`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ final class ImportTests: XCTestCase {`
`12`	`12`	`path: AccessPath([AccessPathComponent(name: identifier)])`
`13`	`13`	`)`
`14`	`14`
`15`		`- let syntax = importDecl.buildDecl(format: Format())`
	`15`	`+ let syntax = importDecl.buildSyntax()`
`16`	`16`
`17`	`17`	`var text = ""`
`18`	`18`	`syntax.write(to: &text)`