Make garbage parameters in SyntaxFactory unlabeled

If the `garbage` parameters in the SyntaxFactory are labelled, it’s not possible to specify e.g. the second garbage node but leave the others to their default (swiftlang/swift#60274).

We could either give these `garbage` parameters distinct names or make them unlabeled to work around that issue. I chose to go for the unlabeled approach because it should be clear that these parameters contain garbage because of their type.

Author: ahoppen

Sources/SwiftSyntax/SyntaxFactory.swift.gyb

@@ -57,7 +57,9 @@ public enum SyntaxFactory {
 %          param_type = param_type + "?"
 %       end
 %       if child.is_garbage_nodes():
-%         child_params.append("garbage %s: %s = nil" % (child.swift_name, param_type))
+%         # It would be nice if we could label all of these arguments 'garbage'.
+%         # But if we do this, we hit https://github.com/apple/swift/issues/60274.
+%         child_params.append("_ %s: %s = nil" % (child.swift_name, param_type))
 %       else:
 %         child_params.append("%s: %s" % (child.swift_name, param_type))
 %       end

Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift

@@ -117,7 +117,15 @@ public struct ${type.buildable()}${conformance_clause(conformances)} {
   /// - Returns: The built `${type.syntax()}`.
   func build${type.base_name()}(format: Format, leadingTrivia additionalLeadingTrivia: Trivia? = nil) -> ${type.syntax()} {
     let result = SyntaxFactory.make${type.base_name()}(
-      ${',\n      '.join(['%s: %s' % (child.factory_parameter_name(), child.generate_expr_build_syntax_node(child.name(), 'format')) for child in children])}
+    % parameters = []
+    % for (index, child) in enumerate(children):
+    %   comma = ',' if index != len(children) - 1 else ''
+    %   if child.child.is_garbage_nodes():
+      ${child.generate_expr_build_syntax_node(child.name(), 'format')}${comma}
+    %   else:
+      ${child.name()}: ${child.generate_expr_build_syntax_node(child.name(), 'format')}${comma}
+    %   end
+    % end
     )
     let combinedLeadingTrivia = leadingTrivia + (additionalLeadingTrivia ?? []) + (result.leadingTrivia ?? [])
     return result.withLeadingTrivia(combinedLeadingTrivia.addingSpacingAfterNewlinesIfNeeded())

Sources/SwiftSyntaxBuilder/BuildableNodes.swift.gyb

@@ -61,7 +61,7 @@ public protocol ExpressibleAsSyntaxBuildable: ExpressibleAsGarbageNodes, Express
 }
 public extension ExpressibleAsSyntaxBuildable {
   /// Conformance to `ExpressibleAsGarbageNodes`
-func createGarbageNodes() -> GarbageNodes {
+  func createGarbageNodes() -> GarbageNodes {
     return GarbageNodes([self])
   }
   /// Conformance to `ExpressibleAsStringLiteralSegments`

Sources/SwiftSyntaxBuilder/generated/ExpressibleAsProtocols.swift

@@ -92,7 +92,7 @@ public struct GarbageNodes: ExpressibleByArrayLiteral, SyntaxBuildable, Expressi
       $0.buildSyntax(format: format, leadingTrivia: nil)
     })
     if let leadingTrivia = leadingTrivia {
-      return result.withLeadingTrivia(leadingTrivia + (result.leadingTrivia ?? []))
+      return result.withLeadingTrivia((leadingTrivia + (result.leadingTrivia ?? [])).addingSpacingAfterNewlinesIfNeeded())
     } else {
       return result
     }

Sources/SwiftSyntaxBuilder/gyb_generated/BuildableCollectionNodes.swift

@@ -19,12 +19,6 @@ def name(self):
     return self.child.swift_name
 
 
-  def factory_parameter_name(self):
-    if self.child.is_garbage_nodes():
-      return 'garbage'
-    else:
-      return self.name()
-
   def type(self):
     """
     The type of this child, represented by a `SyntaxBuildableType`, which can be used to create the corresponding `Buildable` and `ExpressibleAs` types.

Sources/SwiftSyntaxBuilder/gyb_generated/BuildableNodes.swift

@@ -27,16 +27,16 @@ public class VisitorTests: XCTestCase {
   public func testVisitGarbage() throws {
     // This is just bunch of garbage
     let garbageReturnStmt = SyntaxFactory.makeReturnStmt(
-      garbage: SyntaxFactory.makeGarbageNodes([Syntax(SyntaxFactory.makeToken(.identifier("starting"), presence: .present)), Syntax(SyntaxFactory.makeToken(.identifier("garbage"), presence: .present))]),
+      SyntaxFactory.makeGarbageNodes([Syntax(SyntaxFactory.makeToken(.identifier("starting"), presence: .present)), Syntax(SyntaxFactory.makeToken(.identifier("garbage"), presence: .present))]),
       returnKeyword: SyntaxFactory.makeReturnKeyword(trailingTrivia: [.spaces(1)]),
-      garbage: SyntaxFactory.makeGarbageNodes([Syntax(SyntaxFactory.makeToken(.identifier("middle"), presence: .present))]),
-      expression: ExprSyntax(SyntaxFactory.makeNilLiteralExpr(garbage: SyntaxFactory.makeGarbageNodes([Syntax(SyntaxFactory.makeToken(.identifier("end"), presence: .present))]), nilKeyword: SyntaxFactory.makeToken(.nilKeyword, presence: .present)))
+      SyntaxFactory.makeGarbageNodes([Syntax(SyntaxFactory.makeToken(.identifier("middle"), presence: .present))]),
+      expression: ExprSyntax(SyntaxFactory.makeNilLiteralExpr(SyntaxFactory.makeGarbageNodes([Syntax(SyntaxFactory.makeToken(.identifier("end"), presence: .present))]), nilKeyword: SyntaxFactory.makeToken(.nilKeyword, presence: .present)))
     )
 
     // This is more real-world where the user wrote null instead of nil.
     let misspelledNil = SyntaxFactory.makeReturnStmt(
       returnKeyword: SyntaxFactory.makeReturnKeyword(trailingTrivia: [.spaces(1)]),
-      expression: ExprSyntax(SyntaxFactory.makeNilLiteralExpr(garbage: SyntaxFactory.makeGarbageNodes([Syntax(SyntaxFactory.makeToken(.identifier("null"), presence: .present))]), nilKeyword: SyntaxFactory.makeToken(.nilKeyword, presence: .missing)))
+      expression: ExprSyntax(SyntaxFactory.makeNilLiteralExpr(SyntaxFactory.makeGarbageNodes([Syntax(SyntaxFactory.makeToken(.identifier("null"), presence: .present))]), nilKeyword: SyntaxFactory.makeToken(.nilKeyword, presence: .missing)))
     )
 
     // Test SyntaxVisitor