[Variadic Generics] Parse contexutal 'each' in expression context as a

pack element expression.

Author: hborla

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())

Tests/SwiftParserTest/VariadicGenericsTests.swift

@@ -10,7 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-
+@_spi(RawSyntax) import SwiftSyntax
 import XCTest
 
 final class VariadicGenericsTests: XCTestCase {
@@ -60,4 +60,84 @@ final class VariadicGenericsTests: XCTestCase {
       ]
     )
   }
+
+  func testPackElementExprSimple() {
+    AssertParse(
+      """
+      func tuplify<T...>(_ t: (each T)...) -> ((each T)...) {
+        return ((each t)...)
+      }
+      """
+    )
+
+    AssertParse(
+      """
+      func zip<T..., U...>(_ first: T..., with second: U...) -> ((T, U)...) {
+        return ((each first, each second)...)
+      }
+      """
+    )
+
+    AssertParse(
+      """
+      func variadicMap<T..., Result...>(_ t: T..., transform: ((T) -> Result)...) -> (Result...) {
+        return ((each transform)(each t)...)
+      }
+      """
+    )
+  }
+
+  func testEachExprContextualKeyword() {
+    let callExpr = FunctionCallExprSyntax(
+      calledExpression: IdentifierExprSyntax(
+        identifier: .identifier("each")
+      ),
+      leftParen: .leftParen,
+      argumentList: TupleExprElementListSyntax([
+        .init(expression:
+                IdentifierExprSyntax(
+                  identifier: .identifier("x")
+                )
+             )
+      ]),
+      rightParen: .rightParen
+    )
+
+    AssertParse(
+      """
+      func test() {
+      1️⃣each(x)
+      }
+      """,
+      substructure: Syntax(callExpr),
+      substructureAfterMarker: "1️⃣"
+    )
+
+    AssertParse(
+      """
+      func test() {
+      1️⃣each (x)
+      }
+      """,
+      substructure: Syntax(callExpr),
+      substructureAfterMarker: "1️⃣"
+    )
+
+    AssertParse(
+      """
+      func test() {
+      1️⃣each x
+      }
+      """,
+      substructure: Syntax(
+        PackElementExprSyntax(
+          eachKeyword: .contextualKeyword("each"),
+          packRefExpr: IdentifierExprSyntax(
+            identifier: .identifier("x")
+          )
+        )
+      ),
+      substructureAfterMarker: "1️⃣"
+    )
+  }
 }