Update syntax to for-await-in syntax definitions

Sources/SwiftSyntax/gyb_generated/Misc.swift

@@ -1952,6 +1952,6 @@ extension Syntax {
 extension SyntaxParser {
   static func verifyNodeDeclarationHash() -> Bool {
     return String(cString: swiftparse_syntax_structure_versioning_identifier()!) ==
-      "0741fb1877365f4e66ca42dc7d84d31d7ccdd35a"
+      "87a7d7e3a5692f5e70906dbde9053e64d7651ab0"
   }
 }

Sources/SwiftSyntax/gyb_generated/SyntaxBuilders.swift

@@ -7252,7 +7252,7 @@ extension WhereClauseSyntax {
 
 public struct ForInStmtSyntaxBuilder {
   private var layout =
-    Array<RawSyntax?>(repeating: nil, count: 10)
+    Array<RawSyntax?>(repeating: nil, count: 12)
 
   internal init() {}
 
@@ -7271,6 +7271,16 @@ public struct ForInStmtSyntaxBuilder {
     layout[idx] = node.raw
   }
 
+  public mutating func useTryKeyword(_ node: TokenSyntax) {
+    let idx = ForInStmtSyntax.Cursor.tryKeyword.rawValue
+    layout[idx] = node.raw
+  }
+
+  public mutating func useAwaitKeyword(_ node: TokenSyntax) {
+    let idx = ForInStmtSyntax.Cursor.awaitKeyword.rawValue
+    layout[idx] = node.raw
+  }
+
   public mutating func useCaseKeyword(_ node: TokenSyntax) {
     let idx = ForInStmtSyntax.Cursor.caseKeyword.rawValue
     layout[idx] = node.raw
@@ -7310,17 +7320,17 @@ public struct ForInStmtSyntaxBuilder {
     if (layout[2] == nil) {
       layout[2] = RawSyntax.missingToken(TokenKind.forKeyword)
     }
-    if (layout[4] == nil) {
-      layout[4] = RawSyntax.missing(SyntaxKind.pattern)
-    }
     if (layout[6] == nil) {
-      layout[6] = RawSyntax.missingToken(TokenKind.inKeyword)
+      layout[6] = RawSyntax.missing(SyntaxKind.pattern)
     }
-    if (layout[7] == nil) {
-      layout[7] = RawSyntax.missing(SyntaxKind.expr)
+    if (layout[8] == nil) {
+      layout[8] = RawSyntax.missingToken(TokenKind.inKeyword)
     }
     if (layout[9] == nil) {
-      layout[9] = RawSyntax.missing(SyntaxKind.codeBlock)
+      layout[9] = RawSyntax.missing(SyntaxKind.expr)
+    }
+    if (layout[11] == nil) {
+      layout[11] = RawSyntax.missing(SyntaxKind.codeBlock)
     }
 
     return .forRoot(RawSyntax.createAndCalcLength(kind: .forInStmt,

Sources/SwiftSyntax/gyb_generated/SyntaxClassification.swift

@@ -87,6 +87,8 @@ extension SyntaxClassification {
         return (.keyword, false)
       case (.attribute, 1):
         return (.attribute, false)
+      case (.forInStmt, 4):
+        return (.keyword, false)
       case (.simpleTypeIdentifier, 0):
         return (.typeIdentifier, false)
       case (.memberTypeIdentifier, 2):

Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift

@@ -3304,11 +3304,13 @@ public enum SyntaxFactory {
     ], length: .zero, presence: .present))
     return WhereClauseSyntax(data)
   }
-  public static func makeForInStmt(labelName: TokenSyntax?, labelColon: TokenSyntax?, forKeyword: TokenSyntax, caseKeyword: TokenSyntax?, pattern: PatternSyntax, typeAnnotation: TypeAnnotationSyntax?, inKeyword: TokenSyntax, sequenceExpr: ExprSyntax, whereClause: WhereClauseSyntax?, body: CodeBlockSyntax) -> ForInStmtSyntax {
+  public static func makeForInStmt(labelName: TokenSyntax?, labelColon: TokenSyntax?, forKeyword: TokenSyntax, tryKeyword: TokenSyntax?, awaitKeyword: TokenSyntax?, caseKeyword: TokenSyntax?, pattern: PatternSyntax, typeAnnotation: TypeAnnotationSyntax?, inKeyword: TokenSyntax, sequenceExpr: ExprSyntax, whereClause: WhereClauseSyntax?, body: CodeBlockSyntax) -> ForInStmtSyntax {
     let layout: [RawSyntax?] = [
       labelName?.raw,
       labelColon?.raw,
       forKeyword.raw,
+      tryKeyword?.raw,
+      awaitKeyword?.raw,
       caseKeyword?.raw,
       pattern.raw,
       typeAnnotation?.raw,
@@ -3330,6 +3332,8 @@ public enum SyntaxFactory {
       nil,
       RawSyntax.missingToken(TokenKind.forKeyword),
       nil,
+      nil,
+      nil,
       RawSyntax.missing(SyntaxKind.pattern),
       nil,
       RawSyntax.missingToken(TokenKind.inKeyword),

Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxStmtNodes.swift

@@ -983,6 +983,8 @@ public struct ForInStmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
     case labelName
     case labelColon
     case forKeyword
+    case tryKeyword
+    case awaitKeyword
     case caseKeyword
     case pattern
     case typeAnnotation
@@ -1078,6 +1080,50 @@ public struct ForInStmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
     return ForInStmtSyntax(newData)
   }
 
+  public var tryKeyword: TokenSyntax? {
+    get {
+      let childData = data.child(at: Cursor.tryKeyword,
+                                 parent: Syntax(self))
+      if childData == nil { return nil }
+      return TokenSyntax(childData!)
+    }
+    set(value) {
+      self = withTryKeyword(value)
+    }
+  }
+
+  /// Returns a copy of the receiver with its `tryKeyword` replaced.
+  /// - param newChild: The new `tryKeyword` to replace the node's
+  ///                   current `tryKeyword`, if present.
+  public func withTryKeyword(
+    _ newChild: TokenSyntax?) -> ForInStmtSyntax {
+    let raw = newChild?.raw
+    let newData = data.replacingChild(raw, at: Cursor.tryKeyword)
+    return ForInStmtSyntax(newData)
+  }
+
+  public var awaitKeyword: TokenSyntax? {
+    get {
+      let childData = data.child(at: Cursor.awaitKeyword,
+                                 parent: Syntax(self))
+      if childData == nil { return nil }
+      return TokenSyntax(childData!)
+    }
+    set(value) {
+      self = withAwaitKeyword(value)
+    }
+  }
+
+  /// Returns a copy of the receiver with its `awaitKeyword` replaced.
+  /// - param newChild: The new `awaitKeyword` to replace the node's
+  ///                   current `awaitKeyword`, if present.
+  public func withAwaitKeyword(
+    _ newChild: TokenSyntax?) -> ForInStmtSyntax {
+    let raw = newChild?.raw
+    let newData = data.replacingChild(raw, at: Cursor.awaitKeyword)
+    return ForInStmtSyntax(newData)
+  }
+
   public var caseKeyword: TokenSyntax? {
     get {
       let childData = data.child(at: Cursor.caseKeyword,
@@ -1231,7 +1277,7 @@ public struct ForInStmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
 
   public func _validateLayout() {
     let rawChildren = Array(RawSyntaxChildren(Syntax(self)))
-    assert(rawChildren.count == 10)
+    assert(rawChildren.count == 12)
     // Check child #0 child is TokenSyntax or missing
     if let raw = rawChildren[0].raw {
       let info = rawChildren[0].syntaxInfo
@@ -1265,56 +1311,72 @@ public struct ForInStmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
       let syntaxChild = Syntax(syntaxData)
       assert(syntaxChild.is(TokenSyntax.self))
     }
-    // Check child #4 child is PatternSyntax 
-    assert(rawChildren[4].raw != nil)
+    // Check child #4 child is TokenSyntax 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(PatternSyntax.self))
+      assert(syntaxChild.is(TokenSyntax.self))
     }
-    // Check child #5 child is TypeAnnotationSyntax or missing
+    // Check child #5 child is TokenSyntax or missing
     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(TypeAnnotationSyntax.self))
+      assert(syntaxChild.is(TokenSyntax.self))
     }
-    // Check child #6 child is TokenSyntax 
+    // Check child #6 child is PatternSyntax 
     assert(rawChildren[6].raw != nil)
     if let raw = rawChildren[6].raw {
       let info = rawChildren[6].syntaxInfo
       let absoluteRaw = AbsoluteRawSyntax(raw: raw, info: info)
       let syntaxData = SyntaxData(absoluteRaw, parent: Syntax(self))
       let syntaxChild = Syntax(syntaxData)
-      assert(syntaxChild.is(TokenSyntax.self))
+      assert(syntaxChild.is(PatternSyntax.self))
     }
-    // Check child #7 child is ExprSyntax 
-    assert(rawChildren[7].raw != nil)
+    // Check child #7 child is TypeAnnotationSyntax or missing
     if let raw = rawChildren[7].raw {
       let info = rawChildren[7].syntaxInfo
       let absoluteRaw = AbsoluteRawSyntax(raw: raw, info: info)
       let syntaxData = SyntaxData(absoluteRaw, parent: Syntax(self))
       let syntaxChild = Syntax(syntaxData)
-      assert(syntaxChild.is(ExprSyntax.self))
+      assert(syntaxChild.is(TypeAnnotationSyntax.self))
     }
-    // Check child #8 child is WhereClauseSyntax or missing
+    // Check child #8 child is TokenSyntax 
+    assert(rawChildren[8].raw != nil)
     if let raw = rawChildren[8].raw {
       let info = rawChildren[8].syntaxInfo
       let absoluteRaw = AbsoluteRawSyntax(raw: raw, info: info)
       let syntaxData = SyntaxData(absoluteRaw, parent: Syntax(self))
       let syntaxChild = Syntax(syntaxData)
-      assert(syntaxChild.is(WhereClauseSyntax.self))
+      assert(syntaxChild.is(TokenSyntax.self))
     }
-    // Check child #9 child is CodeBlockSyntax 
+    // Check child #9 child is ExprSyntax 
     assert(rawChildren[9].raw != nil)
     if let raw = rawChildren[9].raw {
       let info = rawChildren[9].syntaxInfo
       let absoluteRaw = AbsoluteRawSyntax(raw: raw, info: info)
       let syntaxData = SyntaxData(absoluteRaw, parent: Syntax(self))
       let syntaxChild = Syntax(syntaxData)
+      assert(syntaxChild.is(ExprSyntax.self))
+    }
+    // Check child #10 child is WhereClauseSyntax or missing
+    if let raw = rawChildren[10].raw {
+      let info = rawChildren[10].syntaxInfo
+      let absoluteRaw = AbsoluteRawSyntax(raw: raw, info: info)
+      let syntaxData = SyntaxData(absoluteRaw, parent: Syntax(self))
+      let syntaxChild = Syntax(syntaxData)
+      assert(syntaxChild.is(WhereClauseSyntax.self))
+    }
+    // Check child #11 child is CodeBlockSyntax 
+    assert(rawChildren[11].raw != nil)
+    if let raw = rawChildren[11].raw {
+      let info = rawChildren[11].syntaxInfo
+      let absoluteRaw = AbsoluteRawSyntax(raw: raw, info: info)
+      let syntaxData = SyntaxData(absoluteRaw, parent: Syntax(self))
+      let syntaxChild = Syntax(syntaxData)
       assert(syntaxChild.is(CodeBlockSyntax.self))
     }
   }
@@ -1326,6 +1388,8 @@ extension ForInStmtSyntax: CustomReflectable {
       "labelName": labelName.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any,
       "labelColon": labelColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any,
       "forKeyword": Syntax(forKeyword).asProtocol(SyntaxProtocol.self),
+      "tryKeyword": tryKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any,
+      "awaitKeyword": awaitKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any,
       "caseKeyword": caseKeyword.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any,
       "pattern": Syntax(pattern).asProtocol(SyntaxProtocol.self),
       "typeAnnotation": typeAnnotation.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any,