Merge pull request apple#235 from DougGregor/async-closures

[Concurrency] Add support for 'async' on closures.
maldahleh · Aug 12, 2020 · b6374bb · b6374bb
2 parents 27bc2a1 + e2b1c40
commit b6374bb
Show file tree

Hide file tree

Showing 5 changed files with 51 additions and 10 deletions.
diff --git a/Sources/SwiftSyntax/gyb_generated/Misc.swift b/Sources/SwiftSyntax/gyb_generated/Misc.swift
@@ -1944,6 +1944,6 @@ extension Syntax {
 extension SyntaxParser {
   static func verifyNodeDeclarationHash() -> Bool {
     return String(cString: swiftparse_syntax_structure_versioning_identifier()!) ==
-      "9700f84ac29d74406d59a6433d59aebb33227ade"
+      "71bf2d5d9308cb7092ce3660702fe668381dbbab"
   }
 }
diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxBuilders.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxBuilders.swift
@@ -1917,7 +1917,7 @@ extension ClosureParamSyntax {
 
 public struct ClosureSignatureSyntaxBuilder {
   private var layout =
-    Array<RawSyntax?>(repeating: nil, count: 5)
+    Array<RawSyntax?>(repeating: nil, count: 6)
 
   internal init() {}
 
@@ -1931,6 +1931,11 @@ public struct ClosureSignatureSyntaxBuilder {
     layout[idx] = node.raw
   }
 
+  public mutating func useAsyncKeyword(_ node: TokenSyntax) {
+    let idx = ClosureSignatureSyntax.Cursor.asyncKeyword.rawValue
+    layout[idx] = node.raw
+  }
+
   public mutating func useThrowsTok(_ node: TokenSyntax) {
     let idx = ClosureSignatureSyntax.Cursor.throwsTok.rawValue
     layout[idx] = node.raw
@@ -1947,8 +1952,8 @@ public struct ClosureSignatureSyntaxBuilder {
   }
 
   internal mutating func buildData() -> SyntaxData {
-    if (layout[4] == nil) {
-      layout[4] = RawSyntax.missingToken(TokenKind.inKeyword)
+    if (layout[5] == nil) {
+      layout[5] = RawSyntax.missingToken(TokenKind.inKeyword)
     }
 
     return .forRoot(RawSyntax.createAndCalcLength(kind: .closureSignature,

diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxClassification.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxClassification.swift
@@ -67,6 +67,8 @@ extension SyntaxClassification {
       switch (parentKind, indexInParent) {
       case (.arrowExpr, 0):
         return (.keyword, false)
+      case (.closureSignature, 2):
+        return (.keyword, false)
       case (.expressionSegment, 2):
         return (.stringInterpolationAnchor, true)
       case (.functionSignature, 1):

diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift
@@ -996,10 +996,11 @@ public enum SyntaxFactory {
     ], length: .zero, presence: .present))
     return ClosureParamListSyntax(data)
   }
-  public static func makeClosureSignature(capture: ClosureCaptureSignatureSyntax?, input: Syntax?, throwsTok: TokenSyntax?, output: ReturnClauseSyntax?, inTok: TokenSyntax) -> ClosureSignatureSyntax {
+  public static func makeClosureSignature(capture: ClosureCaptureSignatureSyntax?, input: Syntax?, asyncKeyword: TokenSyntax?, throwsTok: TokenSyntax?, output: ReturnClauseSyntax?, inTok: TokenSyntax) -> ClosureSignatureSyntax {
     let layout: [RawSyntax?] = [
       capture?.raw,
       input?.raw,
+      asyncKeyword?.raw,
       throwsTok?.raw,
       output?.raw,
       inTok.raw,
@@ -1017,6 +1018,7 @@ public enum SyntaxFactory {
       nil,
       nil,
       nil,
+      nil,
       RawSyntax.missingToken(TokenKind.inKeyword),
     ], length: .zero, presence: .present))
     return ClosureSignatureSyntax(data)

diff --git a/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxNodes.swift b/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxNodes.swift
@@ -1505,6 +1505,7 @@ public struct ClosureSignatureSyntax: SyntaxProtocol, SyntaxHashable {
   enum Cursor: Int {
     case capture
     case input
+    case asyncKeyword
     case throwsTok
     case output
     case inTok
@@ -1575,6 +1576,28 @@ public struct ClosureSignatureSyntax: SyntaxProtocol, SyntaxHashable {
     return ClosureSignatureSyntax(newData)
   }
 
+  public var asyncKeyword: TokenSyntax? {
+    get {
+      let childData = data.child(at: Cursor.asyncKeyword,
+                                 parent: Syntax(self))
+      if childData == nil { return nil }
+      return TokenSyntax(childData!)
+    }
+    set(value) {
+      self = withAsyncKeyword(value)
+    }
+  }
+
+  /// Returns a copy of the receiver with its `asyncKeyword` replaced.
+  /// - param newChild: The new `asyncKeyword` to replace the node's
+  ///                   current `asyncKeyword`, if present.
+  public func withAsyncKeyword(
+    _ newChild: TokenSyntax?) -> ClosureSignatureSyntax {
+    let raw = newChild?.raw
+    let newData = data.replacingChild(raw, at: Cursor.asyncKeyword)
+    return ClosureSignatureSyntax(newData)
+  }
+
   public var throwsTok: TokenSyntax? {
     get {
       let childData = data.child(at: Cursor.throwsTok,
@@ -1643,7 +1666,7 @@ public struct ClosureSignatureSyntax: SyntaxProtocol, SyntaxHashable {
 
   public func _validateLayout() {
     let rawChildren = Array(RawSyntaxChildren(Syntax(self)))
-    assert(rawChildren.count == 5)
+    assert(rawChildren.count == 6)
     // Check child #0 child is ClosureCaptureSignatureSyntax or missing
     if let raw = rawChildren[0].raw {
       let info = rawChildren[0].syntaxInfo
@@ -1668,21 +1691,29 @@ public struct ClosureSignatureSyntax: SyntaxProtocol, SyntaxHashable {
       let syntaxChild = Syntax(syntaxData)
       assert(syntaxChild.is(TokenSyntax.self))
     }
-    // Check child #3 child is ReturnClauseSyntax or missing
+    // Check child #3 child is TokenSyntax or missing
     if let raw = rawChildren[3].raw {
       let info = rawChildren[3].syntaxInfo
       let absoluteRaw = AbsoluteRawSyntax(raw: raw, info: info)
       let syntaxData = SyntaxData(absoluteRaw, parent: Syntax(self))
       let syntaxChild = Syntax(syntaxData)
-      assert(syntaxChild.is(ReturnClauseSyntax.self))
+      assert(syntaxChild.is(TokenSyntax.self))
     }
-    // Check child #4 child is TokenSyntax 
-    assert(rawChildren[4].raw != nil)
+    // Check child #4 child is ReturnClauseSyntax or missing
     if let raw = rawChildren[4].raw {
       let info = rawChildren[4].syntaxInfo
       let absoluteRaw = AbsoluteRawSyntax(raw: raw, info: info)
       let syntaxData = SyntaxData(absoluteRaw, parent: Syntax(self))
       let syntaxChild = Syntax(syntaxData)
+      assert(syntaxChild.is(ReturnClauseSyntax.self))
+    }
+    // Check child #5 child is TokenSyntax 
+    assert(rawChildren[5].raw != nil)
+    if let raw = rawChildren[5].raw {
+      let info = rawChildren[5].syntaxInfo
+      let absoluteRaw = AbsoluteRawSyntax(raw: raw, info: info)
+      let syntaxData = SyntaxData(absoluteRaw, parent: Syntax(self))
+      let syntaxChild = Syntax(syntaxData)
       assert(syntaxChild.is(TokenSyntax.self))
     }
   }
@@ -1693,6 +1724,7 @@ extension ClosureSignatureSyntax: CustomReflectable {
     return Mirror(self, children: [
       "capture": capture.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any,
       "input": input.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any,
+      "asyncKeyword": asyncKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any,
       "throwsTok": throwsTok.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any,
       "output": output.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any,
       "inTok": Syntax(inTok).asProtocol(SyntaxProtocol.self),