[Concurrency] Add syntax for the await expression.

Sources/SwiftSyntax/gyb_generated/Misc.swift

@@ -111,6 +111,12 @@ extension SyntaxNode {
     return TryExprSyntax(asSyntaxData)
   }
 
+  public var isAwaitExpr: Bool { return raw.kind == .awaitExpr }
+  public var asAwaitExpr: AwaitExprSyntax? {
+    guard isAwaitExpr else { return nil }
+    return AwaitExprSyntax(asSyntaxData)
+  }
+
   public var isDeclNameArgument: Bool { return raw.kind == .declNameArgument }
   public var asDeclNameArgument: DeclNameArgumentSyntax? {
     guard isDeclNameArgument else { return nil }
@@ -1489,6 +1495,8 @@ extension Syntax {
       return node
     case .tryExpr(let node):
       return node
+    case .awaitExpr(let node):
+      return node
     case .declNameArgument(let node):
       return node
     case .declNameArgumentList(let node):
@@ -1936,6 +1944,6 @@ extension Syntax {
 extension SyntaxParser {
   static func verifyNodeDeclarationHash() -> Bool {
     return String(cString: swiftparse_syntax_structure_versioning_identifier()!) ==
-      "3a049b2faed8cf5c7c125ffe4354a6e8b5d9620f"
+      "fd719aaf2e0dab2620af2d4d123d123b3d0de28d"
   }
 }

Sources/SwiftSyntax/gyb_generated/SyntaxAnyVisitor.swift

@@ -169,6 +169,13 @@ open class SyntaxAnyVisitor: SyntaxVisitor {
   override open func visitPost(_ node: TryExprSyntax) {
     visitAnyPost(node._syntaxNode)
   }
+  override open func visit(_ node: AwaitExprSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+
+  override open func visitPost(_ node: AwaitExprSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
   override open func visit(_ node: DeclNameArgumentSyntax) -> SyntaxVisitorContinueKind {
     return visitAny(node._syntaxNode)
   }

Sources/SwiftSyntax/gyb_generated/SyntaxBaseNodes.swift

@@ -164,7 +164,7 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   /// `nil` if the conversion is not possible.
   public init?(_ syntax: Syntax) {
     switch syntax.raw.kind {
-    case .unknownExpr, .inOutExpr, .poundColumnExpr, .tryExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .sequenceExpr, .poundLineExpr, .poundFileExpr, .poundFileIDExpr, .poundFilePathExpr, .poundFunctionExpr, .poundDsohandleExpr, .symbolicReferenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .ternaryExpr, .memberAccessExpr, .isExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .keyPathExpr, .keyPathBaseExpr, .objcKeyPathExpr, .objcSelectorExpr, .editorPlaceholderExpr, .objectLiteralExpr:
+    case .unknownExpr, .inOutExpr, .poundColumnExpr, .tryExpr, .awaitExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .sequenceExpr, .poundLineExpr, .poundFileExpr, .poundFileIDExpr, .poundFilePathExpr, .poundFunctionExpr, .poundDsohandleExpr, .symbolicReferenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .ternaryExpr, .memberAccessExpr, .isExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .keyPathExpr, .keyPathBaseExpr, .objcKeyPathExpr, .objcSelectorExpr, .editorPlaceholderExpr, .objectLiteralExpr:
       self._syntaxNode = syntax
     default:
       return nil
@@ -178,7 +178,7 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     // Assert that the kind of the given data matches in debug builds.
 #if DEBUG
     switch data.raw.kind {
-    case .unknownExpr, .inOutExpr, .poundColumnExpr, .tryExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .sequenceExpr, .poundLineExpr, .poundFileExpr, .poundFileIDExpr, .poundFilePathExpr, .poundFunctionExpr, .poundDsohandleExpr, .symbolicReferenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .ternaryExpr, .memberAccessExpr, .isExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .keyPathExpr, .keyPathBaseExpr, .objcKeyPathExpr, .objcSelectorExpr, .editorPlaceholderExpr, .objectLiteralExpr:
+    case .unknownExpr, .inOutExpr, .poundColumnExpr, .tryExpr, .awaitExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .sequenceExpr, .poundLineExpr, .poundFileExpr, .poundFileIDExpr, .poundFilePathExpr, .poundFunctionExpr, .poundDsohandleExpr, .symbolicReferenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .ternaryExpr, .memberAccessExpr, .isExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .keyPathExpr, .keyPathBaseExpr, .objcKeyPathExpr, .objcSelectorExpr, .editorPlaceholderExpr, .objectLiteralExpr:
       break
     default:
       fatalError("Unable to create ExprSyntax from \(data.raw.kind)")

Sources/SwiftSyntax/gyb_generated/SyntaxBuilders.swift

@@ -256,6 +256,52 @@ extension TryExprSyntax {
   }
 }
 
+public struct AwaitExprSyntaxBuilder {
+  private var layout =
+    Array<RawSyntax?>(repeating: nil, count: 2)
+
+  internal init() {}
+
+  public mutating func useAwaitKeyword(_ node: TokenSyntax) {
+    let idx = AwaitExprSyntax.Cursor.awaitKeyword.rawValue
+    layout[idx] = node.raw
+  }
+
+  public mutating func useExpression(_ node: ExprSyntax) {
+    let idx = AwaitExprSyntax.Cursor.expression.rawValue
+    layout[idx] = node.raw
+  }
+
+  internal mutating func buildData() -> SyntaxData {
+    if (layout[0] == nil) {
+      layout[0] = RawSyntax.missingToken(TokenKind.awaitKeyword)
+    }
+    if (layout[1] == nil) {
+      layout[1] = RawSyntax.missing(SyntaxKind.expr)
+    }
+
+    return .forRoot(RawSyntax.createAndCalcLength(kind: .awaitExpr,
+      layout: layout, presence: .present))
+  }
+}
+
+extension AwaitExprSyntax {
+  /// Creates a `AwaitExprSyntax` 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 `AwaitExprSyntaxBuilder` which you can use to
+  ///            incrementally build the structure of the node.
+  /// - Returns: A `AwaitExprSyntax` with all the fields populated in the builder
+  ///            closure.
+  public init(_ build: (inout AwaitExprSyntaxBuilder) -> Void) {
+    var builder = AwaitExprSyntaxBuilder()
+    build(&builder)
+    let data = builder.buildData()
+    self.init(data)
+  }
+}
+
 public struct DeclNameArgumentSyntaxBuilder {
   private var layout =
     Array<RawSyntax?>(repeating: nil, count: 2)

Sources/SwiftSyntax/gyb_generated/SyntaxClassification.swift

@@ -212,6 +212,8 @@ extension RawTokenKind {
       return .keyword
     case .throwsKeyword:
       return .keyword
+    case .awaitKeyword:
+      return .keyword
     case .__file__Keyword:
       return .keyword
     case .__line__Keyword:

Sources/SwiftSyntax/gyb_generated/SyntaxEnum.swift

@@ -36,6 +36,7 @@ public enum SyntaxEnum {
   case dictionaryElementList(DictionaryElementListSyntax)
   case stringLiteralSegments(StringLiteralSegmentsSyntax)
   case tryExpr(TryExprSyntax)
+  case awaitExpr(AwaitExprSyntax)
   case declNameArgument(DeclNameArgumentSyntax)
   case declNameArgumentList(DeclNameArgumentListSyntax)
   case declNameArguments(DeclNameArgumentsSyntax)
@@ -306,6 +307,8 @@ public extension Syntax {
       return .stringLiteralSegments(StringLiteralSegmentsSyntax(self)!)
     case .tryExpr:
       return .tryExpr(TryExprSyntax(self)!)
+    case .awaitExpr:
+      return .awaitExpr(AwaitExprSyntax(self)!)
     case .declNameArgument:
       return .declNameArgument(DeclNameArgumentSyntax(self)!)
     case .declNameArgumentList:

Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift

@@ -250,6 +250,25 @@ public enum SyntaxFactory {
     ], length: .zero, presence: .present))
     return TryExprSyntax(data)
   }
+  public static func makeAwaitExpr(awaitKeyword: TokenSyntax, expression: ExprSyntax) -> AwaitExprSyntax {
+    let layout: [RawSyntax?] = [
+      awaitKeyword.raw,
+      expression.raw,
+    ]
+    let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.awaitExpr,
+      layout: layout, presence: SourcePresence.present)
+    let data = SyntaxData.forRoot(raw)
+    return AwaitExprSyntax(data)
+  }
+
+  public static func makeBlankAwaitExpr() -> AwaitExprSyntax {
+    let data = SyntaxData.forRoot(RawSyntax.create(kind: .awaitExpr,
+      layout: [
+      RawSyntax.missingToken(TokenKind.awaitKeyword),
+      RawSyntax.missing(SyntaxKind.expr),
+    ], length: .zero, presence: .present))
+    return AwaitExprSyntax(data)
+  }
   public static func makeDeclNameArgument(name: TokenSyntax, colon: TokenSyntax) -> DeclNameArgumentSyntax {
     let layout: [RawSyntax?] = [
       name.raw,
@@ -5045,6 +5064,12 @@ public enum SyntaxFactory {
                      leadingTrivia: leadingTrivia,
                      trailingTrivia: trailingTrivia)
   }
+  public static func makeAwaitKeyword(leadingTrivia: Trivia = [],
+    trailingTrivia: Trivia = []) -> TokenSyntax {
+    return makeToken(.awaitKeyword, presence: .present,
+                     leadingTrivia: leadingTrivia,
+                     trailingTrivia: trailingTrivia)
+  }
   public static func make__FILE__Keyword(leadingTrivia: Trivia = [],
     trailingTrivia: Trivia = []) -> TokenSyntax {
     return makeToken(.__file__Keyword, presence: .present,

Sources/SwiftSyntax/gyb_generated/SyntaxKind.swift

@@ -36,6 +36,7 @@ internal enum SyntaxKind: CSyntaxKind {
   case dictionaryElementList = 167
   case stringLiteralSegments = 168
   case tryExpr = 27
+  case awaitExpr = 249
   case declNameArgument = 94
   case declNameArgumentList = 169
   case declNameArguments = 95

Sources/SwiftSyntax/gyb_generated/SyntaxRewriter.swift

@@ -128,6 +128,13 @@ open class SyntaxRewriter {
     return ExprSyntax(visitChildren(node))
   }
 
+  /// Visit a `AwaitExprSyntax`.
+  ///   - Parameter node: the node that is being visited
+  ///   - Returns: the rewritten node
+  open func visit(_ node: AwaitExprSyntax) -> ExprSyntax {
+    return ExprSyntax(visitChildren(node))
+  }
+
   /// Visit a `DeclNameArgumentSyntax`.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
@@ -1909,6 +1916,16 @@ open class SyntaxRewriter {
       return Syntax(visit(node))
   }
 
+  /// Implementation detail of visit(_:). Do not call directly.
+  private func visitImplAwaitExprSyntax(_ data: SyntaxData) -> Syntax {
+      let node = AwaitExprSyntax(data)
+      // Accessing _syntaxNode directly is faster than calling Syntax(node)
+      visitPre(node._syntaxNode)
+      defer { visitPost(node._syntaxNode) }
+      if let newNode = visitAny(node._syntaxNode) { return newNode }
+      return Syntax(visit(node))
+  }
+
   /// Implementation detail of visit(_:). Do not call directly.
   private func visitImplDeclNameArgumentSyntax(_ data: SyntaxData) -> Syntax {
       let node = DeclNameArgumentSyntax(data)
@@ -4201,6 +4218,8 @@ open class SyntaxRewriter {
       return visitImplStringLiteralSegmentsSyntax
     case .tryExpr:
       return visitImplTryExprSyntax
+    case .awaitExpr:
+      return visitImplAwaitExprSyntax
     case .declNameArgument:
       return visitImplDeclNameArgumentSyntax
     case .declNameArgumentList:
@@ -4696,6 +4715,8 @@ open class SyntaxRewriter {
       return visitImplStringLiteralSegmentsSyntax(data)
     case .tryExpr:
       return visitImplTryExprSyntax(data)
+    case .awaitExpr:
+      return visitImplAwaitExprSyntax(data)
     case .declNameArgument:
       return visitImplDeclNameArgumentSyntax(data)
     case .declNameArgumentList:

Sources/SwiftSyntax/gyb_generated/SyntaxVisitor.swift

@@ -182,6 +182,16 @@ open class SyntaxVisitor {
   /// The function called after visiting `TryExprSyntax` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: TryExprSyntax) {}
+  /// Visiting `AwaitExprSyntax` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: how should we continue visiting.
+  open func visit(_ node: AwaitExprSyntax) -> SyntaxVisitorContinueKind {
+    return .visitChildren
+  }
+
+  /// The function called after visiting `AwaitExprSyntax` and its descendents.
+  ///   - node: the node we just finished visiting.
+  open func visitPost(_ node: AwaitExprSyntax) {}
   /// Visiting `DeclNameArgumentSyntax` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
@@ -2625,6 +2635,17 @@ open class SyntaxVisitor {
       visitPost(node)
   }
 
+  /// Implementation detail of doVisit(_:_:). Do not call directly.
+  private func visitImplAwaitExprSyntax(_ data: SyntaxData) {
+      let node = AwaitExprSyntax(data)
+      let needsChildren = (visit(node) == .visitChildren)
+      // Avoid calling into visitChildren if possible.
+      if needsChildren && node.raw.numberOfChildren > 0 {
+        visitChildren(node)
+      }
+      visitPost(node)
+  }
+
   /// Implementation detail of doVisit(_:_:). Do not call directly.
   private func visitImplDeclNameArgumentSyntax(_ data: SyntaxData) {
       let node = DeclNameArgumentSyntax(data)
@@ -5105,6 +5126,8 @@ open class SyntaxVisitor {
       visitImplStringLiteralSegmentsSyntax(data)
     case .tryExpr:
       visitImplTryExprSyntax(data)
+    case .awaitExpr:
+      visitImplAwaitExprSyntax(data)
     case .declNameArgument:
       visitImplDeclNameArgumentSyntax(data)
     case .declNameArgumentList:

Sources/SwiftSyntax/gyb_generated/TokenKind.swift

@@ -68,6 +68,7 @@ public enum TokenKind {
   case trueKeyword
   case tryKeyword
   case throwsKeyword
+  case awaitKeyword
   case __file__Keyword
   case __line__Keyword
   case __column__Keyword
@@ -195,6 +196,7 @@ public enum TokenKind {
     case .trueKeyword: return "true"
     case .tryKeyword: return "try"
     case .throwsKeyword: return "throws"
+    case .awaitKeyword: return "__await"
     case .__file__Keyword: return "__FILE__"
     case .__line__Keyword: return "__LINE__"
     case .__column__Keyword: return "__COLUMN__"
@@ -323,6 +325,7 @@ public enum TokenKind {
     case .trueKeyword: return true
     case .tryKeyword: return true
     case .throwsKeyword: return true
+    case .awaitKeyword: return true
     case .__file__Keyword: return true
     case .__line__Keyword: return true
     case .__column__Keyword: return true
@@ -451,6 +454,7 @@ public enum TokenKind {
     case .trueKeyword: return "kw_true"
     case .tryKeyword: return "kw_try"
     case .throwsKeyword: return "kw_throws"
+    case .awaitKeyword: return "kw___await"
     case .__file__Keyword: return "kw___FILE__"
     case .__line__Keyword: return "kw___LINE__"
     case .__column__Keyword: return "kw___COLUMN__"
@@ -579,6 +583,7 @@ public enum TokenKind {
     case .trueKeyword: return SourceLength(utf8Length: 4)
     case .tryKeyword: return SourceLength(utf8Length: 3)
     case .throwsKeyword: return SourceLength(utf8Length: 6)
+    case .awaitKeyword: return SourceLength(utf8Length: 7)
     case .__file__Keyword: return SourceLength(utf8Length: 8)
     case .__line__Keyword: return SourceLength(utf8Length: 8)
     case .__column__Keyword: return SourceLength(utf8Length: 10)
@@ -709,6 +714,7 @@ extension TokenKind: Equatable {
     case (.trueKeyword, .trueKeyword): return true
     case (.tryKeyword, .tryKeyword): return true
     case (.throwsKeyword, .throwsKeyword): return true
+    case (.awaitKeyword, .awaitKeyword): return true
     case (.__file__Keyword, .__file__Keyword): return true
     case (.__line__Keyword, .__line__Keyword): return true
     case (.__column__Keyword, .__column__Keyword): return true
@@ -907,6 +913,8 @@ extension TokenKind {
       return .tryKeyword
     case 53:
       return .throwsKeyword
+    case 123:
+      return .awaitKeyword
     case 54:
       return .__file__Keyword
     case 55:
@@ -1167,6 +1175,8 @@ extension TokenKind {
       return false
     case 53:
       return false
+    case 123:
+      return false
     case 54:
       return false
     case 55:
@@ -1367,6 +1377,7 @@ internal enum RawTokenKind: CTokenKind {
   case trueKeyword = 51
   case tryKeyword = 52
   case throwsKeyword = 53
+  case awaitKeyword = 123
   case __file__Keyword = 54
   case __line__Keyword = 55
   case __column__Keyword = 56
@@ -1608,6 +1619,9 @@ extension TokenKind {
     case .throwsKeyword:
       let length = 6
       return body(.init(kind: .throwsKeyword, length: length))
+    case .awaitKeyword:
+      let length = 7
+      return body(.init(kind: .awaitKeyword, length: length))
     case .__file__Keyword:
       let length = 8
       return body(.init(kind: .__file__Keyword, length: length))