[ASTGen] Implement PackElement and PackExpansion expressions

Author: rintaro

include/swift/AST/ASTBridging.h

@@ -740,6 +740,18 @@ BridgedOptionalTryExpr BridgedOptionalTryExpr_createParsed(
     BridgedASTContext cContext, BridgedSourceLoc cTryLoc, BridgedExpr cSubExpr,
     BridgedSourceLoc cQuestionLoc);
 
+SWIFT_NAME("BridgedPackElementExpr.createParsed(_:eachLoc:packRefExpr:)")
+BridgedPackElementExpr
+BridgedPackElementExpr_createParsed(BridgedASTContext cContext,
+                                    BridgedSourceLoc cEachLoc,
+                                    BridgedExpr cPackRefExpr);
+
+SWIFT_NAME("BridgedPackExpansionExpr.createParsed(_:repeatLoc:patternExpr:)")
+BridgedPackExpansionExpr
+BridgedPackExpansionExpr_createParsed(BridgedASTContext cContext,
+                                      BridgedSourceLoc cRepeatLoc,
+                                      BridgedExpr cPatternExpr);
+
 SWIFT_NAME("BridgedSingleValueStmtExpr.createWithWrappedBranches(_:stmt:"
            "declContext:mustBeExpr:)")
 BridgedSingleValueStmtExpr BridgedSingleValueStmtExpr_createWithWrappedBranches(

lib/AST/ASTBridging.cpp

@@ -994,6 +994,23 @@ BridgedOptionalTryExpr BridgedOptionalTryExpr_createParsed(
       cTryLoc.unbridged(), cSubExpr.unbridged(), cQuestionLoc.unbridged());
 }
 
+BridgedPackElementExpr
+BridgedPackElementExpr_createParsed(BridgedASTContext cContext,
+                                    BridgedSourceLoc cEachLoc,
+                                    BridgedExpr cPackRefExpr) {
+  return PackElementExpr::create(cContext.unbridged(), cEachLoc.unbridged(),
+                                 cPackRefExpr.unbridged());
+}
+
+BridgedPackExpansionExpr
+BridgedPackExpansionExpr_createParsed(BridgedASTContext cContext,
+                                      BridgedSourceLoc cRepeatLoc,
+                                      BridgedExpr cPatternExpr) {
+  return PackExpansionExpr::create(cContext.unbridged(), cRepeatLoc.unbridged(),
+                                   cPatternExpr.unbridged(),
+                                   /*genericEnv=*/nullptr);
+}
+
 BridgedSequenceExpr BridgedSequenceExpr_createParsed(BridgedASTContext cContext,
                                                      BridgedArrayRef exprs) {
   return SequenceExpr::create(cContext.unbridged(), exprs.unbridged<Expr *>());

lib/ASTGen/Sources/ASTGen/Exprs.swift

@@ -44,9 +44,10 @@ func isExprMigrated(_ node: ExprSyntax) -> Bool {
         .booleanLiteralExpr, .borrowExpr, .closureExpr, .consumeExpr, .copyExpr,
         .discardAssignmentExpr, .declReferenceExpr, .dictionaryExpr,
         .functionCallExpr, .ifExpr, .integerLiteralExpr, .memberAccessExpr,
-        .nilLiteralExpr, .postfixOperatorExpr, .prefixOperatorExpr,
-        .sequenceExpr, .stringLiteralExpr, .tryExpr, .tupleExpr, .typeExpr,
-        .unresolvedAsExpr, .unresolvedIsExpr, .unresolvedTernaryExpr:
+        .nilLiteralExpr, .packElementExpr, .packExpansionExpr,
+        .postfixOperatorExpr, .prefixOperatorExpr, .sequenceExpr,
+        .stringLiteralExpr, .tryExpr, .tupleExpr, .typeExpr,  .unresolvedAsExpr,
+        .unresolvedIsExpr, .unresolvedTernaryExpr:
 
       // `generate(stringLiteralExpr:)` doesn't support interpolations.
       if let str = current.as(StringLiteralExprSyntax.self) {
@@ -62,10 +63,9 @@ func isExprMigrated(_ node: ExprSyntax) -> Bool {
         .doExpr, .editorPlaceholderExpr, .floatLiteralExpr, .forceUnwrapExpr,
         .inOutExpr, .infixOperatorExpr,  .isExpr, .keyPathExpr,
         .macroExpansionExpr,  .optionalChainingExpr,
-        .packElementExpr, .packExpansionExpr, .postfixIfConfigExpr,
-        .regexLiteralExpr, .genericSpecializationExpr, .simpleStringLiteralExpr,
-        .subscriptCallExpr, .superExpr, .switchExpr, .ternaryExpr,
-        .patternExpr:
+        .postfixIfConfigExpr, .regexLiteralExpr, .genericSpecializationExpr,
+        .simpleStringLiteralExpr, .subscriptCallExpr, .superExpr, .switchExpr,
+        .ternaryExpr, .patternExpr:
       return false
     case // Unknown expr kinds.
       _ where current.is(ExprSyntax.self):
@@ -155,10 +155,10 @@ extension ASTGenVisitor {
     case .optionalChainingExpr:
       // Need special care to wrap the entire postfix chain with OptionalEvaluationExpr.
       break
-    case .packElementExpr:
-      break
-    case .packExpansionExpr:
-      break
+    case .packElementExpr(let node):
+      return self.generate(packElementExpr: node).asExpr
+    case .packExpansionExpr(let node):
+      return self.generate(packExpansionExpr: node).asExpr
     case .patternExpr:
       break
     case .postfixIfConfigExpr:
@@ -413,6 +413,22 @@ extension ASTGenVisitor {
     }
   }
 
+  func generate(packElementExpr node: PackElementExprSyntax) -> BridgedPackElementExpr {
+    return .createParsed(
+      self.ctx,
+      eachLoc: self.generateSourceLoc(node.eachKeyword),
+      packRefExpr: self.generate(expr: node.pack)
+    )
+  }
+
+  func generate(packExpansionExpr node: PackExpansionExprSyntax) -> BridgedPackExpansionExpr {
+    return .createParsed(
+      self.ctx,
+      repeatLoc: self.generateSourceLoc(node.repeatKeyword),
+      patternExpr: self.generate(expr: node.repetitionPattern)
+    )
+  }
+  
   func generate(ifExpr node: IfExprSyntax) -> BridgedSingleValueStmtExpr {
     let stmt = makeIfStmt(node).asStmt
 

test/ASTGen/verify-parse.swift

@@ -248,3 +248,7 @@ func testUnaryExprs() async throws {
   let bar = copy foo
   let baz = consume foo
 }
+
+func testRepeatEach<each T>(_ t: repeat each T) -> (repeat each T) {
+  return (repeat each t)
+}