Clean code and add some tests

Sources/SwiftSyntaxBuilder/IdentifierPatternConvenienceInitializers.swift

@@ -11,9 +11,9 @@
 //===----------------------------------------------------------------------===//
 
 extension IdentifierPattern {
-    init(_ identifier: String) {
-        self.init(identifier: .identifier(identifier))
-    }
+  public init(_ identifier: String) {
+    self.init(identifier: .identifier(identifier))
+  }
 }
 
 extension IdentifierPattern: ExpressibleByStringLiteral {

Sources/SwiftSyntaxBuilder/VariableDeclConvenienceInitializers.swift

@@ -13,10 +13,10 @@
 import SwiftSyntax
 
 extension VariableDecl {
-    public init(_ letOrVarKeyword: TokenSyntax, name: String, type: String) {
-        self.init(letOrVarKeyword: letOrVarKeyword, bindingsBuilder:  {
-            PatternBinding(pattern: IdentifierPattern(name),
-                           typeAnnotation: TypeAnnotation(type))
-        })
-    }
+  public init(_ letOrVarKeyword: TokenSyntax, name: String, type: String) {
+    self.init(letOrVarKeyword: letOrVarKeyword, bindingsBuilder: {
+      PatternBinding(pattern: IdentifierPattern(name),
+                     typeAnnotation: TypeAnnotation(type))
+      })
+  }
 }

Tests/SwiftSyntaxBuilderTest/BooleanLiteralTests.swift

@@ -1,6 +1,5 @@
 import XCTest
 import SwiftSyntax
-
 import SwiftSyntaxBuilder
 
 final class BooleanLiteralTests: XCTestCase {

Tests/SwiftSyntaxBuilderTest/ExpressibleBuildablesTests.swift

@@ -1,86 +1,85 @@
 import XCTest
 import SwiftSyntax
-
 import SwiftSyntaxBuilder
 
 final class ExpressibleBuildablesTests: XCTestCase {
-    func testExpressibleAsMemberDeclListItem() {
-        let myStruct = StructDecl(identifier: "MyStruct", members: MemberDeclBlock(membersBuilder: {
-            VariableDecl(.var, name: "myFirstVar", type: "Int")
+  func testExpressibleAsMemberDeclListItem() {
+    let myStruct = StructDecl(identifier: "MyStruct", members: MemberDeclBlock(membersBuilder: {
+      VariableDecl(.var, name: "myFirstVar", type: "Int")
 
-            // We use `MemberDeclListItem` to ensure and show we can combine it with `ExpressibleAsMemberDeclListItem`
-            MemberDeclListItem(decl: VariableDecl(letOrVarKeyword: .let, bindingsBuilder: {
-                    PatternBinding(pattern: IdentifierPattern(identifier: .identifier("myOtherLet")),
-                                   typeAnnotation: TypeAnnotation(type: SimpleTypeIdentifier("String")))
-                })
-            )
+      // We use `MemberDeclListItem` to ensure and show we can combine it with `ExpressibleAsMemberDeclListItem`
+      MemberDeclListItem(decl: VariableDecl(letOrVarKeyword: .let, bindingsBuilder: {
+        PatternBinding(pattern: IdentifierPattern(identifier: .identifier("myOtherLet")),
+                       typeAnnotation: TypeAnnotation(type: SimpleTypeIdentifier("String")))
+      })
+      )
 
-            StructDecl(identifier: "InnerStruct", members: MemberDeclBlock())
-        })
-        )
+      StructDecl(identifier: "InnerStruct", members: MemberDeclBlock())
+    })
+    )
 
-        let syntax = myStruct.buildSyntax(format: Format())
-        XCTAssertEqual(syntax.description, """
-        struct MyStruct{
-            var myFirstVar: Int
-            let myOtherLet: String
-            struct InnerStruct{
-            }
+    let syntax = myStruct.buildSyntax(format: Format())
+    XCTAssertEqual(syntax.description, """
+    struct MyStruct{
+        var myFirstVar: Int
+        let myOtherLet: String
+        struct InnerStruct{
         }
-        """)
     }
+    """)
+  }
 
-    func testExpressibleAsCodeBlockItem() {
-        let myCodeBlock = SourceFile(eofToken: .eof) {
-            StructDecl(identifier: "MyStruct1", members: MemberDeclBlock())
+  func testExpressibleAsCodeBlockItem() {
+    let myCodeBlock = SourceFile(eofToken: .eof) {
+      StructDecl(identifier: "MyStruct1", members: MemberDeclBlock())
 
-            StructDecl(identifier: "MyStruct2", members: MemberDeclBlock())
-        }
+      StructDecl(identifier: "MyStruct2", members: MemberDeclBlock())
+    }
 
-        let syntax = myCodeBlock.buildSyntax(format: Format())
-        XCTAssertEqual(syntax.description, """
+    let syntax = myCodeBlock.buildSyntax(format: Format())
+    XCTAssertEqual(syntax.description, """
 
-        struct MyStruct1{
-        }
-        struct MyStruct2{
-        }
-        """)
+    struct MyStruct1{
     }
+    struct MyStruct2{
+    }
+    """)
+  }
 
-    func testExpressibleAsSwitchStmt() {
-        let versions = [("version_1", "1.0.0"), ("version_2", "2.0.0"), ("version_3", "3.0.0"), ("version_3_1", "3.1.0")]
-        let expression = IdentifierExpr(identifier: SyntaxFactory.makeIdentifier("version"))
+  func testExpressibleAsSwitchStmt() {
+    let versions = [("version_1", "1.0.0"), ("version_2", "2.0.0"), ("version_3", "3.0.0"), ("version_3_1", "3.1.0")]
+    let expression = IdentifierExpr(identifier: SyntaxFactory.makeIdentifier("version"))
 
-        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))))
-                })
-            }
+    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))))
         })
+      }
+    })
 
-        let syntax = switchStmt.buildSyntax(format: Format())
+    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"
+    // 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"
 
-        }
-        """)
     }
+    """)
+  }
 }

Tests/SwiftSyntaxBuilderTest/FloatLiteralTests.swift

@@ -1,6 +1,5 @@
 import XCTest
 import SwiftSyntax
-
 import SwiftSyntaxBuilder
 
 final class FloatLiteralTests: XCTestCase {

Tests/SwiftSyntaxBuilderTest/FormatTests.swift

@@ -1,6 +1,5 @@
 import XCTest
 import SwiftSyntax
-
 import SwiftSyntaxBuilder
 
 final class FormatTests: XCTestCase {

Tests/SwiftSyntaxBuilderTest/IdentifierExprTests.swift

@@ -1,6 +1,5 @@
 import XCTest
 import SwiftSyntax
-
 import SwiftSyntaxBuilder
 
 final class IdentifierExprTests: XCTestCase {

Tests/SwiftSyntaxBuilderTest/IdentifierPatternTests.swift

@@ -0,0 +1,26 @@
+import XCTest
+import SwiftSyntax
+import SwiftSyntaxBuilder
+
+final class IdentifierPatternTests: XCTestCase {
+  func testStringLiteral() {
+    let leadingTrivia = Trivia.garbageText("␣")
+
+    let testCases: [UInt: (IdentifierPattern, String)] = [
+      #line: (IdentifierPattern(identifier: .identifier("Test")), "␣Test"),
+      #line: (IdentifierPattern(stringLiteral: "Test"), "␣Test"),
+      #line: (IdentifierPattern("Test"), "␣Test"),
+      #line: ("Test", "␣Test")
+    ]
+
+    for (line, testCase) in testCases {
+      let (builder, expected) = testCase
+      let syntax = builder.buildSyntax(format: Format(), leadingTrivia: leadingTrivia)
+
+      var text = ""
+      syntax.write(to: &text)
+
+      XCTAssertEqual(text, expected, line: line)
+    }
+  }
+}

Tests/SwiftSyntaxBuilderTest/ImportTests.swift

@@ -1,6 +1,5 @@
 import XCTest
 import SwiftSyntax
-
 import SwiftSyntaxBuilder
 
 final class ImportTests: XCTestCase {

Tests/SwiftSyntaxBuilderTest/IntegerLiteralTests.swift

@@ -1,6 +1,5 @@
 import XCTest
 import SwiftSyntax
-
 import SwiftSyntaxBuilder
 
 final class IntegerLiteralTests: XCTestCase {

Tests/SwiftSyntaxBuilderTest/StringLiteralTests.swift

@@ -1,6 +1,5 @@
 import XCTest
 import SwiftSyntax
-
 import SwiftSyntaxBuilder
 
 final class StringLiteralTests: XCTestCase {

Tests/SwiftSyntaxBuilderTest/StructTests.swift

@@ -1,6 +1,5 @@
 import XCTest
 import SwiftSyntax
-
 import SwiftSyntaxBuilder
 
 final class StructTests: XCTestCase {

Tests/SwiftSyntaxBuilderTest/TypeAnnotationTests.swift

@@ -0,0 +1,26 @@
+import XCTest
+import SwiftSyntax
+import SwiftSyntaxBuilder
+
+final class TypeAnnotationTests: XCTestCase {
+  func testStringLiteral() {
+    let leadingTrivia = Trivia.garbageText("␣")
+
+    let testCases: [UInt: (TypeAnnotation, String)] = [
+      #line: (TypeAnnotation(type: SimpleTypeIdentifier("Test")), "␣: Test"),
+      #line: (TypeAnnotation(stringLiteral: "Test"), "␣: Test"),
+      #line: (TypeAnnotation("Test"), "␣: Test"),
+      #line: ("Test", "␣: Test")
+    ]
+
+    for (line, testCase) in testCases {
+      let (builder, expected) = testCase
+      let syntax = builder.buildSyntax(format: Format(), leadingTrivia: leadingTrivia)
+
+      var text = ""
+      syntax.write(to: &text)
+
+      XCTAssertEqual(text, expected, line: line)
+    }
+  }
+}

Tests/SwiftSyntaxBuilderTest/VariableTests.swift

@@ -1,6 +1,5 @@
 import XCTest
 import SwiftSyntax
-
 import SwiftSyntaxBuilder
 
 final class VariableTests: XCTestCase {