[AST] Store opaque value bindings in PackExpansionExpr.

Author: hborla

include/swift/AST/Expr.h

@@ -350,6 +350,11 @@ class alignas(8) Expr : public ASTAllocated<Expr> {
     IsObjC : 1
   );
 
+  SWIFT_INLINE_BITFIELD_FULL(PackExpansionExpr, Expr, 32,
+    : NumPadBits,
+    NumBindings : 32
+  );
+
   SWIFT_INLINE_BITFIELD_FULL(SequenceExpr, Expr, 32,
     : NumPadBits,
     NumElements : 32
@@ -3519,19 +3524,50 @@ class VarargExpansionExpr : public Expr {
 /// that naturally accept a comma-separated list of values, including
 /// call argument lists, the elements of a tuple value, and the source
 /// of a for-in loop.
-class PackExpansionExpr: public Expr {
+class PackExpansionExpr final : public Expr,
+    private llvm::TrailingObjects<PackExpansionExpr,
+                                  OpaqueValueExpr *, Expr *> {
+  friend TrailingObjects;
+
   Expr *PatternExpr;
   SourceLoc DotsLoc;
 
   PackExpansionExpr(Expr *patternExpr,
+                    ArrayRef<OpaqueValueExpr *> opaqueValues,
+                    ArrayRef<Expr *> bindings,
                     SourceLoc dotsLoc,
                     bool implicit, Type type)
     : Expr(ExprKind::PackExpansion, implicit, type),
-      PatternExpr(patternExpr), DotsLoc(dotsLoc) {}
+      PatternExpr(patternExpr), DotsLoc(dotsLoc) {
+    assert(opaqueValues.size() == bindings.size());
+    Bits.PackExpansionExpr.NumBindings = opaqueValues.size();
+
+    assert(Bits.PackExpansionExpr.NumBindings > 0 &&
+           "PackExpansionExpr must have pack references");
+
+    std::uninitialized_copy(opaqueValues.begin(), opaqueValues.end(),
+                            getTrailingObjects<OpaqueValueExpr *>());
+    std::uninitialized_copy(bindings.begin(), bindings.end(),
+                            getTrailingObjects<Expr *>());
+  }
+
+  size_t numTrailingObjects(OverloadToken<OpaqueValueExpr *>) const {
+    return getNumBindings();
+  }
+
+  size_t numTrailingObjects(OverloadToken<Expr *>) const {
+    return getNumBindings();
+  }
+
+  MutableArrayRef<Expr *> getMutableBindings() {
+    return {getTrailingObjects<Expr *>(), getNumBindings()};
+  }
 
 public:
   static PackExpansionExpr *create(ASTContext &ctx,
                                    Expr *patternExpr,
+                                   ArrayRef<OpaqueValueExpr *> opaqueValues,
+                                   ArrayRef<Expr *> bindings,
                                    SourceLoc dotsLoc,
                                    bool implicit = false,
                                    Type type = Type());
@@ -3542,6 +3578,22 @@ class PackExpansionExpr: public Expr {
     PatternExpr = patternExpr;
   }
 
+  unsigned getNumBindings() const {
+    return Bits.PackExpansionExpr.NumBindings;
+  }
+
+  ArrayRef<OpaqueValueExpr *> getOpaqueValues() {
+    return {getTrailingObjects<OpaqueValueExpr *>(), getNumBindings()};
+  }
+
+  ArrayRef<Expr *> getBindings() {
+    return {getTrailingObjects<Expr *>(), getNumBindings()};
+  }
+
+  void setBinding(unsigned i, Expr *e) {
+    getMutableBindings()[i] = e;
+  }
+
   SourceLoc getStartLoc() const {
     return PatternExpr->getStartLoc();
   }

lib/AST/Expr.cpp

@@ -1239,10 +1239,17 @@ VarargExpansionExpr *VarargExpansionExpr::createArrayExpansion(ASTContext &ctx,
 
 PackExpansionExpr *
 PackExpansionExpr::create(ASTContext &ctx, Expr *patternExpr,
+                          ArrayRef<OpaqueValueExpr *> opaqueValues,
+                          ArrayRef<Expr *> bindings,
                           SourceLoc dotsLoc, bool implicit,
                           Type type) {
-  return new (ctx) PackExpansionExpr(patternExpr, dotsLoc,
-                                     implicit, type);
+  size_t size =
+      totalSizeToAlloc<OpaqueValueExpr *, Expr *>(opaqueValues.size(),
+                                                  bindings.size());
+  void *mem = ctx.Allocate(size, alignof(PackExpansionExpr));
+  return ::new (mem) PackExpansionExpr(patternExpr, opaqueValues,
+                                       bindings, dotsLoc,
+                                       implicit, type);
 }
 
 SequenceExpr *SequenceExpr::create(ASTContext &ctx, ArrayRef<Expr*> elements) {