Fixes for printing variadic generic types

include/swift/AST/PackExpansionMatcher.h

@@ -27,17 +27,18 @@ namespace swift {
 
 class ASTContext;
 
-/// The result of a match. If one of lhs or rhs is a pack expansion type,
-/// the other one is a pack type.
+/// The result of a match. An important invariant is that either both types
+/// are PackExpansionTypes, or both types are scalars. In particular, any
+/// PackTypes are always wrapped in a PackExpansionType.
 struct MatchedPair {
   Type lhs;
   Type rhs;
 
-  // An index into the original left-hand side.
-  unsigned idx;
+  unsigned lhsIdx;
+  unsigned rhsIdx;
 
-  MatchedPair(Type lhs, Type rhs, unsigned idx)
-    : lhs(lhs), rhs(rhs), idx(idx) {}
+  MatchedPair(Type lhs, Type rhs, unsigned lhsIdx, unsigned rhsIdx)
+    : lhs(lhs), rhs(rhs), lhsIdx(lhsIdx), rhsIdx(rhsIdx) {}
 };
 
 /// Performs a structural match of two lists of tuple elements. The invariant

include/swift/AST/TypeRepr.h

@@ -366,7 +366,6 @@ class GenericIdentTypeRepr final : public ComponentIdentTypeRepr,
     : ComponentIdentTypeRepr(TypeReprKind::GenericIdent, Loc, Id),
       AngleBrackets(AngleBrackets) {
     Bits.GenericIdentTypeRepr.NumGenericArgs = GenericArgs.size();
-    assert(!GenericArgs.empty());
 #ifndef NDEBUG
     for (auto arg : GenericArgs)
       assert(arg != nullptr);

include/swift/AST/Types.h

@@ -71,6 +71,7 @@ class Identifier;
 class InOutType;
 class OpaqueTypeDecl;
 class OpenedArchetypeType;
+class PackType;
 class PlaceholderTypeRepr;
 enum class ReferenceCounting : uint8_t;
 enum class ResilienceExpansion : unsigned;
@@ -2002,6 +2003,8 @@ class TypeAliasType final
   /// this type references.
   ArrayRef<Type> getDirectGenericArgs() const;
 
+  PackType *getExpandedGenericArgsPack();
+
   // Support for FoldingSet.
   void Profile(llvm::FoldingSetNodeID &id) const;
 
@@ -2420,6 +2423,8 @@ class BoundGenericType : public NominalOrBoundGenericNominalType,
     return {getTrailingObjectsPointer(), Bits.BoundGenericType.GenericArgCount};
   }
 
+  PackType *getExpandedGenericArgsPack();
+
   void Profile(llvm::FoldingSetNodeID &ID) {
     Profile(ID, getDecl(), getParent(), getGenericArgs());
   }
@@ -6478,6 +6483,10 @@ 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);
+
 public:
   /// Retrieves the number of elements in this pack.
   unsigned getNumElements() const { return Bits.PackType.Count; }

lib/AST/ASTContext.cpp

@@ -3258,11 +3258,6 @@ PackType *PackType::get(const ASTContext &C, ArrayRef<Type> elements) {
   RecursiveTypeProperties properties;
   bool isCanonical = true;
   for (Type eltTy : elements) {
-    assert(!eltTy->isTypeParameter() ||
-           !eltTy->getRootGenericParam()->isParameterPack() &&
-           "Pack type parameter outside of a pack expansion");
-    assert(!eltTy->is<PackArchetypeType>() &&
-           "Pack type archetype outside of a pack expansion");
     assert(!eltTy->is<PackType>() &&
            "Cannot have pack directly inside another pack");
 

lib/AST/ASTPrinter.cpp

@@ -5282,15 +5282,20 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
   Optional<llvm::DenseMap<const clang::Module *, ModuleDecl *>>
       VisibleClangModules;
 
-  void printGenericArgs(ArrayRef<Type> Args) {
-    if (Args.empty())
-      return;
-
+  void printGenericArgs(PackType *flatArgs) {
     Printer << "<";
-    interleave(Args, [&](Type Arg) { visit(Arg); }, [&] { Printer << ", "; });
+    interleave(flatArgs->getElementTypes(),
+               [&](Type arg) { visit(arg); },
+               [&] { Printer << ", "; });
     Printer << ">";
   }
 
+  void printGenericArgs(ASTContext &ctx,
+                        TypeArrayView<GenericTypeParamType> params,
+                        ArrayRef<Type> args) {
+    printGenericArgs(PackType::get(ctx, params, args));
+  }
+
   /// Helper function for printing a type that is embedded within a larger type.
   ///
   /// This is necessary whenever the inner type may not normally be represented
@@ -5626,7 +5631,11 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
     }
 
     printQualifiedType(T);
-    printGenericArgs(T->getDirectGenericArgs());
+
+    auto *typeAliasDecl = T->getDecl();
+    if (typeAliasDecl->isGeneric()) {
+      printGenericArgs(T->getExpandedGenericArgsPack());
+    }
   }
 
   void visitParenType(ParenType *T) {
@@ -5711,7 +5720,8 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
       }
     }
     printQualifiedType(T);
-    printGenericArgs(T->getGenericArgs());
+
+    printGenericArgs(T->getExpandedGenericArgsPack());
   }
 
   void visitParentType(Type T) {
@@ -6525,6 +6535,11 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
       return false;
     };
 
+    OpaqueTypeDecl *decl = T->getDecl();
+    auto *namingDecl = decl->getNamingDecl();
+    auto genericSig = namingDecl->getInnermostDeclContext()
+          ->getGenericSignatureOfContext();
+
     switch (Options.OpaqueReturnTypePrinting) {
     case PrintOptions::OpaqueReturnTypePrintingMode::WithOpaqueKeyword:
       if (printNamedOpaque())
@@ -6542,8 +6557,6 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
 
       // Opaque archetype substitutions are always canonical, so re-sugar the
       // constraint type using the owning declaration's generic parameter names.
-      auto genericSig = T->getDecl()->getNamingDecl()->getInnermostDeclContext()
-          ->getGenericSignatureOfContext();
       if (genericSig)
         constraint = genericSig->getSugaredType(constraint);
 
@@ -6556,7 +6569,6 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
       // turn this back into a reference to the naming decl for the opaque
       // type.
       Printer << "@_opaqueReturnTypeOf(";
-      OpaqueTypeDecl *decl = T->getDecl();
 
       Printer.printEscapedStringLiteral(
                                    decl->getOpaqueReturnTypeIdentifier().str());
@@ -6570,22 +6582,24 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
       // attribute to apply to, but the attribute alone references the opaque
       // type.
       Printer << ") __";
-      printGenericArgs(T->getSubstitutions().getReplacementTypes());
+
+      if (genericSig) {
+        printGenericArgs(decl->getASTContext(),
+                         genericSig.getGenericParams(),
+                         T->getSubstitutions().getReplacementTypes());
+      }
       return;
     }
     case PrintOptions::OpaqueReturnTypePrintingMode::Description: {
       // TODO(opaque): present opaque types with user-facing syntax. we should
       // probably print this as `some P` and record the fact that we printed that
       // so that diagnostics can add followup notes.
-      Printer << "(return type of " << T->getDecl()->getNamingDecl()->printRef();
+      Printer << "(return type of " << namingDecl->printRef();
       Printer << ')';
-      if (!T->getSubstitutions().empty()) {
-        Printer << '<';
-        auto replacements = T->getSubstitutions().getReplacementTypes();
-        llvm::interleave(
-            replacements.begin(), replacements.end(), [&](Type t) { visit(t); },
-            [&] { Printer << ", "; });
-        Printer << '>';
+      if (genericSig) {
+        printGenericArgs(decl->getASTContext(),
+                         genericSig.getGenericParams(),
+                         T->getSubstitutions().getReplacementTypes());
       }
       return;
     }