Model Pack Expressions and Pack Reifications

Pack expressions take a series of argument values and bundle them together as a pack - much like how a tuple expression bundles argument expressions into a tuple.

Pack reification represents the operation that converts packs to tuples/scalar types in the AST. This is important since we want pack types in return positions to resolve to tuples contextually.

Author: CodaFi

include/swift/AST/Expr.h

@@ -348,6 +348,10 @@ class alignas(8) Expr : public ASTAllocated<Expr> {
     IsPlaceholder : 1
   );
 
+  SWIFT_INLINE_BITFIELD_FULL(PackExpr, Expr, 32,
+    : NumPadBits,
+    NumElements : 32
+  );
   } Bits;
 
 private:
@@ -3314,6 +3318,18 @@ class BridgeToObjCExpr : public ImplicitConversionExpr {
   }
 };
 
+/// ReifyPackExpr - Drop the pack structure and reify it either as a tuple or
+/// single value.
+class ReifyPackExpr : public ImplicitConversionExpr {
+public:
+  ReifyPackExpr(Expr *subExpr, Type type)
+    : ImplicitConversionExpr(ExprKind::ReifyPack, subExpr, type) {}
+
+  static bool classof(const Expr *E) {
+    return E->getKind() == ExprKind::ReifyPack;
+  }
+};
+
 /// UnresolvedSpecializeExpr - Represents an explicit specialization using
 /// a type parameter list (e.g. "Vector<Int>") that has not been resolved.
 class UnresolvedSpecializeExpr final : public Expr,
@@ -5758,6 +5774,55 @@ class OneWayExpr : public Expr {
   }
 };
 
+/// An expression node that aggregates a set of heterogeneous arguments into a
+/// parameter pack suitable for passing off to a variadic generic function
+/// argument.
+///
+/// There is no user-visible way to spell a pack expression, they are always
+/// implicitly created at applies. As such, any appearance of pack types outside
+/// of applies are illegal. In general, packs appearing in such positions should
+/// have a \c ReifyPackExpr to convert them to a user-available AST type.
+class PackExpr final : public Expr,
+    private llvm::TrailingObjects<PackExpr, Expr *> {
+  friend TrailingObjects;
+
+  size_t numTrailingObjects() const {
+    return getNumElements();
+  }
+
+  PackExpr(ArrayRef<Expr *> SubExprs, Type Ty);
+
+public:
+  /// Create a pack.
+  static PackExpr *create(ASTContext &ctx, ArrayRef<Expr *> SubExprs, Type Ty);
+
+  /// Create an empty pack.
+  static PackExpr *createEmpty(ASTContext &ctx);
+
+  SourceLoc getLoc() const { return SourceLoc(); }
+  SourceRange getSourceRange() const { return SourceRange(); }
+
+  /// Retrieve the elements of this pack.
+  MutableArrayRef<Expr *> getElements() {
+    return { getTrailingObjects<Expr *>(), getNumElements() };
+  }
+
+  /// Retrieve the elements of this pack.
+  ArrayRef<Expr *> getElements() const {
+    return { getTrailingObjects<Expr *>(), getNumElements() };
+  }
+
+  unsigned getNumElements() const { return Bits.PackExpr.NumElements; }
+
+  Expr *getElement(unsigned i) const {
+    return getElements()[i];
+  }
+  void setElement(unsigned i, Expr *e) {
+    getElements()[i] = e;
+  }
+
+  static bool classof(const Expr *E) { return E->getKind() == ExprKind::Pack; }
+};
 inline bool Expr::isInfixOperator() const {
   return isa<BinaryExpr>(this) || isa<IfExpr>(this) ||
          isa<AssignExpr>(this) || isa<ExplicitCastExpr>(this);

include/swift/AST/ExprNodes.def

@@ -181,7 +181,8 @@ ABSTRACT_EXPR(ImplicitConversion, Expr)
   EXPR(DifferentiableFunctionExtractOriginal, ImplicitConversionExpr)
   EXPR(LinearFunctionExtractOriginal, ImplicitConversionExpr)
   EXPR(LinearToDifferentiableFunction, ImplicitConversionExpr)
-  EXPR_RANGE(ImplicitConversion, Load, LinearToDifferentiableFunction)
+  EXPR(ReifyPack, ImplicitConversionExpr)
+  EXPR_RANGE(ImplicitConversion, Load, ReifyPack)
 ABSTRACT_EXPR(ExplicitCast, Expr)
   ABSTRACT_EXPR(CheckedCast, ExplicitCastExpr)
     EXPR(ForcedCheckedCast, CheckedCastExpr)
@@ -203,7 +204,8 @@ EXPR(KeyPath, Expr)
 UNCHECKED_EXPR(KeyPathDot, Expr)
 UNCHECKED_EXPR(OneWay, Expr)
 EXPR(Tap, Expr)
-LAST_EXPR(Tap)
+EXPR(Pack, Expr)
+LAST_EXPR(Pack)
 
 #undef EXPR_RANGE
 #undef LITERAL_EXPR

include/swift/AST/Types.h

@@ -419,6 +419,13 @@ class alignas(1 << TypeAlignInBits) TypeBase
     Count : 32
   );
 
+  SWIFT_INLINE_BITFIELD_FULL(PackType, TypeBase, 32,
+    : NumPadBits,
+
+    /// The number of elements of the tuple.
+    Count : 32
+  );
+
   SWIFT_INLINE_BITFIELD_FULL(BoundGenericType, TypeBase, 32,
     : NumPadBits,
 

lib/AST/ASTDumper.cpp

@@ -2074,6 +2074,15 @@ class PrintExpr : public ExprVisitor<PrintExpr> {
     }
     PrintWithColorRAII(OS, ParenthesisColor) << ')';
   }
+  void visitPackExpr(PackExpr *E) {
+    printCommon(E, "pack_expr");
+
+    for (unsigned i = 0, e = E->getNumElements(); i != e; ++i) {
+      OS << '\n';
+      printRec(E->getElement(i));
+    }
+    PrintWithColorRAII(OS, ParenthesisColor) << ')';
+  }
   void visitArrayExpr(ArrayExpr *E) {
     printCommon(E, "array_expr");
     PrintWithColorRAII(OS, LiteralValueColor) << " initializer=";
@@ -2220,6 +2229,11 @@ class PrintExpr : public ExprVisitor<PrintExpr> {
     printRec(E->getSubExpr());
     PrintWithColorRAII(OS, ParenthesisColor) << ')';
   }
+  void visitReifyPackExpr(ReifyPackExpr *E) {
+    printCommon(E, "reify_pack") << '\n';
+    printRec(E->getSubExpr());
+    PrintWithColorRAII(OS, ParenthesisColor) << ')';
+  }
   void visitLoadExpr(LoadExpr *E) {
     printCommon(E, "load_expr") << '\n';
     printRec(E->getSubExpr());
@@ -3588,6 +3602,25 @@ namespace {
       PrintWithColorRAII(OS, ParenthesisColor) << ')';
     }
 
+    void visitPackType(PackType *T, StringRef label) {
+      printCommon(label, "pack_type");
+      printField("num_elements", T->getNumElements());
+      Indent += 2;
+      for (Type elt : T->getElementTypes()) {
+        OS.indent(Indent) << "(";
+        printRec(elt);
+        OS << ")";
+      }
+      Indent -= 2;
+      PrintWithColorRAII(OS, ParenthesisColor) << ')';
+    }
+
+    void visitPackExpansionType(PackExpansionType *T, StringRef label) {
+      printCommon(label, "pack_expansion_type");
+      printField("pattern", T->getPatternType());
+      PrintWithColorRAII(OS, ParenthesisColor) << ')';
+    }
+
     void visitParenType(ParenType *T, StringRef label) {
       printCommon(label, "paren_type");
       dumpParameterFlags(T->getParameterFlags());

lib/AST/ASTWalker.cpp

@@ -602,6 +602,16 @@ class Traversal : public ASTVisitor<Traversal, Expr*, Stmt*,
       }
     return E;
   }
+  Expr *visitPackExpr(PackExpr *E) {
+    for (unsigned i = 0, e = E->getNumElements(); i != e; ++i)
+      if (E->getElement(i)) {
+        if (Expr *Elt = doIt(E->getElement(i)))
+          E->setElement(i, Elt);
+        else
+          return nullptr;
+      }
+    return E;
+  }
   Expr *visitSubscriptExpr(SubscriptExpr *E) {
     if (Expr *Base = doIt(E->getBase()))
       E->setBase(Base);

lib/AST/Expr.cpp

@@ -397,6 +397,7 @@ ConcreteDeclRef Expr::getReferencedDecl(bool stopAtParenExpr) const {
   PASS_THROUGH_REFERENCE(BridgeFromObjC, getSubExpr);
   PASS_THROUGH_REFERENCE(ConditionalBridgeFromObjC, getSubExpr);
   PASS_THROUGH_REFERENCE(UnderlyingToOpaque, getSubExpr);
+  PASS_THROUGH_REFERENCE(ReifyPack, getSubExpr);
   NO_REFERENCE(Coerce);
   NO_REFERENCE(ForcedCheckedCast);
   NO_REFERENCE(ConditionalCheckedCast);
@@ -414,6 +415,7 @@ ConcreteDeclRef Expr::getReferencedDecl(bool stopAtParenExpr) const {
   NO_REFERENCE(KeyPathDot);
   PASS_THROUGH_REFERENCE(OneWay, getSubExpr);
   NO_REFERENCE(Tap);
+  NO_REFERENCE(Pack);
 
 #undef SIMPLE_REFERENCE
 #undef NO_REFERENCE
@@ -723,6 +725,7 @@ bool Expr::canAppendPostfixExpression(bool appendingPostfixOperator) const {
   case ExprKind::BridgeFromObjC:
   case ExprKind::BridgeToObjC:
   case ExprKind::UnderlyingToOpaque:
+  case ExprKind::ReifyPack:
     // Implicit conversion nodes have no syntax of their own; defer to the
     // subexpression.
     return cast<ImplicitConversionExpr>(this)->getSubExpr()
@@ -740,6 +743,7 @@ bool Expr::canAppendPostfixExpression(bool appendingPostfixOperator) const {
   case ExprKind::UnresolvedPattern:
   case ExprKind::EditorPlaceholder:
   case ExprKind::KeyPathDot:
+  case ExprKind::Pack:
     return false;
 
   case ExprKind::Tap:
@@ -906,6 +910,8 @@ bool Expr::isValidParentOfTypeExpr(Expr *typeExpr) const {
   case ExprKind::KeyPathDot:
   case ExprKind::OneWay:
   case ExprKind::Tap:
+  case ExprKind::ReifyPack:
+  case ExprKind::Pack:
     return false;
   }
 
@@ -1116,6 +1122,21 @@ InOutExpr::InOutExpr(SourceLoc operLoc, Expr *subExpr, Type baseType,
          baseType.isNull() ? baseType : InOutType::get(baseType)),
     SubExpr(subExpr), OperLoc(operLoc) {}
 
+VarargExpansionExpr *VarargExpansionExpr::createParamExpansion(ASTContext &ctx, Expr *E) {
+  assert(E->getType() && "Expansion must have fully-resolved type!");
+  return new (ctx) VarargExpansionExpr(E, /*implicit*/ true, E->getType());
+}
+
+VarargExpansionExpr *VarargExpansionExpr::createArrayExpansion(ASTContext &ctx, ArrayExpr *AE) {
+  assert(AE->getType() && "Expansion must have fully-resolved type!");
+  return new (ctx) VarargExpansionExpr(AE, /*implicit*/ true, AE->getType());
+}
+
+VarargExpansionExpr *VarargExpansionExpr::createTupleExpansion(ASTContext &ctx, TupleExpr *TE) {
+  assert(TE->getType() && "Expansion must have fully-resolved type!");
+  return new (ctx) VarargExpansionExpr(TE, /*implicit*/ true, TE->getType());
+}
+
 SequenceExpr *SequenceExpr::create(ASTContext &ctx, ArrayRef<Expr*> elements) {
   assert(elements.size() & 1 && "even number of elements in sequence");
   size_t bytes = totalSizeToAlloc<Expr *>(elements.size());
@@ -2250,6 +2271,30 @@ RegexLiteralExpr::createParsed(ASTContext &ctx, SourceLoc loc,
   return new (ctx) RegexLiteralExpr(loc, regexText, /*implicit*/ false);
 }
 
+PackExpr::PackExpr(ArrayRef<Expr *> SubExprs, Type Ty)
+  : Expr(ExprKind::Pack, /*implicit*/ true, Ty) {
+  Bits.PackExpr.NumElements = SubExprs.size();
+
+  // Copy elements.
+  std::uninitialized_copy(SubExprs.begin(), SubExprs.end(),
+                          getTrailingObjects<Expr *>());
+}
+
+PackExpr *PackExpr::create(ASTContext &ctx,
+                           ArrayRef<Expr *> SubExprs,
+                           Type Ty) {
+  assert(Ty->castTo<PackType>());
+
+  size_t size =
+      totalSizeToAlloc<Expr *>(SubExprs.size());
+  void *mem = ctx.Allocate(size, alignof(PackExpr));
+  return new (mem) PackExpr(SubExprs, Ty);
+}
+
+PackExpr *PackExpr::createEmpty(ASTContext &ctx) {
+  return create(ctx, {}, PackType::getEmpty(ctx));
+}
+
 void swift::simple_display(llvm::raw_ostream &out, const ClosureExpr *CE) {
   if (!CE) {
     out << "(null)";

lib/AST/Type.cpp

@@ -231,6 +231,7 @@ bool CanType::isReferenceTypeImpl(CanType type, const GenericSignatureImpl *sig,
   case TypeKind::BoundGenericStruct:
   case TypeKind::SILToken:
   case TypeKind::Pack:
+  case TypeKind::PackExpansion:
 #define REF_STORAGE(Name, ...) \
   case TypeKind::Name##Storage:
 #include "swift/AST/ReferenceStorage.def"

lib/SILGen/SILGenExpr.cpp

@@ -436,6 +436,7 @@ namespace {
              CollectionUpcastConversionExpr *E,
              SGFContext C);
     RValue visitBridgeToObjCExpr(BridgeToObjCExpr *E, SGFContext C);
+    RValue visitReifyPackExpr(ReifyPackExpr *E, SGFContext C);
     RValue visitBridgeFromObjCExpr(BridgeFromObjCExpr *E, SGFContext C);
     RValue visitConditionalBridgeFromObjCExpr(ConditionalBridgeFromObjCExpr *E,
                                               SGFContext C);
@@ -460,6 +461,7 @@ namespace {
     RValue visitCoerceExpr(CoerceExpr *E, SGFContext C);
     RValue visitUnderlyingToOpaqueExpr(UnderlyingToOpaqueExpr *E, SGFContext C);
     RValue visitTupleExpr(TupleExpr *E, SGFContext C);
+    RValue visitPackExpr(PackExpr *E, SGFContext C);
     RValue visitMemberRefExpr(MemberRefExpr *E, SGFContext C);
     RValue visitDynamicMemberRefExpr(DynamicMemberRefExpr *E, SGFContext C);
     RValue visitDotSyntaxBaseIgnoredExpr(DotSyntaxBaseIgnoredExpr *E,
@@ -1488,6 +1490,11 @@ RValueEmitter::visitBridgeToObjCExpr(BridgeToObjCExpr *E, SGFContext C) {
   return RValue(SGF, E, result);
 }
 
+RValue
+RValueEmitter::visitReifyPackExpr(ReifyPackExpr *E, SGFContext C) {
+  llvm_unreachable("Unimplemented!");
+}
+
 RValue RValueEmitter::visitArchetypeToSuperExpr(ArchetypeToSuperExpr *E,
                                                 SGFContext C) {
   ManagedValue archetype = SGF.emitRValueAsSingleValue(E->getSubExpr());
@@ -2183,6 +2190,10 @@ RValue RValueEmitter::visitTupleExpr(TupleExpr *E, SGFContext C) {
   return result;
 }
 
+RValue RValueEmitter::visitPackExpr(PackExpr *E, SGFContext C) {
+  llvm_unreachable("Unimplemented!");
+}
+
 RValue RValueEmitter::visitMemberRefExpr(MemberRefExpr *e,
                                          SGFContext resultCtx) {
   assert(!e->getType()->is<LValueType>() &&

lib/Sema/CSGen.cpp

@@ -1720,6 +1720,18 @@ namespace {
       return TupleType::get(elements, CS.getASTContext());
     }
 
+    Type visitPackExpr(PackExpr *expr) {
+      // The type of a pack expression is simply a pack of the types of
+      // its subexpressions.
+      SmallVector<Type, 4> elements;
+      elements.reserve(expr->getNumElements());
+      for (unsigned i = 0, n = expr->getNumElements(); i != n; ++i) {
+        elements.emplace_back(CS.getType(expr->getElement(i)));
+      }
+
+      return PackType::get(CS.getASTContext(), elements);
+    }
+
     Type visitSubscriptExpr(SubscriptExpr *expr) {
       ValueDecl *decl = nullptr;
       if (expr->hasDecl()) {

lib/Serialization/Serialization.cpp

@@ -4386,6 +4386,12 @@ class Serializer::TypeSerializer : public TypeVisitor<TypeSerializer> {
     llvm_unreachable("Unimplemented!");
   }
 
+  void visitPackExpansionType(const PackExpansionType *pack) {
+    using namespace decls_block;
+//    serializeSimpleWrapper<ParenTypeLayout>(parenTy->getUnderlyingType());
+    llvm_unreachable("Unimplemented!");
+  }
+
   void visitParenType(const ParenType *parenTy) {
     using namespace decls_block;
     assert(parenTy->getParameterFlags().isNone());