Add trailing trivia and with{Leading,Trailing}Trivia to buildable nodes

Sources/generate-swift-syntax-builder/String+Extensions.swift

@@ -14,5 +14,6 @@ import Foundation
 
 extension StringProtocol {
     var withFirstCharacterLowercased: String { prefix(1).lowercased() + dropFirst() }
+    var withFirstCharacterUppercased: String { prefix(1).uppercased() + dropFirst() }
     var backticked: String { "`\(self)`" }
 }

Sources/generate-swift-syntax-builder/SyntaxUtilities.swift

@@ -99,3 +99,59 @@ func createDisambiguatingExpressibleAsCreateFunction(type: SyntaxBuildableType,
     "/// through `ExpressibleAs*` protocols. To resolve the ambiguity, provie a fixed implementation that doesn't perform any conversions.",
   ]) 
 }
+
+/// Generate a `withATrivia` function.
+func createWithTriviaFunction(trivia: String) -> FunctionDecl {
+  FunctionDecl(
+    modifiers: [Token.public],
+    identifier: .identifier("with\(trivia.withFirstCharacterUppercased)"),
+    signature: FunctionSignature(
+      input: ParameterClause {
+        FunctionParameter(
+          firstName: .wildcard,
+          secondName: .identifier(trivia),
+          colon: .colon,
+          type: "Trivia"
+        )
+      },
+      output: "Self"
+    )
+  ) {
+    VariableDecl(.var, name: "result", initializer: "self")
+    SequenceExpr {
+      MemberAccessExpr(base: "result", name: trivia)
+      AssignmentExpr()
+      trivia
+    }
+    ReturnStmt(expression: "result")
+  }
+}
+
+func createTriviaAttachment(varName: String, triviaVarName: String, trivia: String) -> IfStmt {
+  IfStmt(
+    conditions: ExprList {
+      PrefixOperatorExpr(
+        operatorToken: .prefixOperator("!"),
+        postfixExpression: MemberAccessExpr(base: triviaVarName, name: "isEmpty")
+      )
+    }
+  ) {
+    SequenceExpr {
+      varName
+      AssignmentExpr()
+      FunctionCallExpr(MemberAccessExpr(base: varName, name: "with\(trivia.withFirstCharacterUppercased)")) {
+        TupleExprElement(expression: SequenceExpr {
+          triviaVarName
+          BinaryOperatorExpr("+")
+          TupleExpr {
+            SequenceExpr {
+              MemberAccessExpr(base: varName, name: trivia)
+              BinaryOperatorExpr("??")
+              ArrayExpr()
+            }
+          }
+        })
+      }
+    }
+  }
+}

Sources/generate-swift-syntax-builder/Templates/BuildableCollectionNodesFile.swift

@@ -20,6 +20,9 @@ let buildableCollectionNodesFile = SourceFile {
     path: "SwiftSyntax"
   )
 
+  let triviaSides = ["leading", "trailing"]
+  let trivias = triviaSides.map { "\($0)Trivia" }
+
   for node in SYNTAX_NODES where node.isSyntaxCollection {
     let type = node.type
     let elementType = node.collectionElementType
@@ -34,6 +37,16 @@ let buildableCollectionNodesFile = SourceFile {
       identifier: type.buildableBaseName,
       inheritanceClause: createTypeInheritanceClause(conformances: conformances)
     ) {
+      for (side, trivia) in zip(triviaSides, trivias) {
+        VariableDecl(
+          leadingTrivia: .docLineComment("/// The \(side) trivia attached to this syntax node once built.") + .newline,
+          .var,
+          name: trivia,
+          type: "Trivia",
+          initializer: ArrayExpr()
+        )
+      }
+
       VariableDecl(.let, name: "elements", type: ArrayType(elementType: elementType.buildable))
 
       // Generate initializers
@@ -42,10 +55,14 @@ let buildableCollectionNodesFile = SourceFile {
       createArrayLiteralInitializer(node: node)
 
       // Generate function declarations
-      createBuildFunction(node: node)
+      createBuildFunction(node: node, trivias: trivias)
       createBuildSyntaxFunction(node: node)
       createExpressibleAsCreateFunction(type: type)
       createDisambiguatingExpressibleAsCreateFunction(type: type, baseType: .init(syntaxKind: "Syntax"))
+
+      for trivia in trivias {
+        createWithTriviaFunction(trivia: trivia)
+      }
     }
 
     // For nodes without expressible-as conformances, conform Array to the corresponding expressible-as
@@ -170,7 +187,7 @@ private func createArrayLiteralInitializer(node: Node) -> InitializerDecl {
 }
 
 /// Generate the function building the collection syntax.
-private func createBuildFunction(node: Node) -> FunctionDecl {
+private func createBuildFunction(node: Node, trivias: [String]) -> FunctionDecl {
   let type = node.type
   let elementType = node.collectionElementType
   return FunctionDecl(
@@ -182,7 +199,7 @@ private func createBuildFunction(node: Node) -> FunctionDecl {
     )
   ) {
     VariableDecl(
-      .let,
+      .var,
       name: "result",
       initializer: FunctionCallExpr("\(type.syntaxBaseName)") {
         if elementType.isToken {
@@ -204,6 +221,9 @@ private func createBuildFunction(node: Node) -> FunctionDecl {
         }
       }
     )
+    for trivia in trivias {
+      createTriviaAttachment(varName: "result", triviaVarName: trivia, trivia: trivia)
+    }
     ReturnStmt(expression: FunctionCallExpr(MemberAccessExpr(base: "format", name: "_format")) {
       TupleExprElement(
         label: "syntax",

Sources/generate-swift-syntax-builder/Templates/BuildableNodesFile.swift

@@ -20,6 +20,9 @@ let buildableNodesFile = SourceFile {
     path: "SwiftSyntax"
   )
 
+  let triviaSides = ["leading", "trailing"]
+  let trivias = triviaSides.map { "\($0)Trivia" }
+
   for node in SYNTAX_NODES where node.isBuildable {
     let type = node.type
     let baseType = node.baseType
@@ -35,44 +38,46 @@ let buildableNodesFile = SourceFile {
       identifier: type.buildableBaseName,
       inheritanceClause: createTypeInheritanceClause(conformances: conformances)
     ) {
-      VariableDecl(
-        leadingTrivia: [
-          "/// The leading trivia attached to this syntax node once built.",
-          "/// This is typically used to add comments (e.g. for documentation).",
-        ].map { .docLineComment($0) + .newline }.reduce([], +),
-        .var,
-        name: "leadingTrivia",
-        type: "Trivia"
-      )
+      for (side, trivia) in zip(triviaSides, trivias) {
+        VariableDecl(
+          leadingTrivia: .docLineComment("/// The \(side) trivia attached to this syntax node once built.") + .newline,
+          .var,
+          name: trivia,
+          type: "Trivia"
+        )
+      }
 
       // Generate members
       for child in node.children {
         VariableDecl(.var, name: child.swiftName, type: child.type.buildable)
       }
 
       // Generate initializers
-      createDefaultInitializer(node: node)
+      createDefaultInitializer(node: node, trivias: trivias)
       if let convenienceInit = createConvenienceInitializer(node: node) {
         convenienceInit
       }
 
       // Generate function declarations
-      createBuildFunction(node: node)
+      createBuildFunction(node: node, trivias: trivias)
       createBuildBaseTypeFunction(node: node)
       createExpressibleAsCreateFunction(type: node.type)
       createDisambiguatingExpressibleAsCreateFunction(type: node.type, baseType: node.baseType)
       if baseType.baseName != "Syntax" {
         createDisambiguatingExpressibleAsCreateFunction(type: node.baseType, baseType: .init(syntaxKind: "Syntax"))
       }
       if hasTrailingComma {
-        createWithTrailingCommaFunction(node: node)
+        createWithTrailingCommaFunction()
+      }
+      for trivia in trivias {
+        createWithTriviaFunction(trivia: trivia)
       }
     }
   }
 }
 
 /// Create the default initializer for the given node.
-private func createDefaultInitializer(node: Node) -> InitializerDecl {
+private func createDefaultInitializer(node: Node, trivias: [String]) -> InitializerDecl {
   let type = node.type
   return InitializerDecl(
     leadingTrivia: ([
@@ -84,12 +89,14 @@ private func createDefaultInitializer(node: Node) -> InitializerDecl {
     modifiers: [Token.public],
     signature: FunctionSignature(
       input: ParameterClause {
-        FunctionParameter(
-          firstName: .identifier("leadingTrivia"),
-          colon: .colon,
-          type: "Trivia",
-          defaultArgument: ArrayExpr()
-        )
+        for trivia in trivias {
+          FunctionParameter(
+            firstName: .identifier(trivia),
+            colon: .colon,
+            type: "Trivia",
+            defaultArgument: ArrayExpr()
+          )
+        }
         for child in node.children {
           FunctionParameter(
             firstName: .identifier(child.swiftName),
@@ -101,10 +108,12 @@ private func createDefaultInitializer(node: Node) -> InitializerDecl {
       }
     )
   ) {
-    SequenceExpr {
-      MemberAccessExpr(base: "self", name: "leadingTrivia")
-      AssignmentExpr()
-      "leadingTrivia"
+    for trivia in trivias {
+      SequenceExpr {
+        MemberAccessExpr(base: "self", name: trivia)
+        AssignmentExpr()
+        trivia
+      }
     }
     for child in node.children {
       SequenceExpr {
@@ -226,7 +235,7 @@ private func createConvenienceInitializer(node: Node) -> InitializerDecl? {
 }
 
 /// Generate the function building the node syntax.
-private func createBuildFunction(node: Node) -> FunctionDecl {
+private func createBuildFunction(node: Node, trivias: [String]) -> FunctionDecl {
   let type = node.type
   let children = node.children
   return FunctionDecl(
@@ -254,31 +263,8 @@ private func createBuildFunction(node: Node) -> FunctionDecl {
         }
       }
     )
-    IfStmt(
-      conditions: ExprList {
-        PrefixOperatorExpr(
-          operatorToken: .prefixOperator("!"),
-          postfixExpression: MemberAccessExpr(base: "leadingTrivia", name: "isEmpty")
-        )
-      }
-    ) {
-      SequenceExpr {
-        "result"
-        AssignmentExpr()
-        FunctionCallExpr(MemberAccessExpr(base: "result", name: "withLeadingTrivia")) {
-          TupleExprElement(expression: SequenceExpr {
-            "leadingTrivia"
-            BinaryOperatorExpr("+")
-            TupleExpr {
-              SequenceExpr {
-                MemberAccessExpr(base: "result", name: "leadingTrivia")
-                BinaryOperatorExpr("??")
-                ArrayExpr()
-              }
-            }
-          })
-        }
-      }
+    for trivia in trivias {
+      createTriviaAttachment(varName: "result", triviaVarName: trivia, trivia: trivia)
     }
     ReturnStmt(expression: FunctionCallExpr(MemberAccessExpr(base: "format", name: "_format")) {
       TupleExprElement(
@@ -316,9 +302,8 @@ private func createBuildBaseTypeFunction(node: Node) -> FunctionDecl {
 }
 
 /// Generate the `withTrailingComma` function.
-private func createWithTrailingCommaFunction(node: Node) -> FunctionDecl {
-  let children = node.children
-  return FunctionDecl(
+private func createWithTrailingCommaFunction() -> FunctionDecl {
+  FunctionDecl(
     leadingTrivia: .docLineComment("/// Conformance to `HasTrailingComma`.") + .newline,
     modifiers: [Token.public],
     identifier: .identifier("withTrailingComma"),

Tests/SwiftSyntaxBuilderTest/TriviaTests.swift

@@ -32,4 +32,40 @@ final class TriviaTests: XCTestCase {
     XCTAssertEqual(y, x + .space)
     XCTAssertEqual(y, [.newlines(1), .spaces(1)])
   }
+
+  func testAttachedTrivia() {
+    let testCases: [UInt: (VariableDecl, String)] = [
+      #line: (
+        VariableDecl(.let, name: "x", type: "Int").withLeadingTrivia(.space),
+        " let x: Int"
+      ),
+      #line: (
+        VariableDecl(.let, name: "x", type: "Int").withTrailingTrivia(.space),
+        "let x: Int "
+      ),
+    ]
+    for (line, testCase) in testCases {
+      let (decl, expected) = testCase
+      let syntax = decl.buildSyntax(format: Format())
+      XCTAssertEqual(syntax.description, expected, line: line)
+    }
+  }
+
+  func testAttachedListTrivia() {
+    let testCases: [UInt: (AttributeList, String)] = [
+      #line: (
+        AttributeList([CustomAttribute("Test")]).withLeadingTrivia(.space),
+        " @Test"
+      ),
+      #line: (
+        AttributeList([CustomAttribute("A").withTrailingTrivia(.space), CustomAttribute("B")]).withTrailingTrivia(.space),
+        "@A @B "
+      ),
+    ]
+    for (line, testCase) in testCases {
+      let (decl, expected) = testCase
+      let syntax = decl.buildSyntax(format: Format())
+      XCTAssertEqual(syntax.description, expected, line: line)
+    }
+  }
 }