Model PackExpansion Types

A PackExpansionType is the interface type of the explicit expansion of a
corresponding set of variadic generic parameters.
Pack expansions are spelled as single-element tuples with a single variadic
component in most contexts except functions where they are allowed to appear without parentheses to match normal variadic declaration syntax.

```
func expand<T...>(_ xs: T...) -> (T...)
                        ~~~~     ~~~~~~
```

A pack expansion type comes equipped with a pattern type spelled before
the ellipses - `T` in the examples above. This pattern type is the subject
of the expansion of the pack that is tripped when its variadic generic
parameter is substituted for a `PackType`.

Author: CodaFi

include/swift/AST/TypeDifferenceVisitor.h

@@ -135,6 +135,12 @@ class CanTypeDifferenceVisitor : public CanTypePairVisitor<Impl, bool> {
                                type1->getElementTypes(),
                                type2->getElementTypes());
   }
+
+  bool visitPackExpansionType(CanPackExpansionType type1,
+                              CanPackExpansionType type2) {
+    return asImpl().visit(type1.getPatternType(), type2.getPatternType());
+  }
+
   bool visitTupleType(CanTupleType type1, CanTupleType type2) {
     return visitComponentArray(type1, type2,
                                type1->getElements(), type2->getElements());

include/swift/AST/TypeMatcher.h

@@ -166,6 +166,19 @@ class TypeMatcher {
       // Pack/non-pack mismatch.
       return mismatch(firstTuple.getPointer(), secondType, sugaredFirstType);
     }
+
+    bool visitPackExpansionType(CanPackExpansionType firstPE, Type secondType,
+                                Type sugaredFirstType) {
+      if (auto secondInOut = secondType->getAs<PackExpansionType>()) {
+        return this->visit(firstPE.getPatternType(),
+                           secondInOut->getPatternType(),
+                           sugaredFirstType->castTo<PackExpansionType>()
+                             ->getPatternType());
+      }
+
+      return mismatch(firstPE.getPointer(), secondType, sugaredFirstType);
+    }
+
     bool visitReferenceStorageType(CanReferenceStorageType firstStorage,
                                    Type secondType, Type sugaredFirstType) {
       auto _secondStorage = secondType->getCanonicalType();

include/swift/AST/TypeNodes.def

@@ -166,6 +166,7 @@ TYPE(Existential, Type)
 TYPE(LValue, Type)
 TYPE(InOut, Type)
 TYPE(Pack, Type)
+TYPE(PackExpansion, Type)
 UNCHECKED_TYPE(TypeVariable, Type)
 ABSTRACT_SUGARED_TYPE(Sugar, Type)
   SUGARED_TYPE(Paren, SugarType)

include/swift/AST/Types.h

@@ -6202,6 +6202,63 @@ BEGIN_CAN_TYPE_WRAPPER(PackType, Type)
   }
 END_CAN_TYPE_WRAPPER(PackType, Type)
 
+/// PackExpansionType - The interface type of the explicit expansion of a
+/// corresponding set of variadic generic parameters.
+///
+/// Pack expansions are spelled as single-element tuples with a single variadic
+/// component in most contexts except functions where they are allowed to appear
+/// without parentheses to match normal variadic declaration syntax.
+///
+/// \code
+/// func expand<T...>(_ xs: T...) -> (T...)
+///                         ~~~~     ~~~~~~
+/// \endcode
+///
+/// A pack expansion type comes equipped with a pattern type spelled before
+/// the ellipses - \c T in the examples above. This pattern type is the subject
+/// of the expansion of the pack that is tripped when its variadic generic
+/// parameter is substituted for a \c PackType.
+class PackExpansionType : public TypeBase, public llvm::FoldingSetNode {
+  friend class ASTContext;
+
+  Type patternType;
+
+public:
+  /// Create a pack expansion type from the given pattern type.
+  ///
+  /// It is not required that the pattern type actually contain a reference to
+  /// a variadic generic parameter.
+  static PackExpansionType *get(Type pattern);
+
+public:
+  /// Retrieves the pattern type of this pack expansion.
+  Type getPatternType() const { return patternType; }
+
+public:
+  void Profile(llvm::FoldingSetNodeID &ID) {
+    Profile(ID, getPatternType());
+  }
+
+  static void Profile(llvm::FoldingSetNodeID &ID, Type patternType);
+
+  // Implement isa/cast/dyncast/etc.
+  static bool classof(const TypeBase *T) {
+    return T->getKind() == TypeKind::PackExpansion;
+  }
+
+private:
+  PackExpansionType(Type patternType, const ASTContext *CanCtx)
+    : TypeBase(TypeKind::PackExpansion, CanCtx,
+               patternType->getRecursiveProperties()), patternType(patternType) {
+      assert(patternType);
+    }
+};
+BEGIN_CAN_TYPE_WRAPPER(PackExpansionType, Type)
+  CanType getPatternType() const {
+    return CanType(getPointer()->getPatternType());
+  }
+END_CAN_TYPE_WRAPPER(PackExpansionType, Type)
+
 /// getASTContext - Return the ASTContext that this type belongs to.
 inline ASTContext &TypeBase::getASTContext() {
   // If this type is canonical, it has the ASTContext in it.

lib/AST/ASTMangler.cpp

@@ -1170,6 +1170,7 @@ void ASTMangler::appendType(Type type, GenericSignature sig,
     }
 
     case TypeKind::Pack:
+    case TypeKind::PackExpansion:
       assert(DWARFMangling && "sugared types are only legal for the debugger");
       appendOperator("XSP");
       llvm_unreachable("Unimplemented");

lib/AST/ASTPrinter.cpp

@@ -4639,6 +4639,12 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
     Printer << ")";
   }
 
+  void visitPackExpansionType(PackExpansionType *T) {
+    Printer << "(";
+    visit(T->getPatternType());
+    Printer << "..." << ")";
+  }
+
   void visitTupleType(TupleType *T) {
     Printer.callPrintStructurePre(PrintStructureKind::TupleType);
     SWIFT_DEFER { Printer.printStructurePost(PrintStructureKind::TupleType); };

lib/AST/TypeWalker.cpp

@@ -56,6 +56,10 @@ class Traversal : public TypeVisitor<Traversal, bool>
     return false;
   }
 
+  bool visitPackExpansionType(PackExpansionType *ty) {
+    return doIt(ty->getPatternType());
+  }
+
   bool visitParenType(ParenType *ty) {
     return doIt(ty->getUnderlyingType());
   }

lib/IRGen/Fulfillment.cpp

@@ -53,6 +53,7 @@ static bool isLeafTypeMetadata(CanType type) {
   case TypeKind::LValue:
   case TypeKind::InOut:
   case TypeKind::DynamicSelf:
+  case TypeKind::PackExpansion:
     llvm_unreachable("these types do not have metadata");
 
   // All the builtin types are leaves.
@@ -79,6 +80,7 @@ static bool isLeafTypeMetadata(CanType type) {
 
   case TypeKind::Pack:
     return cast<PackType>(type)->getNumElements() == 0;
+
   // Nominal types might have generic parents.
   case TypeKind::Class:
   case TypeKind::Enum:

lib/IRGen/GenType.cpp

@@ -2199,6 +2199,7 @@ const TypeInfo *TypeConverter::convertType(CanType ty) {
   case TypeKind::SILToken:
     llvm_unreachable("should not be asking for representation of a SILToken");
   case TypeKind::Pack:
+  case TypeKind::PackExpansion:
     llvm_unreachable("Unimplemented!");
   }
   }

lib/IRGen/IRGenDebugInfo.cpp

@@ -1508,6 +1508,7 @@ class IRGenDebugInfoImpl : public IRGenDebugInfo {
     }
 
     case TypeKind::Pack:
+    case TypeKind::PackExpansion:
       llvm_unreachable("Unimplemented!");
 
     case TypeKind::Tuple: {