Add ExtensionDecl test

Author: kimdv

Sources/SwiftSyntaxBuilder/FunctionCallExprConvenienceInitializers.swift

@@ -19,7 +19,7 @@ extension FunctionCallExpr {
     leftParen: TokenSyntax? = nil,
     rightParen: TokenSyntax? = nil,
     trailingClosure: ExpressibleAsClosureExpr? = nil,
-    @TupleExprElementListBuilder argumentListBuilder: () -> TupleExprElementList = { .empty },
+    @TupleExprElementListBuilder argumentListBuilder: () -> ExpressibleAsTupleExprElementList = { TupleExprElementList.empty },
     @MultipleTrailingClosureElementListBuilder additionalTrailingClosuresBuilder: () -> MultipleTrailingClosureElementList? = { nil }
   ) {
     self.init(

Sources/SwiftSyntaxBuilder/IdentifierExprConvenienceInitializers.swift

@@ -15,9 +15,3 @@ extension IdentifierExpr {
     self.init(identifier: .identifier(identifier))
   }
 }
-
-extension IdentifierExpr: ExpressibleByStringLiteral {
-  public init(stringLiteral value: String) {
-    self.init(value)
-  }
-}

Sources/SwiftSyntaxBuilder/IdentifierPatternConvenienceInitializers.swift

@@ -15,9 +15,3 @@ extension IdentifierPattern {
     self.init(identifier: .identifier(identifier))
   }
 }
-
-extension IdentifierPattern: ExpressibleByStringLiteral {
-  public init(stringLiteral value: String) {
-    self.init(value)
-  }
-}

Sources/SwiftSyntaxBuilder/SimpleTypeIdentifierConvenienceInitializers.swift

@@ -14,13 +14,7 @@ import SwiftSyntax
 
 extension SimpleTypeIdentifier {
   public init(_ name: String) {
-    self.init(name: SyntaxFactory.makeIdentifier(name),
+    self.init(name: .identifier(name),
               genericArgumentClause: nil)
   }
 }
-
-extension SimpleTypeIdentifier: ExpressibleByStringLiteral {
-  public init(stringLiteral value: String) {
-    self.init(value)
-  }
-}

Sources/SwiftSyntaxBuilder/StringLiteralExprConvenienceInitializers.swift

@@ -23,9 +23,3 @@ extension StringLiteralExpr {
               closeQuote: closeQuote)
   }
 }
-
-extension StringLiteralExpr: ExpressibleByStringLiteral {
-  public init(stringLiteral value: String) {
-    self.init(value)
-  }
-}

Sources/SwiftSyntaxBuilder/TypeAnnotationConvenienceInitializers.swift

@@ -15,9 +15,3 @@ extension TypeAnnotation {
     self.init(type: SimpleTypeIdentifier(type))
   }
 }
-
-extension TypeAnnotation: ExpressibleByStringLiteral {
-  public init(stringLiteral value: String) {
-    self.init(value)
-  }
-}

Tests/SwiftSyntaxBuilderTest/BinaryOperatorExprTests.swift

@@ -15,10 +15,10 @@ final class BinaryOperatorExprTests: XCTestCase {
       let (builder, expected) = testCase
       let binaryOperatorExpr = builder.createBinaryOperatorExpr()
       let syntax = binaryOperatorExpr.buildSyntax(format: Format(), leadingTrivia: leadingTrivia)
-      
+
       var text = ""
       syntax.write(to: &text)
-      
+
       XCTAssertEqual(text, expected, line: line)
     }
   }

Tests/SwiftSyntaxBuilderTest/ExtensionDeclTests.swift

@@ -0,0 +1,48 @@
+import XCTest
+import SwiftSyntax
+import SwiftSyntaxBuilder
+
+final class ExtensionDeclTests: XCTestCase {
+  func testExtensionDecl() {
+    let leadingTrivia = Trivia.garbageText("␣")
+
+    let keywords = ["associatedtype", "class"].map { keyword -> VariableDecl in
+      // We need to use `CodeBlock` here to ensure there is braces around.
+      let body = CodeBlock(statementsBuilder: {
+        FunctionCallExpr("SyntaxFactory.make\(keyword)Keyword",
+                         leftParen: .leftParen,
+                         rightParen: .rightParen)
+      })
+
+      return VariableDecl(letOrVarKeyword: .var,
+                          modifiersBuilder: { TokenSyntax.public },
+                          bindingsBuilder: {
+        PatternBinding(pattern: "`\(keyword)`",
+                       typeAnnotation: "TokenSyntax",
+                       initializer: nil,
+                       accessor: body)
+
+      })
+    }
+    let members = MemberDeclList(keywords)
+    let buildable = ExtensionDecl(modifiers: nil,
+                                  extendedType: "TokenSyntax",
+                                  members: members)
+
+    let syntax = buildable.buildSyntax(format: Format(), leadingTrivia: leadingTrivia)
+
+    var text = ""
+    syntax.write(to: &text)
+
+    XCTAssertEqual(text, """
+    ␣extension TokenSyntax{
+        public var `associatedtype`: TokenSyntax{
+            SyntaxFactory.makeassociatedtypeKeyword()
+        }
+        public var `class`: TokenSyntax{
+            SyntaxFactory.makeclassKeyword()
+        }
+    }
+    """)
+  }
+}

Tests/SwiftSyntaxBuilderTest/FunctionTests.swift

@@ -3,20 +3,17 @@ import SwiftSyntax
 import SwiftSyntaxBuilder
 
 final class FunctionTests: XCTestCase {
-  func testEmptyStruct() {
+  func testFibonacci() {
     let leadingTrivia = Trivia.garbageText("␣")
 
     let input = ParameterClause(parameterListBuilder: {
       FunctionParameter(firstName: .wildcard, secondName: .identifier("n"), colon: .colon, type: "Int", attributesBuilder: {})
     })
 
-    let ifCodeBlock = CodeBlock(statementsBuilder: {
-      ReturnStmt(expression: IntegerLiteralExpr(digits: "n"))
-    })
-
+    let ifCodeBlock = ReturnStmt(expression: IntegerLiteralExpr(digits: "n"))
+    
     let signature = FunctionSignature(input: input, output: "Int")
 
-
     let codeBlock = CodeBlock(statementsBuilder: {
       IfStmt(conditions: ExprList([
         IntegerLiteralExpr(digits: "n"),

Tests/SwiftSyntaxBuilderTest/IdentifierExprTests.swift

@@ -8,7 +8,6 @@ final class IdentifierExprTests: XCTestCase {
 
     let testCases: [UInt: (ExpressibleAsIdentifierExpr, String)] = [
       #line: (IdentifierExpr(identifier: .identifier("Test")), "␣Test"),
-      #line: (IdentifierExpr(stringLiteral: "Test"), "␣Test"),
       #line: (IdentifierExpr("Test"), "␣Test"),
       #line: ("Test", "␣Test")
     ]

Tests/SwiftSyntaxBuilderTest/IdentifierPatternTests.swift

@@ -8,7 +8,6 @@ final class IdentifierPatternTests: XCTestCase {
 
     let testCases: [UInt: (ExpressibleAsIdentifierPattern, String)] = [
       #line: (IdentifierPattern(identifier: .identifier("Test")), "␣Test"),
-      #line: (IdentifierPattern(stringLiteral: "Test"), "␣Test"),
       #line: (IdentifierPattern("Test"), "␣Test"),
       #line: ("Test", "␣Test")
     ]

Tests/SwiftSyntaxBuilderTest/TypeAnnotationTests.swift

@@ -9,7 +9,6 @@ final class TypeAnnotationTests: XCTestCase {
     let testCases: [UInt: (ExpressibleAsTypeAnnotation, String)] = [
       #line: (TypeAnnotation(type: "Test"), "␣: Test"),
       #line: (TypeAnnotation(type: SimpleTypeIdentifier("Test")), "␣: Test"),
-      #line: (TypeAnnotation(stringLiteral: "Test"), "␣: Test"),
       #line: (TypeAnnotation("Test"), "␣: Test"),
       #line: (SimpleTypeIdentifier("Test"), "␣: Test"),
       #line: ("Test", "␣: Test")