Merge pull request #216 from rintaro/unbraced-multiple-trailing-closures

[SE-0279] Update for braceless multiple trailing closure syntax

Author: rjmccall

Sources/SwiftSyntax/gyb_generated/Misc.swift

@@ -357,6 +357,18 @@ extension SyntaxNode {
     return UnresolvedPatternExprSyntax(asSyntaxData)
   }
 
+  public var isMultipleTrailingClosureElement: Bool { return raw.kind == .multipleTrailingClosureElement }
+  public var asMultipleTrailingClosureElement: MultipleTrailingClosureElementSyntax? {
+    guard isMultipleTrailingClosureElement else { return nil }
+    return MultipleTrailingClosureElementSyntax(asSyntaxData)
+  }
+
+  public var isMultipleTrailingClosureElementList: Bool { return raw.kind == .multipleTrailingClosureElementList }
+  public var asMultipleTrailingClosureElementList: MultipleTrailingClosureElementListSyntax? {
+    guard isMultipleTrailingClosureElementList else { return nil }
+    return MultipleTrailingClosureElementListSyntax(asSyntaxData)
+  }
+
   public var isFunctionCallExpr: Bool { return raw.kind == .functionCallExpr }
   public var asFunctionCallExpr: FunctionCallExprSyntax? {
     guard isFunctionCallExpr else { return nil }
@@ -1553,6 +1565,10 @@ extension Syntax {
       return node
     case .unresolvedPatternExpr(let node):
       return node
+    case .multipleTrailingClosureElement(let node):
+      return node
+    case .multipleTrailingClosureElementList(let node):
+      return node
     case .functionCallExpr(let node):
       return node
     case .subscriptExpr(let node):
@@ -1912,6 +1928,6 @@ extension Syntax {
 extension SyntaxParser {
   static func verifyNodeDeclarationHash() -> Bool {
     return String(cString: swiftparse_syntax_structure_versioning_identifier()!) ==
-      "3634919159735844058"
+      "3723395330444835342"
   }
 }

Sources/SwiftSyntax/gyb_generated/SyntaxAnyVisitor.swift

@@ -456,6 +456,20 @@ open class SyntaxAnyVisitor: SyntaxVisitor {
   override open func visitPost(_ node: UnresolvedPatternExprSyntax) {
     visitAnyPost(node._syntaxNode)
   }
+  override open func visit(_ node: MultipleTrailingClosureElementSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+
+  override open func visitPost(_ node: MultipleTrailingClosureElementSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
+  override open func visit(_ node: MultipleTrailingClosureElementListSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+
+  override open func visitPost(_ node: MultipleTrailingClosureElementListSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
   override open func visit(_ node: FunctionCallExprSyntax) -> SyntaxVisitorContinueKind {
     return visitAny(node._syntaxNode)
   }

Sources/SwiftSyntax/gyb_generated/SyntaxBuilders.swift

@@ -1987,9 +1987,63 @@ extension UnresolvedPatternExprSyntax {
   }
 }
 
+public struct MultipleTrailingClosureElementSyntaxBuilder {
+  private var layout =
+    Array<RawSyntax?>(repeating: nil, count: 3)
+
+  internal init() {}
+
+  public mutating func useLabel(_ node: TokenSyntax) {
+    let idx = MultipleTrailingClosureElementSyntax.Cursor.label.rawValue
+    layout[idx] = node.raw
+  }
+
+  public mutating func useColon(_ node: TokenSyntax) {
+    let idx = MultipleTrailingClosureElementSyntax.Cursor.colon.rawValue
+    layout[idx] = node.raw
+  }
+
+  public mutating func useClosure(_ node: ClosureExprSyntax) {
+    let idx = MultipleTrailingClosureElementSyntax.Cursor.closure.rawValue
+    layout[idx] = node.raw
+  }
+
+  internal mutating func buildData() -> SyntaxData {
+    if (layout[0] == nil) {
+      layout[0] = RawSyntax.missingToken(TokenKind.identifier(""))
+    }
+    if (layout[1] == nil) {
+      layout[1] = RawSyntax.missingToken(TokenKind.colon)
+    }
+    if (layout[2] == nil) {
+      layout[2] = RawSyntax.missing(SyntaxKind.closureExpr)
+    }
+
+    return .forRoot(RawSyntax.createAndCalcLength(kind: .multipleTrailingClosureElement,
+      layout: layout, presence: .present))
+  }
+}
+
+extension MultipleTrailingClosureElementSyntax {
+  /// Creates a `MultipleTrailingClosureElementSyntax` using the provided build function.
+  /// - Parameter:
+  ///   - build: A closure that wil be invoked in order to initialize
+  ///            the fields of the syntax node.
+  ///            This closure is passed a `MultipleTrailingClosureElementSyntaxBuilder` which you can use to
+  ///            incrementally build the structure of the node.
+  /// - Returns: A `MultipleTrailingClosureElementSyntax` with all the fields populated in the builder
+  ///            closure.
+  public init(_ build: (inout MultipleTrailingClosureElementSyntaxBuilder) -> Void) {
+    var builder = MultipleTrailingClosureElementSyntaxBuilder()
+    build(&builder)
+    let data = builder.buildData()
+    self.init(data)
+  }
+}
+
 public struct FunctionCallExprSyntaxBuilder {
   private var layout =
-    Array<RawSyntax?>(repeating: nil, count: 5)
+    Array<RawSyntax?>(repeating: nil, count: 6)
 
   internal init() {}
 
@@ -2024,6 +2078,17 @@ public struct FunctionCallExprSyntaxBuilder {
     layout[idx] = node.raw
   }
 
+  public mutating func addAdditionalTralingClosure(_ elt: MultipleTrailingClosureElementSyntax) {
+    let idx = FunctionCallExprSyntax.Cursor.additionalTrailingClosures.rawValue
+    if let list = layout[idx] {
+      layout[idx] = list.appending(elt.raw)
+    } else {
+      layout[idx] = RawSyntax.create(kind: SyntaxKind.multipleTrailingClosureElementList,
+        layout: [elt.raw], length: elt.raw.totalLength,
+        presence: SourcePresence.present)
+    }
+  }
+
   internal mutating func buildData() -> SyntaxData {
     if (layout[0] == nil) {
       layout[0] = RawSyntax.missing(SyntaxKind.expr)
@@ -2056,7 +2121,7 @@ extension FunctionCallExprSyntax {
 
 public struct SubscriptExprSyntaxBuilder {
   private var layout =
-    Array<RawSyntax?>(repeating: nil, count: 5)
+    Array<RawSyntax?>(repeating: nil, count: 6)
 
   internal init() {}
 
@@ -2091,6 +2156,17 @@ public struct SubscriptExprSyntaxBuilder {
     layout[idx] = node.raw
   }
 
+  public mutating func addAdditionalTralingClosure(_ elt: MultipleTrailingClosureElementSyntax) {
+    let idx = SubscriptExprSyntax.Cursor.additionalTrailingClosures.rawValue
+    if let list = layout[idx] {
+      layout[idx] = list.appending(elt.raw)
+    } else {
+      layout[idx] = RawSyntax.create(kind: SyntaxKind.multipleTrailingClosureElementList,
+        layout: [elt.raw], length: elt.raw.totalLength,
+        presence: SourcePresence.present)
+    }
+  }
+
   internal mutating func buildData() -> SyntaxData {
     if (layout[0] == nil) {
       layout[0] = RawSyntax.missing(SyntaxKind.expr)