AST: Refactor printing of generic types a bit

Author: slavapestov

include/swift/AST/Types.h

@@ -2081,7 +2081,7 @@ class TypeAliasType final
   /// this type references.
   ArrayRef<Type> getDirectGenericArgs() const;
 
-  PackType *getExpandedGenericArgsPack();
+  SmallVector<Type, 2> getExpandedGenericArgs();
 
   // Support for FoldingSet.
   void Profile(llvm::FoldingSetNodeID &id) const;
@@ -2562,7 +2562,7 @@ class BoundGenericType : public NominalOrBoundGenericNominalType,
     return {getTrailingObjectsPointer(), Bits.BoundGenericType.GenericArgCount};
   }
 
-  PackType *getExpandedGenericArgsPack();
+  SmallVector<Type, 2> getExpandedGenericArgs();
 
   void Profile(llvm::FoldingSetNodeID &ID) {
     Profile(ID, getDecl(), getParent(), getGenericArgs());
@@ -6820,15 +6820,15 @@ class PackType final : public TypeBase, public llvm::FoldingSetNode,
   /// Creates a pack from the types in \p elements.
   static PackType *get(const ASTContext &C, ArrayRef<Type> elements);
 
-  static PackType *get(const ASTContext &C,
-                       TypeArrayView<GenericTypeParamType> params,
-                       ArrayRef<Type> args);
-
   /// Given a type T, which must be a pack parameter, a member type
   /// of a pack parameter, or a pack archetype, construct the type
   /// Pack{repeat each T}.
   static PackType *getSingletonPackExpansion(Type packParameter);
 
+  static SmallVector<Type, 2> getExpandedGenericArgs(
+      TypeArrayView<GenericTypeParamType> params,
+      ArrayRef<Type> args);
+
 public:
   /// Retrieves the number of elements in this pack.
   unsigned getNumElements() const { return Bits.PackType.Count; }

lib/AST/ASTPrinter.cpp

@@ -5590,9 +5590,9 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
   Optional<llvm::DenseMap<const clang::Module *, ModuleDecl *>>
       VisibleClangModules;
 
-  void printGenericArgs(PackType *flatArgs) {
+  void printGenericArgs(ArrayRef<Type> flatArgs) {
     Printer << "<";
-    interleave(flatArgs->getElementTypes(),
+    interleave(flatArgs,
                [&](Type arg) { visit(arg); },
                [&] { Printer << ", "; });
     Printer << ">";
@@ -5601,7 +5601,7 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
   void printGenericArgs(ASTContext &ctx,
                         TypeArrayView<GenericTypeParamType> params,
                         ArrayRef<Type> args) {
-    printGenericArgs(PackType::get(ctx, params, args));
+    printGenericArgs(PackType::getExpandedGenericArgs(params, args));
   }
 
   /// Helper function for printing a type that is embedded within a larger type.
@@ -5952,7 +5952,7 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
 
     auto *typeAliasDecl = T->getDecl();
     if (typeAliasDecl->isGeneric()) {
-      printGenericArgs(T->getExpandedGenericArgsPack());
+      printGenericArgs(T->getExpandedGenericArgs());
     }
   }
 
@@ -6057,7 +6057,7 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
     }
     printQualifiedType(T);
 
-    printGenericArgs(T->getExpandedGenericArgsPack());
+    printGenericArgs(T->getExpandedGenericArgs());
   }
 
   void visitParentType(Type T) {

lib/AST/ParameterPack.cpp

@@ -40,7 +40,9 @@ struct PackTypeParameterCollector: TypeWalker {
       if (auto parentType = boundGenericType->getParent())
         parentType.walk(*this);
 
-      Type(boundGenericType->getExpandedGenericArgsPack()).walk(*this);
+      for (auto type : boundGenericType->getExpandedGenericArgs())
+        type.walk(*this);
+
       return Action::SkipChildren;
     }
 
@@ -49,7 +51,9 @@ struct PackTypeParameterCollector: TypeWalker {
         if (auto parentType = typeAliasType->getParent())
           parentType.walk(*this);
 
-        Type(typeAliasType->getExpandedGenericArgsPack()).walk(*this);
+        for (auto type : typeAliasType->getExpandedGenericArgs())
+          type.walk(*this);
+
         return Action::SkipChildren;
       }
     }
@@ -244,7 +248,7 @@ unsigned ParameterList::getOrigParamIndex(SubstitutionMap subMap,
 }
 
 /// <T...> Foo<T, Pack{Int, String}> => Pack{T..., Int, String}
-PackType *BoundGenericType::getExpandedGenericArgsPack() {
+SmallVector<Type, 2> BoundGenericType::getExpandedGenericArgs() {
   // It would be nicer to use genericSig.getInnermostGenericParams() here,
   // but that triggers a request cycle if we're in the middle of computing
   // the generic signature already.
@@ -253,26 +257,26 @@ PackType *BoundGenericType::getExpandedGenericArgsPack() {
     params.push_back(paramDecl->getDeclaredInterfaceType());
   }
 
-  return PackType::get(getASTContext(),
+  return PackType::getExpandedGenericArgs(
                        TypeArrayView<GenericTypeParamType>(params),
                        getGenericArgs());
 }
 
 /// <T...> Foo<T, Pack{Int, String}> => Pack{T..., Int, String}
-PackType *TypeAliasType::getExpandedGenericArgsPack() {
+SmallVector<Type, 2> TypeAliasType::getExpandedGenericArgs() {
   if (!getDecl()->isGeneric())
-    return nullptr;
+    return SmallVector<Type, 2>();
 
   auto genericSig = getGenericSignature();
-  return PackType::get(getASTContext(),
+  return PackType::getExpandedGenericArgs(
                        genericSig.getInnermostGenericParams(),
                        getDirectGenericArgs());
 }
 
-/// <T...> Pack{T, Pack{Int, String}} => Pack{T..., Int, String}
-PackType *PackType::get(const ASTContext &C,
-                        TypeArrayView<GenericTypeParamType> params,
-                        ArrayRef<Type> args) {
+/// <T...> Pack{T, Pack{Int, String}} => {T..., Int, String}
+SmallVector<Type, 2>
+PackType::getExpandedGenericArgs(TypeArrayView<GenericTypeParamType> params,
+                                 ArrayRef<Type> args) {
   SmallVector<Type, 2> wrappedArgs;
 
   assert(params.size() == args.size());
@@ -288,7 +292,7 @@ PackType *PackType::get(const ASTContext &C,
     wrappedArgs.push_back(arg);
   }
 
-  return get(C, wrappedArgs);
+  return wrappedArgs;
 }
 
 PackType *PackType::getSingletonPackExpansion(Type param) {
@@ -347,7 +351,7 @@ static CanPackType getApproximateFormalPackType(const ASTContext &ctx,
                                                 Collection loweredEltTypes) {
   // Build an array of formal element types, but be lazy about it:
   // use the original array unless we see an element type that doesn't
-  // work as a legal format type.
+  // work as a legal formal type.
   Optional<SmallVector<CanType, 4>> formalEltTypes;
   for (auto i : indices(loweredEltTypes)) {
     auto loweredEltType = loweredEltTypes[i];