[PreCheckExpr] Consider postfix ellipsis expressions containing 'each' type

reprs to be pack expansion expressions.

Author: hborla

include/swift/AST/Expr.h

@@ -3584,10 +3584,6 @@ class PackExpansionExpr final : public Expr,
     : Expr(ExprKind::PackExpansion, implicit, type),
       PatternExpr(patternExpr), DotsLoc(dotsLoc), Environment(environment) {
     Bits.PackExpansionExpr.NumBindings = packElements.size();
-
-    assert(Bits.PackExpansionExpr.NumBindings > 0 &&
-           "PackExpansionExpr must have pack references");
-
     std::uninitialized_copy(packElements.begin(), packElements.end(),
                             getTrailingObjects<PackElementExpr *>());
   }

lib/Sema/CSGen.cpp

@@ -23,6 +23,7 @@
 #include "swift/AST/ASTWalker.h"
 #include "swift/AST/Expr.h"
 #include "swift/AST/GenericSignature.h"
+#include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/ParameterList.h"
 #include "swift/AST/PrettyStackTrace.h"
 #include "swift/AST/SubstitutionMap.h"
@@ -3006,9 +3007,17 @@ namespace {
       auto *shapeTypeVar = CS.createTypeVariable(shapeLoc,
                                                  TVO_CanBindToPack |
                                                  TVO_CanBindToHole);
-      auto packReference = expr->getPackElements().front()->getPackRefExpr();
-      auto packType = CS.simplifyType(CS.getType(packReference))
-          ->castTo<PackExpansionType>()->getPatternType();
+      Type packType;
+      if (!expr->getPackElements().empty()) {
+        auto packReference = expr->getPackElements().front()->getPackRefExpr();
+        packType = CS.simplifyType(CS.getType(packReference))
+            ->castTo<PackExpansionType>()->getPatternType();
+      } else {
+        // FIXME: The generic environment needs to be per-shape-class.
+        llvm::SmallVector<GenericEnvironment::PackElementBinding, 2> bindings;
+        elementEnv->getPackElementBindings(bindings);
+        packType = bindings.front().second;
+      }
       CS.addConstraint(ConstraintKind::ShapeOf, packType, shapeTypeVar,
                        CS.getConstraintLocator(expr));
 

lib/Sema/PreCheckExpr.cpp

@@ -408,13 +408,9 @@ static Expr *getPackExpansion(DeclContext *dc, Expr *expr, SourceLoc opLoc) {
     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);
-
+    void createElementEnvironment() {
       if (!environment) {
+        auto &ctx = dc->getASTContext();
         auto sig = ctx.getOpenedElementSignature(
             dc->getGenericSignatureOfContext().getCanonicalSignature());
         auto *contextEnv = dc->getGenericEnvironmentOfContext();
@@ -423,15 +419,30 @@ static Expr *getPackExpansion(DeclContext *dc, Expr *expr, SourceLoc opLoc) {
             GenericEnvironment::forOpenedElement(sig, UUID::fromTime(),
                                                  contextSubs);
       }
+    }
 
+    virtual PreWalkResult<Expr *> walkToExprPre(Expr *E) override {
+      auto *packElement = dyn_cast<PackElementExpr>(E);
+      if (!packElement)
+        return Action::Continue(E);
+
+      createElementEnvironment();
       packElements.push_back(packElement);
       return Action::Continue(packElement);
     }
+
+    virtual PreWalkAction walkToTypeReprPre(TypeRepr *T) override {
+      if (isa<PackReferenceTypeRepr>(T)) {
+        createElementEnvironment();
+      }
+
+      return Action::Continue();
+    }
   } packReferenceFinder(dc);
 
   auto *pattern = expr->walk(packReferenceFinder);
 
-  if (!packReferenceFinder.packElements.empty()) {
+  if (packReferenceFinder.environment != nullptr) {
     return PackExpansionExpr::create(dc->getASTContext(), pattern,
                                      packReferenceFinder.packElements,
                                      opLoc, packReferenceFinder.environment);

test/Constraints/pack-expansion-expressions.swift

@@ -63,3 +63,8 @@ func forEachEach<C..., U>(c: C..., function: (U) -> Void)
     where C: Collection, C.Element == U {
   _ = (each c).forEach(function)...
 }
+
+func typeReprPacks<T...>(_ t: T...) where T: ExpressibleByIntegerLiteral {
+  _ = Array<each T>()...
+  _ = (1 as each T)...
+}