[ConstraintSystem] Implement basic type checking for pack expressions.

During prechecking, postfix '...' expressions are rewritten to pack
expansion expressions if the operand contains pack references. References
to packs are replaced with opaque values, and the pack expansion stores
the opaque value bindings to decl refs.

Author: hborla

include/swift/AST/Identifier.h

@@ -128,6 +128,10 @@ class Identifier {
     return is("??");
   }
 
+  bool isExpansionOperator() const {
+    return is("...");
+  }
+
   /// isOperatorStartCodePoint - Return true if the specified code point is a
   /// valid start of an operator.
   static bool isOperatorStartCodePoint(uint32_t C) {

lib/AST/ASTVerifier.cpp

@@ -820,6 +820,25 @@ class Verifier : public ASTWalker {
       OpenedExistentialArchetypes.erase(expr->getOpenedArchetype());
     }
 
+    bool shouldVerify(PackExpansionExpr *expr) {
+      if (!shouldVerify(cast<Expr>(expr)))
+        return false;
+
+      for (auto *placeholder : expr->getOpaqueValues()) {
+        assert(!OpaqueValues.count(placeholder));
+        OpaqueValues[placeholder] = 0;
+      }
+
+      return true;
+    }
+
+    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/Sema/CSApply.cpp

@@ -3598,7 +3598,23 @@ namespace {
     }
 
     Expr *visitParenExpr(ParenExpr *expr) {
-      return simplifyExprType(expr);
+      Expr *result = expr;
+      auto type = simplifyType(cs.getType(expr));
+
+      // A ParenExpr can end up with a tuple type if it contains
+      // a pack expansion. Rewrite it to a TupleExpr.
+      if (dyn_cast<PackExpansionExpr>(expr->getSubExpr())) {
+        auto &ctx = cs.getASTContext();
+        result = TupleExpr::create(ctx, expr->getLParenLoc(),
+                                   {expr->getSubExpr()},
+                                   /*elementNames=*/{},
+                                   /*elementNameLocs=*/{},
+                                   expr->getRParenLoc(),
+                                   expr->isImplicit());
+      }
+
+      cs.setType(result, type);
+      return result;
     }
 
     Expr *visitUnresolvedMemberChainResultExpr(
@@ -3802,7 +3818,13 @@ namespace {
     }
 
     Expr *visitPackExpansionExpr(PackExpansionExpr *expr) {
-      llvm_unreachable("not implemented for PackExpansionExpr");
+      for (unsigned i = 0; i < expr->getNumBindings(); ++i) {
+        auto *binding = expr->getBindings()[i];
+        expr->setBinding(i, visit(binding));
+      }
+
+      simplifyExprType(expr);
+      return expr;
     }
 
     Expr *visitDynamicTypeExpr(DynamicTypeExpr *expr) {
@@ -3814,7 +3836,6 @@ namespace {
     }
 
     Expr *visitOpaqueValueExpr(OpaqueValueExpr *expr) {
-      assert(expr->isPlaceholder() && "Already type-checked");
       return expr;
     }
 

lib/Sema/CSGen.cpp

@@ -1770,6 +1770,13 @@ namespace {
     }
 
     virtual Type visitParenExpr(ParenExpr *expr) {
+      // If the ParenExpr contains a pack expansion, generate a tuple
+      // type containing the pack expansion type.
+      if (CS.getType(expr->getSubExpr())->getAs<PackExpansionType>()) {
+        return TupleType::get({CS.getType(expr->getSubExpr())},
+                              CS.getASTContext());
+      }
+
       if (auto favoredTy = CS.getFavoredType(expr->getSubExpr())) {
         CS.setFavoredType(expr, favoredTy);
       }
@@ -2874,7 +2881,19 @@ namespace {
     }
 
     Type visitPackExpansionExpr(PackExpansionExpr *expr) {
-      llvm_unreachable("not implemented for PackExpansionExpr");
+      for (auto *binding : expr->getBindings()) {
+        auto type = visit(binding);
+        CS.setType(binding, type);
+      }
+
+      auto patternTy = CS.getType(expr->getPatternExpr());
+
+      // FIXME: Use a ShapeOf constraint here.
+      auto *declRef = dyn_cast<DeclRefExpr>(expr->getBindings().front());
+      auto *decl = dyn_cast<VarDecl>(declRef->getDecl());
+      auto shapeType = decl->getType()->getAs<PackExpansionType>()->getCountType();
+
+      return PackExpansionType::get(patternTy, shapeType);
     }
 
     Type visitDynamicTypeExpr(DynamicTypeExpr *expr) {
@@ -2887,7 +2906,6 @@ namespace {
     }
 
     Type visitOpaqueValueExpr(OpaqueValueExpr *expr) {
-      assert(expr->isPlaceholder() && "Already type checked");
       return expr->getType();
     }
 

lib/Sema/PreCheckExpr.cpp

@@ -414,6 +414,50 @@ static bool exprLooksLikeAType(Expr *expr) {
       getCompositionExpr(expr);
 }
 
+static Expr *getPackExpansion(ASTContext &ctx, Expr *expr, SourceLoc opLoc) {
+  struct PackReferenceFinder : public ASTWalker {
+    ASTContext &ctx;
+    llvm::SmallVector<OpaqueValueExpr *, 2> opaqueValues;
+    llvm::SmallVector<Expr *, 2> bindings;
+
+    PackReferenceFinder(ASTContext &ctx) : ctx(ctx) {}
+
+    virtual PreWalkResult<Expr *> walkToExprPre(Expr *E) override {
+      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();
+
+          // FIXME: The OpaqueValueExpr should use the opened element
+          // type of the pattern.
+          auto patternType = expansionType->getPatternType();
+          auto *opaqueValue = new (ctx) OpaqueValueExpr(sourceRange,
+                                                        patternType);
+          opaqueValues.push_back(opaqueValue);
+          bindings.push_back(declRef);
+          return Action::Continue(opaqueValue);
+        }
+      }
+
+      return Action::Continue(E);
+    }
+  } packReferenceFinder(ctx);
+
+  auto *pattern = expr->walk(packReferenceFinder);
+
+  if (!packReferenceFinder.bindings.empty()) {
+    return PackExpansionExpr::create(ctx, pattern,
+                                     packReferenceFinder.opaqueValues,
+                                     packReferenceFinder.bindings,
+                                     opLoc);
+  }
+
+  return nullptr;
+}
+
 /// Bind an UnresolvedDeclRefExpr by performing name lookup and
 /// returning the resultant expression. Context is the DeclContext used
 /// for the lookup.
@@ -1306,6 +1350,18 @@ namespace {
         return Action::Continue(result);
       }
 
+      // Rewrite postfix unary '...' expressions containing pack
+      // references to PackExpansionExpr.
+      if (auto *postfixExpr = dyn_cast<PostfixUnaryExpr>(expr)) {
+        auto *op = dyn_cast<OverloadedDeclRefExpr>(postfixExpr->getFn());
+        if (op && op->getDecls()[0]->getBaseName().getIdentifier().isExpansionOperator()) {
+          auto *operand = postfixExpr->getOperand();
+          if (auto *expansion = getPackExpansion(Ctx, operand, op->getLoc())) {
+            return Action::Continue(expansion);
+          }
+        }
+      }
+
       // Type check the type parameters in an UnresolvedSpecializeExpr.
       if (auto *us = dyn_cast<UnresolvedSpecializeExpr>(expr)) {
         if (auto *typeExpr = simplifyUnresolvedSpecializeExpr(us))

test/Constraints/pack-expansion-expressions.swift

@@ -0,0 +1,17 @@
+// RUN: %target-typecheck-verify-swift -enable-experimental-variadic-generics
+
+func tuplify<T...>(_ t: T...) -> (T...) {
+  return (t...)
+}
+
+func prepend<First, Rest...>(value: First, to rest: Rest...) -> (First, Rest...) {
+  return (value, rest...)
+}
+
+func concatenate<T..., U...>(_ first: T..., with second: U...) -> ((T, U)...) {
+  return ((first, second)...)
+}
+
+func zip<T..., U...>(_ first: T..., with second: U...) -> ((T, U)...) {
+  return ((first, second)...)
+}