[Variadic Generics] Parse contextual each in expression context as PackElementExprSyntax.

CodeGeneration/Sources/SyntaxSupport/gyb_generated/ExprNodes.swift

@@ -213,6 +213,22 @@ public let EXPR_NODES: [Node] = [
                ])
        ]),
 
+  Node(name: "PackElementExpr",
+       nameForDiagnostics: nil,
+       kind: "Expr",
+       children: [
+         Child(name: "EachKeyword",
+               kind: "ContextualKeywordToken",
+               tokenChoices: [
+                 "ContextualKeyword"
+               ],
+               textChoices: [
+                 "each"
+               ]),
+         Child(name: "PackRefExpr",
+               kind: "Expr")
+       ]),
+
   Node(name: "SequenceExpr",
        nameForDiagnostics: nil,
        kind: "Expr",

Sources/SwiftParser/Expressions.swift

@@ -1020,13 +1020,20 @@ extension Parser {
         return RawExprSyntax(RawUnresolvedPatternExprSyntax(pattern: pattern, arena: self.arena))
       }
 
-      // 'any' followed by another identifier is an existential type.
-      if self.atContextualKeyword("any"),
-         self.peek().tokenKind == .identifier,
-         !self.peek().isAtStartOfLine
-      {
-        let ty = self.parseType()
-        return RawExprSyntax(RawTypeExprSyntax(type: ty, arena: self.arena))
+      // We might have a contextual keyword followed by an identifier.
+      // 'each <identifier>' is a pack element expr, and 'any <identifier>'
+      // is an existential type expr.
+      if self.peek().tokenKind == .identifier, !self.peek().isAtStartOfLine {
+        if self.atContextualKeyword("any") {
+          let ty = self.parseType()
+          return RawExprSyntax(RawTypeExprSyntax(type: ty, arena: self.arena))
+        }
+
+        if let each = self.consumeIfContextualKeyword("each") {
+          let packRef = self.parseExpression()
+          return RawExprSyntax(RawPackElementExprSyntax(
+            eachKeyword: each, packRefExpr: packRef, arena: self.arena))
+        }
       }
 
       return RawExprSyntax(self.parseIdentifierExpression())

Sources/SwiftSyntax/Documentation.docc/gyb_generated/SwiftSyntax.md

@@ -112,6 +112,7 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code.
 - <doc:SwiftSyntax/NilLiteralExprSyntax>
 - <doc:SwiftSyntax/DiscardAssignmentExprSyntax>
 - <doc:SwiftSyntax/AssignmentExprSyntax>
+- <doc:SwiftSyntax/PackElementExprSyntax>
 - <doc:SwiftSyntax/SequenceExprSyntax>
 - <doc:SwiftSyntax/SymbolicReferenceExprSyntax>
 - <doc:SwiftSyntax/PrefixOperatorExprSyntax>

Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxNodes.swift

@@ -65,7 +65,7 @@ public struct RawExprSyntax: RawExprSyntaxNodeProtocol {
 
   public static func isKindOf(_ raw: RawSyntax) -> Bool {
     switch raw.kind {
-    case .missingExpr, .inOutExpr, .poundColumnExpr, .tryExpr, .awaitExpr, .moveExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .sequenceExpr, .symbolicReferenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .infixOperatorExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .unresolvedTernaryExpr, .ternaryExpr, .memberAccessExpr, .unresolvedIsExpr, .isExpr, .unresolvedAsExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .regexLiteralExpr, .keyPathExpr, .macroExpansionExpr, .postfixIfConfigExpr, .editorPlaceholderExpr: return true
+    case .missingExpr, .inOutExpr, .poundColumnExpr, .tryExpr, .awaitExpr, .moveExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .packElementExpr, .sequenceExpr, .symbolicReferenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .infixOperatorExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .unresolvedTernaryExpr, .ternaryExpr, .memberAccessExpr, .unresolvedIsExpr, .isExpr, .unresolvedAsExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .regexLiteralExpr, .keyPathExpr, .macroExpansionExpr, .postfixIfConfigExpr, .editorPlaceholderExpr: return true
     default: return false
     }
   }
@@ -1585,6 +1585,66 @@ public struct RawAssignmentExprSyntax: RawExprSyntaxNodeProtocol {
   }
 }
 
+@_spi(RawSyntax)
+public struct RawPackElementExprSyntax: RawExprSyntaxNodeProtocol {
+
+  @_spi(RawSyntax)
+  public var layoutView: RawSyntaxLayoutView {
+    return raw.layoutView!
+  }
+
+  public static func isKindOf(_ raw: RawSyntax) -> Bool {
+    return raw.kind == .packElementExpr
+  }
+
+  public var raw: RawSyntax
+  init(raw: RawSyntax) {
+    assert(Self.isKindOf(raw))
+    self.raw = raw
+  }
+
+  public init?<Node: RawSyntaxNodeProtocol>(_ other: Node) {
+    guard Self.isKindOf(other.raw) else { return nil }
+    self.init(raw: other.raw)
+  }
+
+  public init(
+    _ unexpectedBeforeEachKeyword: RawUnexpectedNodesSyntax? = nil,
+    eachKeyword: RawTokenSyntax,
+    _ unexpectedBetweenEachKeywordAndPackRefExpr: RawUnexpectedNodesSyntax? = nil,
+    packRefExpr: RawExprSyntax,
+    _ unexpectedAfterPackRefExpr: RawUnexpectedNodesSyntax? = nil,
+    arena: __shared SyntaxArena
+  ) {
+    let raw = RawSyntax.makeLayout(
+      kind: .packElementExpr, uninitializedCount: 5, arena: arena) { layout in
+      layout.initialize(repeating: nil)
+      layout[0] = unexpectedBeforeEachKeyword?.raw
+      layout[1] = eachKeyword.raw
+      layout[2] = unexpectedBetweenEachKeywordAndPackRefExpr?.raw
+      layout[3] = packRefExpr.raw
+      layout[4] = unexpectedAfterPackRefExpr?.raw
+    }
+    self.init(raw: raw)
+  }
+
+  public var unexpectedBeforeEachKeyword: RawUnexpectedNodesSyntax? {
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+  public var eachKeyword: RawTokenSyntax {
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
+  }
+  public var unexpectedBetweenEachKeywordAndPackRefExpr: RawUnexpectedNodesSyntax? {
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+  public var packRefExpr: RawExprSyntax {
+    layoutView.children[3].map(RawExprSyntax.init(raw:))!
+  }
+  public var unexpectedAfterPackRefExpr: RawUnexpectedNodesSyntax? {
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+}
+
 @_spi(RawSyntax)
 public struct RawSequenceExprSyntax: RawExprSyntaxNodeProtocol {
 

Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxValidation.swift

@@ -264,6 +264,14 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self))
     assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
     break
+  case .packElementExpr:
+    assert(layout.count == 5)
+    assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
+    assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self))
+    assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
+    assertNoError(kind, 3, verify(layout[3], as: RawExprSyntax.self))
+    assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self))
+    break
   case .sequenceExpr:
     assert(layout.count == 3)
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))

Sources/SwiftSyntax/generated/Misc.swift

@@ -197,6 +197,7 @@ extension Syntax {
     .node(OptionalChainingExprSyntax.self), 
     .node(OptionalPatternSyntax.self), 
     .node(OptionalTypeSyntax.self), 
+    .node(PackElementExprSyntax.self), 
     .node(PackExpansionTypeSyntax.self), 
     .node(PackReferenceTypeSyntax.self), 
     .node(ParameterClauseSyntax.self), 
@@ -645,6 +646,8 @@ extension SyntaxKind {
       return OptionalPatternSyntax.self
     case .optionalType: 
       return OptionalTypeSyntax.self
+    case .packElementExpr: 
+      return PackElementExprSyntax.self
     case .packExpansionType: 
       return PackExpansionTypeSyntax.self
     case .packReferenceType: 
@@ -1176,6 +1179,8 @@ extension SyntaxKind {
       return "optional pattern"
     case .optionalType: 
       return "optional type"
+    case .packElementExpr: 
+      return nil
     case .packExpansionType: 
       return "variadic expansion"
     case .packReferenceType: 

Sources/SwiftSyntax/gyb_generated/SyntaxAnyVisitor.swift

@@ -242,6 +242,13 @@ open class SyntaxAnyVisitor: SyntaxVisitor {
   override open func visitPost(_ node: AssignmentExprSyntax) {
     visitAnyPost(node._syntaxNode)
   }
+  override open func visit(_ node: PackElementExprSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+
+  override open func visitPost(_ node: PackElementExprSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
   override open func visit(_ node: SequenceExprSyntax) -> SyntaxVisitorContinueKind {
     return visitAny(node._syntaxNode)
   }

Sources/SwiftSyntax/gyb_generated/SyntaxBaseNodes.swift

@@ -215,7 +215,7 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
 
   public init?<S: SyntaxProtocol>(_ node: S) {
     switch node.raw.kind {
-    case .missingExpr, .inOutExpr, .poundColumnExpr, .tryExpr, .awaitExpr, .moveExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .sequenceExpr, .symbolicReferenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .infixOperatorExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .unresolvedTernaryExpr, .ternaryExpr, .memberAccessExpr, .unresolvedIsExpr, .isExpr, .unresolvedAsExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .regexLiteralExpr, .keyPathExpr, .macroExpansionExpr, .postfixIfConfigExpr, .editorPlaceholderExpr:
+    case .missingExpr, .inOutExpr, .poundColumnExpr, .tryExpr, .awaitExpr, .moveExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .packElementExpr, .sequenceExpr, .symbolicReferenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .infixOperatorExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .unresolvedTernaryExpr, .ternaryExpr, .memberAccessExpr, .unresolvedIsExpr, .isExpr, .unresolvedAsExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .regexLiteralExpr, .keyPathExpr, .macroExpansionExpr, .postfixIfConfigExpr, .editorPlaceholderExpr:
       self._syntaxNode = node._syntaxNode
     default:
       return nil
@@ -229,7 +229,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 .missingExpr, .inOutExpr, .poundColumnExpr, .tryExpr, .awaitExpr, .moveExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .sequenceExpr, .symbolicReferenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .infixOperatorExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .unresolvedTernaryExpr, .ternaryExpr, .memberAccessExpr, .unresolvedIsExpr, .isExpr, .unresolvedAsExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .regexLiteralExpr, .keyPathExpr, .macroExpansionExpr, .postfixIfConfigExpr, .editorPlaceholderExpr:
+    case .missingExpr, .inOutExpr, .poundColumnExpr, .tryExpr, .awaitExpr, .moveExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .packElementExpr, .sequenceExpr, .symbolicReferenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .infixOperatorExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .unresolvedTernaryExpr, .ternaryExpr, .memberAccessExpr, .unresolvedIsExpr, .isExpr, .unresolvedAsExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .regexLiteralExpr, .keyPathExpr, .macroExpansionExpr, .postfixIfConfigExpr, .editorPlaceholderExpr:
       break
     default:
       fatalError("Unable to create ExprSyntax from \(data.raw.kind)")
@@ -278,6 +278,7 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
       .node(NilLiteralExprSyntax.self),
       .node(DiscardAssignmentExprSyntax.self),
       .node(AssignmentExprSyntax.self),
+      .node(PackElementExprSyntax.self),
       .node(SequenceExprSyntax.self),
       .node(SymbolicReferenceExprSyntax.self),
       .node(PrefixOperatorExprSyntax.self),

Sources/SwiftSyntax/gyb_generated/SyntaxEnum.swift

@@ -43,6 +43,7 @@ public enum SyntaxEnum {
   case nilLiteralExpr(NilLiteralExprSyntax)
   case discardAssignmentExpr(DiscardAssignmentExprSyntax)
   case assignmentExpr(AssignmentExprSyntax)
+  case packElementExpr(PackElementExprSyntax)
   case sequenceExpr(SequenceExprSyntax)
   case exprList(ExprListSyntax)
   case symbolicReferenceExpr(SymbolicReferenceExprSyntax)
@@ -340,6 +341,8 @@ public extension Syntax {
       return .discardAssignmentExpr(DiscardAssignmentExprSyntax(self)!)
     case .assignmentExpr:
       return .assignmentExpr(AssignmentExprSyntax(self)!)
+    case .packElementExpr:
+      return .packElementExpr(PackElementExprSyntax(self)!)
     case .sequenceExpr:
       return .sequenceExpr(SequenceExprSyntax(self)!)
     case .exprList:

Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift

@@ -692,6 +692,37 @@ public enum SyntaxFactory {
       return AssignmentExprSyntax(data)
     }
   }
+  @available(*, deprecated, message: "Use initializer on PackElementExprSyntax")
+  public static func makePackElementExpr(_ unexpectedBeforeEachKeyword: UnexpectedNodesSyntax? = nil, eachKeyword: TokenSyntax, _ unexpectedBetweenEachKeywordAndPackRefExpr: UnexpectedNodesSyntax? = nil, packRefExpr: ExprSyntax, _ unexpectedAfterPackRefExpr: UnexpectedNodesSyntax? = nil) -> PackElementExprSyntax {
+    let layout: [RawSyntax?] = [
+      unexpectedBeforeEachKeyword?.raw,
+      eachKeyword.raw,
+      unexpectedBetweenEachKeywordAndPackRefExpr?.raw,
+      packRefExpr.raw,
+      unexpectedAfterPackRefExpr?.raw,
+    ]
+    return withExtendedLifetime(SyntaxArena()) { arena in
+      let raw = RawSyntax.makeLayout(kind: SyntaxKind.packElementExpr,
+        from: layout, arena: arena)
+      let data = SyntaxData.forRoot(raw)
+      return PackElementExprSyntax(data)
+    }
+  }
+
+  @available(*, deprecated, message: "Use initializer on PackElementExprSyntax")
+  public static func makeBlankPackElementExpr(presence: SourcePresence = .present) -> PackElementExprSyntax {
+    return withExtendedLifetime(SyntaxArena()) { arena in
+      let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .packElementExpr,
+        from: [
+        nil,
+        RawSyntax.makeMissingToken(kind: TokenKind.contextualKeyword(""), arena: arena),
+        nil,
+        RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena),
+        nil,
+      ], arena: arena))
+      return PackElementExprSyntax(data)
+    }
+  }
   @available(*, deprecated, message: "Use initializer on SequenceExprSyntax")
   public static func makeSequenceExpr(_ unexpectedBeforeElements: UnexpectedNodesSyntax? = nil, elements: ExprListSyntax, _ unexpectedAfterElements: UnexpectedNodesSyntax? = nil) -> SequenceExprSyntax {
     let layout: [RawSyntax?] = [

Sources/SwiftSyntax/gyb_generated/SyntaxKind.swift

@@ -43,6 +43,7 @@ public enum SyntaxKind {
   case nilLiteralExpr
   case discardAssignmentExpr
   case assignmentExpr
+  case packElementExpr
   case sequenceExpr
   case exprList
   case symbolicReferenceExpr

Sources/SwiftSyntax/gyb_generated/SyntaxRewriter.swift

@@ -212,6 +212,13 @@ open class SyntaxRewriter {
     return ExprSyntax(visitChildren(node))
   }
 
+  /// Visit a `PackElementExprSyntax`.
+  ///   - Parameter node: the node that is being visited
+  ///   - Returns: the rewritten node
+  open func visit(_ node: PackElementExprSyntax) -> ExprSyntax {
+    return ExprSyntax(visitChildren(node))
+  }
+
   /// Visit a `SequenceExprSyntax`.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
@@ -2201,6 +2208,16 @@ open class SyntaxRewriter {
     return Syntax(visit(node))
   }
 
+  /// Implementation detail of visit(_:). Do not call directly.
+  private func visitImplPackElementExprSyntax(_ data: SyntaxData) -> Syntax {
+    let node = PackElementExprSyntax(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 visitImplSequenceExprSyntax(_ data: SyntaxData) -> Syntax {
     let node = SequenceExprSyntax(data)
@@ -4645,6 +4662,8 @@ open class SyntaxRewriter {
       return visitImplDiscardAssignmentExprSyntax
     case .assignmentExpr:
       return visitImplAssignmentExprSyntax
+    case .packElementExpr:
+      return visitImplPackElementExprSyntax
     case .sequenceExpr:
       return visitImplSequenceExprSyntax
     case .exprList:
@@ -5182,6 +5201,8 @@ open class SyntaxRewriter {
       return visitImplDiscardAssignmentExprSyntax(data)
     case .assignmentExpr:
       return visitImplAssignmentExprSyntax(data)
+    case .packElementExpr:
+      return visitImplPackElementExprSyntax(data)
     case .sequenceExpr:
       return visitImplSequenceExprSyntax(data)
     case .exprList:

Sources/SwiftSyntax/gyb_generated/SyntaxTransform.swift

@@ -127,6 +127,10 @@ public protocol SyntaxTransformVisitor {
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: AssignmentExprSyntax) -> ResultType
+  /// Visiting `PackElementExprSyntax` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: the sum of whatever the child visitors return.
+  func visit(_ node: PackElementExprSyntax) -> ResultType
   /// Visiting `SequenceExprSyntax` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
@@ -1236,6 +1240,12 @@ extension SyntaxTransformVisitor {
   public func visit(_ node: AssignmentExprSyntax) -> ResultType {
     visitAny(Syntax(node))
   }
+  /// Visiting `PackElementExprSyntax` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: nil by default.
+  public func visit(_ node: PackElementExprSyntax) -> ResultType {
+    visitAny(Syntax(node))
+  }
   /// Visiting `SequenceExprSyntax` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
@@ -2705,6 +2715,8 @@ extension SyntaxTransformVisitor {
       return visit(derived)
     case .assignmentExpr(let derived):
       return visit(derived)
+    case .packElementExpr(let derived):
+      return visit(derived)
     case .sequenceExpr(let derived):
       return visit(derived)
     case .exprList(let derived):