[Sema] Represent pack element references in pack expansion patterns as

PackElementExpr.

Author: hborla

include/swift/AST/Expr.h

@@ -3569,51 +3569,41 @@ class PackElementExpr final : public Expr {
 /// call argument lists, the elements of a tuple value, and the source
 /// of a for-in loop.
 class PackExpansionExpr final : public Expr,
-    private llvm::TrailingObjects<PackExpansionExpr,
-                                  OpaqueValueExpr *, Expr *> {
+    private llvm::TrailingObjects<PackExpansionExpr, PackElementExpr *> {
   friend TrailingObjects;
 
   Expr *PatternExpr;
   SourceLoc DotsLoc;
   GenericEnvironment *Environment;
 
   PackExpansionExpr(Expr *patternExpr,
-                    ArrayRef<OpaqueValueExpr *> opaqueValues,
-                    ArrayRef<Expr *> bindings,
+                    ArrayRef<PackElementExpr *> packElements,
                     SourceLoc dotsLoc,
                     GenericEnvironment *environment,
                     bool implicit, Type type)
     : Expr(ExprKind::PackExpansion, implicit, type),
       PatternExpr(patternExpr), DotsLoc(dotsLoc), Environment(environment) {
-    assert(opaqueValues.size() == bindings.size());
-    Bits.PackExpansionExpr.NumBindings = opaqueValues.size();
+    Bits.PackExpansionExpr.NumBindings = packElements.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();
+    std::uninitialized_copy(packElements.begin(), packElements.end(),
+                            getTrailingObjects<PackElementExpr *>());
   }
 
-  size_t numTrailingObjects(OverloadToken<Expr *>) const {
+  size_t numTrailingObjects(OverloadToken<PackElementExpr *>) const {
     return getNumBindings();
   }
 
-  MutableArrayRef<Expr *> getMutableBindings() {
-    return {getTrailingObjects<Expr *>(), getNumBindings()};
+  MutableArrayRef<PackElementExpr *> getMutableBindings() {
+    return {getTrailingObjects<PackElementExpr *>(), getNumBindings()};
   }
 
 public:
   static PackExpansionExpr *create(ASTContext &ctx,
                                    Expr *patternExpr,
-                                   ArrayRef<OpaqueValueExpr *> opaqueValues,
-                                   ArrayRef<Expr *> bindings,
+                                   ArrayRef<PackElementExpr *> packElements,
                                    SourceLoc dotsLoc,
                                    GenericEnvironment *environment,
                                    bool implicit = false,
@@ -3629,15 +3619,11 @@ class PackExpansionExpr final : public Expr,
     return Bits.PackExpansionExpr.NumBindings;
   }
 
-  ArrayRef<OpaqueValueExpr *> getOpaqueValues() {
-    return {getTrailingObjects<OpaqueValueExpr *>(), getNumBindings()};
-  }
-
-  ArrayRef<Expr *> getBindings() {
-    return {getTrailingObjects<Expr *>(), getNumBindings()};
+  ArrayRef<PackElementExpr *> getPackElements() {
+    return {getTrailingObjects<PackElementExpr *>(), getNumBindings()};
   }
 
-  void setBinding(unsigned i, Expr *e) {
+  void setBinding(unsigned i, PackElementExpr *e) {
     getMutableBindings()[i] = e;
   }
 

lib/AST/ASTVerifier.cpp

@@ -836,12 +836,6 @@ class Verifier : public ASTWalker {
         return false;
 
       Generics.push_back(expr->getGenericEnvironment());
-
-      for (auto *placeholder : expr->getOpaqueValues()) {
-        assert(!OpaqueValues.count(placeholder));
-        OpaqueValues[placeholder] = 0;
-      }
-
       return true;
     }
 
@@ -854,13 +848,6 @@ class Verifier : public ASTWalker {
       verifyCheckedAlwaysBase(E);
     }
 
-    void cleanup(PackExpansionExpr *expr) {
-      for (auto *placeholder : expr->getOpaqueValues()) {
-        assert(OpaqueValues.count(placeholder));
-        OpaqueValues.erase(placeholder);
-      }
-    }
-
     bool shouldVerify(MakeTemporarilyEscapableExpr *expr) {
       if (!shouldVerify(cast<Expr>(expr)))
         return false;

lib/AST/Expr.cpp

@@ -1248,16 +1248,14 @@ VarargExpansionExpr *VarargExpansionExpr::createArrayExpansion(ASTContext &ctx,
 
 PackExpansionExpr *
 PackExpansionExpr::create(ASTContext &ctx, Expr *patternExpr,
-                          ArrayRef<OpaqueValueExpr *> opaqueValues,
-                          ArrayRef<Expr *> bindings, SourceLoc dotsLoc,
-                          GenericEnvironment *environment,
+                          ArrayRef<PackElementExpr *> packElements,
+                          SourceLoc dotsLoc, GenericEnvironment *environment,
                           bool implicit, Type type) {
   size_t size =
-      totalSizeToAlloc<OpaqueValueExpr *, Expr *>(opaqueValues.size(),
-                                                  bindings.size());
+      totalSizeToAlloc<PackElementExpr *>(packElements.size());
   void *mem = ctx.Allocate(size, alignof(PackExpansionExpr));
-  return ::new (mem) PackExpansionExpr(patternExpr, opaqueValues,
-                                       bindings, dotsLoc, environment,
+  return ::new (mem) PackExpansionExpr(patternExpr, packElements,
+                                       dotsLoc, environment,
                                        implicit, type);
 }
 

lib/Sema/CSApply.cpp

@@ -3820,13 +3820,7 @@ namespace {
     }
 
     Expr *visitPackExpansionExpr(PackExpansionExpr *expr) {
-      for (unsigned i = 0; i < expr->getNumBindings(); ++i) {
-        auto *binding = expr->getBindings()[i];
-        expr->setBinding(i, visit(binding));
-      }
-
-      simplifyExprType(expr);
-      return expr;
+      return simplifyExprType(expr);
     }
 
     Expr *visitPackElementExpr(PackElementExpr *expr) {
@@ -7136,10 +7130,9 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
     auto shapeType = toExpansionType->getCountType();
     auto expansionTy = PackExpansionType::get(patternType, shapeType);
 
-    return cs.cacheType(PackExpansionExpr::create(ctx, pattern,
-        expansion->getOpaqueValues(), expansion->getBindings(),
-        expansion->getEndLoc(), expansion->getGenericEnvironment(),
-        expansion->isImplicit(), expansionTy));
+    expansion->setPatternExpr(pattern);
+    expansion->setType(expansionTy);
+    return expansion;
   }
 
   case TypeKind::BuiltinTuple:

lib/Sema/CSGen.cpp

@@ -2983,7 +2983,7 @@ namespace {
       auto *shapeTypeVar = CS.createTypeVariable(shapeLoc,
                                                  TVO_CanBindToPack |
                                                  TVO_CanBindToHole);
-      auto packReference = expr->getBindings().front();
+      auto packReference = expr->getPackElements().front()->getPackRefExpr();
       auto packType = CS.simplifyType(CS.getType(packReference))
           ->castTo<PackExpansionType>()->getPatternType();
       CS.addConstraint(ConstraintKind::ShapeOf, packType, shapeTypeVar,

lib/Sema/MiscDiagnostics.cpp

@@ -3621,16 +3621,6 @@ void VarDeclUsageChecker::markStoredOrInOutExpr(Expr *E, unsigned Flags) {
     return markStoredOrInOutExpr(OEE->getSubExpr(), Flags);
   }
 
-  // Bind pack references in pack expansions.
-  if (auto *expansion = dyn_cast<PackExpansionExpr>(E)) {
-    for (unsigned i = 0; i < expansion->getNumBindings(); ++i) {
-      auto *opaqueValue = expansion->getOpaqueValues()[i];
-      auto *packReference = expansion->getBindings()[i];
-      OpaqueValueMap[opaqueValue] = packReference;
-    }
-    return markStoredOrInOutExpr(expansion->getPatternExpr(), Flags);
-  }
-  
   // If this is an OpaqueValueExpr that we've seen a mapping for, jump to the
   // mapped value.
   if (auto *OVE = dyn_cast<OpaqueValueExpr>(E))
@@ -3707,15 +3697,6 @@ ASTWalker::PreWalkResult<Expr *> VarDeclUsageChecker::walkToExprPre(Expr *E) {
     return Action::SkipChildren(E);
   }
 
-  // If we see a PackExpansionExpr, record its pack reference bindings.
-  if (auto *expansion = dyn_cast<PackExpansionExpr>(E)) {
-    for (unsigned i = 0; i < expansion->getNumBindings(); ++i) {
-      auto *opaqueValue = expansion->getOpaqueValues()[i];
-      auto *packReference = expansion->getBindings()[i];
-      OpaqueValueMap[opaqueValue] = packReference;
-    }
-  }
-
   // Visit bindings.
   if (auto ove = dyn_cast<OpaqueValueExpr>(E)) {
     if (auto mapping = OpaqueValueMap.lookup(ove))

lib/Sema/PreCheckExpr.cpp

@@ -402,55 +402,38 @@ static BinaryExpr *getCompositionExpr(Expr *expr) {
 static Expr *getPackExpansion(DeclContext *dc, Expr *expr, SourceLoc opLoc) {
   struct PackReferenceFinder : public ASTWalker {
     DeclContext *dc;
-    llvm::SmallVector<OpaqueValueExpr *, 2> opaqueValues;
-    llvm::SmallVector<Expr *, 2> bindings;
+    llvm::SmallVector<PackElementExpr *, 2> packElements;
     GenericEnvironment *environment;
 
     PackReferenceFinder(DeclContext *dc)
       : dc(dc), environment(nullptr) {}
 
     virtual PreWalkResult<Expr *> walkToExprPre(Expr *E) override {
       auto &ctx = dc->getASTContext();
+      auto *packElement = dyn_cast<PackElementExpr>(E);
+      if (!packElement)
+        return Action::Continue(E);
 
-      if (auto *declRef = dyn_cast<DeclRefExpr>(E)) {
-        auto *decl = dyn_cast<VarDecl>(declRef->getDecl());
-        if (!decl)
-          return Action::Continue(E);
-
-        if (auto expansionType = decl->getType()->getAs<PackExpansionType>()) {
-          auto sourceRange = declRef->getSourceRange();
-
-          // Map the pattern interface type into the context of the opened
-          // element signature.
-          if (!environment) {
-            auto sig = ctx.getOpenedElementSignature(
-                dc->getGenericSignatureOfContext().getCanonicalSignature());
-            auto *contextEnv = dc->getGenericEnvironmentOfContext();
-            auto contextSubs = contextEnv->getForwardingSubstitutionMap();
-            environment =
-                GenericEnvironment::forOpenedElement(sig, UUID::fromTime(),
-                                                     contextSubs);
-          }
-          auto elementType = environment->mapPackTypeIntoElementContext(
-              expansionType->getPatternType()->mapTypeOutOfContext());
-
-          auto *opaqueValue = new (ctx) OpaqueValueExpr(sourceRange, elementType);
-          opaqueValues.push_back(opaqueValue);
-          bindings.push_back(declRef);
-          return Action::Continue(opaqueValue);
-        }
+      if (!environment) {
+        auto sig = ctx.getOpenedElementSignature(
+            dc->getGenericSignatureOfContext().getCanonicalSignature());
+        auto *contextEnv = dc->getGenericEnvironmentOfContext();
+        auto contextSubs = contextEnv->getForwardingSubstitutionMap();
+        environment =
+            GenericEnvironment::forOpenedElement(sig, UUID::fromTime(),
+                                                 contextSubs);
       }
 
-      return Action::Continue(E);
+      packElements.push_back(packElement);
+      return Action::Continue(packElement);
     }
   } packReferenceFinder(dc);
 
   auto *pattern = expr->walk(packReferenceFinder);
 
-  if (!packReferenceFinder.bindings.empty()) {
+  if (!packReferenceFinder.packElements.empty()) {
     return PackExpansionExpr::create(dc->getASTContext(), pattern,
-                                     packReferenceFinder.opaqueValues,
-                                     packReferenceFinder.bindings,
+                                     packReferenceFinder.packElements,
                                      opLoc, packReferenceFinder.environment);
   }
 

test/Constraints/pack-expansion-expressions.swift

@@ -3,44 +3,44 @@
 // REQUIRES: asserts
 
 func tuplify<T...>(_ t: T...) -> (T...) {
-  return (t...)
+  return ((each t)...)
 }
 
 func prepend<First, Rest...>(value: First, to rest: Rest...) -> (First, Rest...) {
-  return (value, rest...)
+  return (value, (each rest)...)
 }
 
 func concatenate<T..., U...>(_ first: T..., with second: U...) -> (T..., U...) {
-  return (first..., second...)
+  return ((each first)..., (each second)...)
 }
 
 func zip<T..., U...>(_ first: T..., with second: U...) -> ((T, U)...) {
-  return ((first, second)...)
+  return ((each first, each second)...)
 }
 
 func forward<U...>(_ u: U...) -> (U...) {
-  return tuplify(u...)
+  return tuplify((each u)...)
 }
 
 func forwardAndMap<U..., V...>(us u: U..., vs v: V...) -> ([(U, V)]...) {
-  return tuplify([(u, v)]...)
+  return tuplify([(each u, each v)]...)
 }
 
 func variadicMap<T..., Result...>(_ t: T..., transform: ((T) -> Result)...) -> (Result...) {
-  return (transform(t)...)
+  return ((each transform)(each t)...)
 }
 
 func coerceExpansion<T...>(_ value: T...) {
   func promoteToOptional<Wrapped...>(_: Wrapped?...) {}
 
-  promoteToOptional(value...)
+  promoteToOptional((each value)...)
 }
 
 func localValuePack<T...>(_ t: T...) -> (T..., T...) {
-  let local = t...
-  let localAnnotated: T... = t...
+  let local = (each t)...
+  let localAnnotated: T... = (each t)...
 
-  return (local..., localAnnotated...)
+  return ((each local)..., (each localAnnotated)...)
 }
 
 protocol P {
@@ -52,14 +52,14 @@ protocol P {
 }
 
 func outerArchetype<T..., U>(t: T..., u: U) where T: P {
-  let _: (T.A, U)... = (t.value, u)...
+  let _: (T.A, U)... = ((each t).value, u)...
 }
 
 func sameElement<T..., U>(t: T..., u: U) where T: P, T == U {
-  let _: T... = t.f(u)...
+  let _: T... = (each t).f(u)...
 }
 
 func forEachEach<C..., U>(c: C..., function: (U) -> Void)
     where C: Collection, C.Element == U {
-  _ = c.forEach(function)...
+  _ = (each c).forEach(function)...
 }

test/Constraints/variadic_generic_constraints.swift

@@ -69,10 +69,10 @@ let _ = zip(t: 1, 2, 3, u: "hi", "hello", "greetings")  // ok
 let _ = zip(t: 1, u: "hi", "hello", "greetings")  // expected-error {{type of expression is ambiguous without more context}}
 
 func goodCallToZip<T..., U...>(t: T..., u: U...) where ((T, U)...): Any {
-  _ = zip(t: t..., u: u...)
+  _ = zip(t: (each t)..., u: (each u)...)
 }
 
 func badCallToZip<T..., U...>(t: T..., u: U...) {
-  _ = zip(t: t..., u: u...)
+  _ = zip(t: (each t)..., u: (each u)...)
   // expected-error@-1 {{global function 'zip(t:u:)' requires the type packs 'T' and 'U' have the same shape}}
 }