ASTPrinter: Fix printing variadic BoundGenericTypes

Author: slavapestov

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;
     }

test/ModuleInterface/pack_expansion_type.swift

@@ -12,5 +12,29 @@ public func variadicFunction<T..., U...>(t: T..., u: U...) -> ((T, U)...) {}
 public struct VariadicType<T...> {
   // CHECK: public func variadicMethod<U...>(t: T..., u: U...) -> ((T, U)...) where ((T, U)...) : Any
   public func variadicMethod<U...>(t: T..., u: U...) -> ((T, U)...) {}
+
+  // CHECK: public func returnsSelf() -> PackExpansionType.VariadicType<T...>
+  public func returnsSelf() -> Self {}
 }
 // CHECK: }
+
+// CHECK: public func returnsVariadicType() -> PackExpansionType.VariadicType<>
+public func returnsVariadicType() -> VariadicType< > {}
+
+// CHECK: public func returnsVariadicType() -> PackExpansionType.VariadicType<Swift.Int, Swift.String, Swift.Float>
+public func returnsVariadicType() -> VariadicType<Int, String, Float> {}
+
+// CHECK: public func returnsVariadicType<T...>() -> PackExpansionType.VariadicType<T...>
+public func returnsVariadicType<T...>() -> VariadicType<T... > {}
+
+// CHECK: public typealias VariadicAlias<T...> = PackExpansionType.VariadicType<Swift.Array<T>...>
+public typealias VariadicAlias<T...> = VariadicType<Array<T>... >
+
+// CHECK: public func returnsVariadicAlias() -> PackExpansionType.VariadicAlias<>
+public func returnsVariadicAlias() -> VariadicAlias< > {}
+
+// CHECK: public func returnsVariadicAlias() -> PackExpansionType.VariadicAlias<Swift.Int, Swift.String, Swift.Float>
+public func returnsVariadicAlias() -> VariadicAlias<Int, String, Float> {}
+
+// CHECK: public func returnsVariadicAlias<T...>() -> PackExpansionType.VariadicAlias<T...>
+public func returnsVariadicAlias<T...>() -> VariadicAlias<T... > {}

test/SILGen/pack_expansion_type.swift

@@ -8,7 +8,7 @@
 public func variadicFunction<T..., U...>(t: T..., u: U...) -> ((T, U)...) {}
 
 public struct VariadicType<T...> {
-  // CHECK-LABEL: sil [ossa] @$s19pack_expansion_type12VariadicTypeV14variadicMethod1t1ux_qd__txQp_txxQp_qd__qd__Qptqd__RhzlF : $@convention(method) <T...><U... where ((T, U)...) : Any> (@in_guaranteed T..., @in_guaranteed U..., VariadicType<T>) -> @out (T, U)... {
-  // CHECK: bb0(%0 : $*(T, U)..., %1 : $*T..., %2 : $*U..., %3 : $VariadicType<T>):
+  // CHECK-LABEL: sil [ossa] @$s19pack_expansion_type12VariadicTypeV14variadicMethod1t1ux_qd__txQp_txxQp_qd__qd__Qptqd__RhzlF : $@convention(method) <T...><U... where ((T, U)...) : Any> (@in_guaranteed T..., @in_guaranteed U..., VariadicType<T...>) -> @out (T, U)... {
+  // CHECK: bb0(%0 : $*(T, U)..., %1 : $*T..., %2 : $*U..., %3 : $VariadicType<T...>):
   public func variadicMethod<U...>(t: T..., u: U...) -> ((T, U)...) {}
 }