More variadic generics mangling changes

docs/ABI/Mangling.rst

@@ -887,8 +887,10 @@ now codified into the ABI; the index 0 is therefore reserved.
 
 ::
 
-  generic-signature ::= requirement* 'l'     // one generic parameter
-  generic-signature ::= requirement* 'r' GENERIC-PARAM-COUNT* 'l'
+  generic-signature ::= requirement* generic-param-pack-marker* 'l'     // one generic parameter
+  generic-signature ::= requirement* generic-param-pack-marker* 'r' GENERIC-PARAM-COUNT* 'l'
+
+  generic-param-pack-marker ::= 'Rv' GENERIC_PARAM-INDEX   // generic parameter pack marker
 
   GENERIC-PARAM-COUNT ::= 'z'                // zero parameters
   GENERIC-PARAM-COUNT ::= INDEX              // N+1 parameters
@@ -931,9 +933,11 @@ now codified into the ABI; the index 0 is therefore reserved.
   LAYOUT-SIZE ::= INDEX // Size only
   LAYOUT-SIZE-AND-ALIGNMENT ::= INDEX INDEX // Size followed by alignment
 
+A generic signature begins with an optional list of requirements.
 
+This is followed by an optional list of generic-param-pack-markers to record
+which generic parameters are packs (variadic).
 
-A generic signature begins with an optional list of requirements.
 The ``<GENERIC-PARAM-COUNT>`` describes the number of generic parameters at
 each depth of the signature. As a special case, no ``<GENERIC-PARAM-COUNT>``
 values indicates a single generic parameter at the outermost depth::

include/swift/Demangling/DemangleNodes.def

@@ -63,6 +63,7 @@ NODE(DependentGenericParamType)
 NODE(DependentGenericSameTypeRequirement)
 NODE(DependentGenericSameShapeRequirement)
 NODE(DependentGenericLayoutRequirement)
+NODE(DependentGenericParamPackMarker)
 NODE(DependentGenericSignature)
 NODE(DependentGenericType)
 NODE(DependentMemberType)

lib/AST/ASTDemangler.cpp

@@ -1011,12 +1011,8 @@ LayoutConstraint ASTBuilder::getLayoutConstraintWithSizeAlign(
 CanGenericSignature ASTBuilder::demangleGenericSignature(
     NominalTypeDecl *nominalDecl,
     NodePointer node) {
-  // The type parameters appearing in the signature's requirements are not
-  // notionally part of our current generic signature.
-  //
-  // FIXME: Fix this to support variadic generics.
   llvm::SaveAndRestore<GenericSignature> savedSignature(
-      GenericSig, GenericSignature());
+      GenericSig, nominalDecl->getGenericSignature());
 
   SmallVector<Requirement, 2> requirements;
 

lib/AST/ASTMangler.cpp

@@ -2979,7 +2979,7 @@ void ASTMangler::appendRequirement(const Requirement &reqt,
     if (tryMangleTypeSubstitution(DT, sig)) {
       switch (reqt.getKind()) {
         case RequirementKind::SameShape:
-          llvm_unreachable("Same-shape requirement not supported here");
+          llvm_unreachable("Same-shape requirement with dependent member type?");
         case RequirementKind::Conformance:
           return appendOperator("RQ");
         case RequirementKind::Layout:
@@ -3038,14 +3038,20 @@ void ASTMangler::appendRequirement(const Requirement &reqt,
 
 void ASTMangler::appendGenericSignatureParts(
                                      GenericSignature sig,
-                                     ArrayRef<CanTypeWrapper<GenericTypeParamType>> params,
+                                     ArrayRef<CanGenericTypeParamType> params,
                                      unsigned initialParamDepth,
                                      ArrayRef<Requirement> requirements) {
   // Mangle the requirements.
   for (const Requirement &reqt : requirements) {
     appendRequirement(reqt, sig);
   }
 
+  // Mangle which generic parameters are pack parameters.
+  for (auto param : params) {
+    if (param->isParameterPack())
+      appendOpWithGenericParamIndex("Rv", param);
+  }
+
   if (params.size() == 1 && params[0]->getDepth() == initialParamDepth)
     return appendOperator("l");
 

lib/Demangling/Demangler.cpp

@@ -76,6 +76,7 @@ static bool isEntity(Node::Kind kind) {
 
 static bool isRequirement(Node::Kind kind) {
   switch (kind) {
+    case Node::Kind::DependentGenericParamPackMarker:
     case Node::Kind::DependentGenericSameTypeRequirement:
     case Node::Kind::DependentGenericSameShapeRequirement:
     case Node::Kind::DependentGenericLayoutRequirement:
@@ -3788,11 +3789,12 @@ NodePointer Demangler::demangleGenericSignature(bool hasParamCounts) {
 }
 
 NodePointer Demangler::demangleGenericRequirement() {
-  
+
   enum { Generic, Assoc, CompoundAssoc, Substitution } TypeKind;
-  enum { Protocol, BaseClass, SameType, SameShape, Layout } ConstraintKind;
+  enum { Protocol, BaseClass, SameType, SameShape, Layout, PackMarker } ConstraintKind;
 
   switch (nextChar()) {
+    case 'v': ConstraintKind = PackMarker; TypeKind = Generic; break;
     case 'c': ConstraintKind = BaseClass; TypeKind = Assoc; break;
     case 'C': ConstraintKind = BaseClass; TypeKind = CompoundAssoc; break;
     case 'b': ConstraintKind = BaseClass; TypeKind = Generic; break;
@@ -3832,6 +3834,9 @@ NodePointer Demangler::demangleGenericRequirement() {
   }
 
   switch (ConstraintKind) {
+  case PackMarker:
+    return createWithChild(
+        Node::Kind::DependentGenericParamPackMarker, ConstrTy);
   case Protocol:
     return createWithChildren(
         Node::Kind::DependentGenericConformanceRequirement, ConstrTy,

lib/Demangling/NodePrinter.cpp

@@ -368,6 +368,7 @@ class NodePrinter {
     case Node::Kind::DefaultAssociatedConformanceAccessor:
     case Node::Kind::DependentAssociatedTypeRef:
     case Node::Kind::DependentGenericSignature:
+    case Node::Kind::DependentGenericParamPackMarker:
     case Node::Kind::DependentGenericParamCount:
     case Node::Kind::DependentGenericConformanceRequirement:
     case Node::Kind::DependentGenericLayoutRequirement:
@@ -982,6 +983,92 @@ class NodePrinter {
     }
   }
 
+  void printGenericSignature(NodePointer Node, unsigned depth) {
+    Printer << '<';
+
+    unsigned numChildren = Node->getNumChildren();
+
+    unsigned numGenericParams = 0;
+    for (; numGenericParams < numChildren; ++numGenericParams) {
+      if (Node->getChild(numGenericParams)->getKind()
+               != Node::Kind::DependentGenericParamCount) {
+        break;
+      }
+    }
+
+    unsigned firstRequirement = numGenericParams;
+    for (; firstRequirement < numChildren; ++firstRequirement) {
+      auto child = Node->getChild(firstRequirement);
+      if (child->getKind() == Node::Kind::Type)
+        child = child->getChild(0);
+      if (child->getKind() != Node::Kind::DependentGenericParamPackMarker) {
+        break;
+      }
+    }
+
+    auto isGenericParamPack = [&](unsigned depth, unsigned index) {
+      for (unsigned i = numGenericParams; i < firstRequirement; ++i) {
+        auto child = Node->getChild(i);
+        if (child->getKind() != Node::Kind::DependentGenericParamPackMarker)
+          continue;
+        child = child->getChild(0);
+
+        if (child->getKind() != Node::Kind::Type)
+          continue;
+
+        child = child->getChild(0);
+        if (child->getKind() != Node::Kind::DependentGenericParamType)
+          continue;
+
+        if (index == child->getChild(0)->getIndex() &&
+            depth == child->getChild(1)->getIndex()) {
+          return true;
+        }
+      }
+
+      return false;
+    };
+
+    unsigned gpDepth = 0;
+    for (; gpDepth < numGenericParams; ++gpDepth) {
+      if (gpDepth != 0)
+        Printer << "><";
+
+      unsigned count = Node->getChild(gpDepth)->getIndex();
+      for (unsigned index = 0; index < count; ++index) {
+        if (index != 0)
+          Printer << ", ";
+
+        // Limit the number of printed generic parameters. In practice this
+        // it will never be exceeded. The limit is only important for malformed
+        // symbols where count can be really huge.
+        if (index >= 128) {
+          Printer << "...";
+          break;
+        }
+
+        if (isGenericParamPack(gpDepth, index))
+          Printer << "each ";
+
+        // FIXME: Depth won't match when a generic signature applies to a
+        // method in generic type context.
+        Printer << Options.GenericParameterName(gpDepth, index);
+      }
+    }
+
+    if (firstRequirement != numChildren) {
+      if (Options.DisplayWhereClauses) {
+        Printer << " where ";
+        for (unsigned i = firstRequirement; i < numChildren; ++i) {
+          if (i > firstRequirement)
+            Printer << ", ";
+          print(Node->getChild(i), depth + 1);
+        }
+      }
+    }
+    Printer << '>';
+  }
+
   void printFunctionSigSpecializationParams(NodePointer Node, unsigned depth);
 
   void printSpecializationPrefix(NodePointer node, StringRef Description,
@@ -2634,49 +2721,11 @@ NodePointer NodePrinter::print(NodePointer Node, unsigned depth,
 
   case Node::Kind::DependentPseudogenericSignature:
   case Node::Kind::DependentGenericSignature: {
-    Printer << '<';
-
-    unsigned depth = 0;
-    unsigned numChildren = Node->getNumChildren();
-    for (;
-         depth < numChildren
-           && Node->getChild(depth)->getKind()
-               == Node::Kind::DependentGenericParamCount;
-         ++depth) {
-      if (depth != 0)
-        Printer << "><";
-
-      unsigned count = Node->getChild(depth)->getIndex();
-      for (unsigned index = 0; index < count; ++index) {
-        if (index != 0)
-          Printer << ", ";
-        // Limit the number of printed generic parameters. In practice this
-        // it will never be exceeded. The limit is only important for malformed
-        // symbols where count can be really huge.
-        if (index >= 128) {
-          Printer << "...";
-          break;
-        }
-        // FIXME: Depth won't match when a generic signature applies to a
-        // method in generic type context.
-        Printer << Options.GenericParameterName(depth, index);
-      }
-    }
-
-    if (depth != numChildren) {
-      if (Options.DisplayWhereClauses) {
-        Printer << " where ";
-        for (unsigned i = depth; i < numChildren; ++i) {
-          if (i > depth)
-            Printer << ", ";
-          print(Node->getChild(i), depth + 1);
-        }
-      }
-    }
-    Printer << '>';
+    printGenericSignature(Node, depth);
     return nullptr;
   }
   case Node::Kind::DependentGenericParamCount:
+  case Node::Kind::DependentGenericParamPackMarker:
     printer_unreachable("should be printed as a child of a "
                         "DependentGenericSignature");
   case Node::Kind::DependentGenericConformanceRequirement: {

lib/Demangling/OldRemangler.cpp

@@ -1941,6 +1941,11 @@ ManglingError Remangler::mangleDependentPseudogenericSignature(Node *node,
   return mangleDependentGenericSignature(node, depth + 1);
 }
 
+ManglingError Remangler::mangleDependentGenericParamPackMarker(Node *node,
+                                                               unsigned depth) {
+  return MANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
+}
+
 ManglingError Remangler::mangleDependentGenericSignature(Node *node,
                                                          unsigned depth) {
   auto i = node->begin(), e = node->end();

lib/Demangling/Remangler.cpp

@@ -1160,6 +1160,15 @@ ManglingError Remangler::mangleDependentGenericSignature(Node *node,
   return ManglingError::Success;
 }
 
+ManglingError Remangler::mangleDependentGenericParamPackMarker(Node *node,
+                                                      unsigned depth) {
+  DEMANGLER_ASSERT(node->getNumChildren() == 1, node);
+  DEMANGLER_ASSERT(node->getChild(0)->getKind() == Node::Kind::Type, node);
+  Buffer << "Rv";
+  mangleDependentGenericParamIndex(node->getChild(0)->getChild(0));
+  return ManglingError::Success;
+}
+
 ManglingError Remangler::mangleDependentGenericType(Node *node,
                                                     unsigned depth) {
   RETURN_IF_ERROR(

lib/IRGen/GenPack.cpp

@@ -161,6 +161,8 @@ llvm::Value *IRGenFunction::emitPackShapeExpression(CanType type) {
   if (pair.first > 0) {
     auto *constant = llvm::ConstantInt::get(IGM.SizeTy, pair.first);
     accumulateSum(*this, pair.second, constant);
+  } else if (pair.second == nullptr) {
+    pair.second = llvm::ConstantInt::get(IGM.SizeTy, 0);
   }
 
   setScopedLocalTypeData(type, kind, pair.second);

lib/SILGen/SILGenLazyConformance.cpp

@@ -12,7 +12,9 @@
 
 #include "SILGen.h"
 #include "swift/AST/Decl.h"
+#include "swift/AST/PackConformance.h"
 #include "swift/AST/ProtocolConformance.h"
+#include "swift/AST/ProtocolConformanceRef.h"
 #include "swift/ClangImporter/ClangModule.h"
 #include "swift/SIL/SILInstruction.h"
 #include "swift/SIL/SILVisitor.h"
@@ -31,6 +33,16 @@ void SILGenModule::useConformance(ProtocolConformanceRef conformanceRef) {
   if (conformanceRef.isAbstract())
     return;
 
+  // Recursively visit pack conformances.
+  if (conformanceRef.isPack()) {
+    auto *packConformance = conformanceRef.getPack();
+
+    for (auto patternConformanceRef : packConformance->getPatternConformances())
+      useConformance(patternConformanceRef);
+
+    return;
+  }
+
   auto conformance = conformanceRef.getConcrete();
 
   // Always look through inherited conformances.

test/DebugInfo/variadic-generics-count.swift

@@ -6,14 +6,14 @@
 // REQUIRES: asserts
 
 public func f1<T...>(ts: repeat each T) {
-  // CHECK: define {{.*}} @"$s1a2f12tsyxxQp_tlF"(%swift.opaque** {{.*}}, i{{32|64}} [[COUNT1_1:.*]], %swift.type** {{.*}})
+  // CHECK: define {{.*}} @"$s1a2f12tsyxxQp_tRvzlF"(%swift.opaque** {{.*}}, i{{32|64}} [[COUNT1_1:.*]], %swift.type** {{.*}})
   // CHECK-DAG: store i{{32|64}} [[COUNT1_1]], i{{32|64}}* %[[COUNT1_1_A:.*]], align
   // CHECK-DAG: call void @llvm.dbg.declare({{.*}}[[COUNT1_1_A]], metadata ![[COUNT1_1_VAR:[0-9]+]], metadata !DIExpression())
   // CHECK-LABEL: ret void
 }
 
 public func f2<U..., V...>(us: repeat each U, vs: repeat each V) {
-  // CHECK: define {{.*}} @"$s1a2f22us2vsyxxQp_q_q_Qptr0_lF"(%swift.opaque** {{.*}}, %swift.opaque** {{.*}}, i{{32|64}} [[COUNT2_1:.*]], i{{32|64}} [[COUNT2_2:.*]], %swift.type** {{.*}}, %swift.type** {{.*}})
+  // CHECK: define {{.*}} @"$s1a2f22us2vsyxxQp_q_q_QptRvzRv_r0_lF"(%swift.opaque** {{.*}}, %swift.opaque** {{.*}}, i{{32|64}} [[COUNT2_1:.*]], i{{32|64}} [[COUNT2_2:.*]], %swift.type** {{.*}}, %swift.type** {{.*}})
   // CHECK-DAG: store i{{32|64}} [[COUNT2_1]], i{{32|64}}* %[[COUNT2_1_A:.*]], align
   // CHECK-DAG: store i{{32|64}} [[COUNT2_2]], i{{32|64}}* %[[COUNT2_2_A:.*]], align
   // CHECK-DAG: call void @llvm.dbg.declare({{.*}}[[COUNT2_1_A]], metadata ![[COUNT2_1_VAR:[0-9]+]], metadata !DIExpression())
@@ -22,14 +22,14 @@ public func f2<U..., V...>(us: repeat each U, vs: repeat each V) {
 }
 
 public func f3<T...>(ts: repeat each T, more_ts: repeat each T) {
-  // CHECK: define {{.*}} @"$s1a2f32ts05more_B0yxxQp_xxQptlF"(%swift.opaque** {{.*}}, %swift.opaque** {{.*}}, i{{32|64}} [[COUNT3_1:.*]], %swift.type** {{.*}})
+  // CHECK: define {{.*}} @"$s1a2f32ts05more_B0yxxQp_xxQptRvzlF"(%swift.opaque** {{.*}}, %swift.opaque** {{.*}}, i{{32|64}} [[COUNT3_1:.*]], %swift.type** {{.*}})
   // CHECK-DAG: store i{{32|64}} [[COUNT3_1]], i{{32|64}}* %[[COUNT3_1_A:.*]], align
   // CHECK-DAG: call void @llvm.dbg.declare({{.*}}[[COUNT3_1_A]], metadata ![[COUNT3_1_VAR:[0-9]+]], metadata !DIExpression())
   // CHECK-LABEL: ret void
 }
 
 public func f4<U..., V...>(us: repeat (each U, each V)) {
-  // CHECK: define {{.*}} @"$s1a2f42usyx_q_txQp_tq_Rhzr0_lF"(%swift.opaque** {{.*}}, i{{32|64}} [[COUNT4_1:.*]], %swift.type** {{.*}}, %swift.type** {{.*}})
+  // CHECK: define {{.*}} @"$s1a2f42usyx_q_txQp_tq_RhzRvzRv_r0_lF"(%swift.opaque** {{.*}}, i{{32|64}} [[COUNT4_1:.*]], %swift.type** {{.*}}, %swift.type** {{.*}})
   // CHECK-DAG: store i{{32|64}} [[COUNT4_1]], i{{32|64}}* %[[COUNT4_1_A:.*]], align
   // CHECK-DAG: call void @llvm.dbg.declare({{.*}}[[COUNT4_1_A]], metadata ![[COUNT4_1_VAR:[0-9]+]], metadata !DIExpression())
   // CHECK-LABEL: ret void

test/DebugInfo/variadic-generics.swift

@@ -6,7 +6,7 @@
 // REQUIRES: asserts
 
 public func foo<T...>(args: repeat each T) {
-  // CHECK: define {{.*}} @"$s1a3foo4argsyxxQp_tlF"
+  // CHECK: define {{.*}} @"$s1a3foo4argsyxxQp_tRvzlF"
   // CHECK-SAME: %swift.type** %[[TYPE_PACK_ARG:.*]])
   // CHECK: %[[TYPE_PACK_ALLOCA:.*]] = alloca %swift.type**
   // CHECK: call void @llvm.dbg.declare(metadata %swift.type*** %[[TYPE_PACK_ALLOCA]], metadata ![[TYPE_PACK_VAR:[0-9]+]], metadata !DIExpression())

test/IRGen/variadic_generic_functions.swift

@@ -5,13 +5,13 @@
 
 // REQUIRES: PTRSIZE=64
 
-// CHECK-LABEL: define hidden swiftcc void @"$s26variadic_generic_functions2f11tyxxQp_tlF"(%swift.opaque** noalias nocapture %0, i64 %1, %swift.type** %T)
+// CHECK-LABEL: define hidden swiftcc void @"$s26variadic_generic_functions2f11tyxxQp_tRvzlF"(%swift.opaque** noalias nocapture %0, i64 %1, %swift.type** %T)
 func f1<T...>(t: repeat each T) {}
 
-// CHECK-LABEL: define hidden swiftcc void @"$s26variadic_generic_functions2f21t1uyxxQp_q_q_Qptr0_lF"(%swift.opaque** noalias nocapture %0, %swift.opaque** noalias nocapture %1, i64 %2, i64 %3, %swift.type** %T, %swift.type** %U)
+// CHECK-LABEL: define hidden swiftcc void @"$s26variadic_generic_functions2f21t1uyxxQp_q_q_QptRvzRv_r0_lF"(%swift.opaque** noalias nocapture %0, %swift.opaque** noalias nocapture %1, i64 %2, i64 %3, %swift.type** %T, %swift.type** %U)
 func f2<T..., U...>(t: repeat each T, u: repeat each U) {}
 
-// CHECK-LABEL: define hidden swiftcc void @"$s26variadic_generic_functions2f31t1uyxxQp_q_xQptq_Rhzr0_lF"(%swift.opaque** noalias nocapture %0, %swift.opaque** noalias nocapture %1, i64 %2, %swift.type** %T, %swift.type** %U)
+// CHECK-LABEL: define hidden swiftcc void @"$s26variadic_generic_functions2f31t1uyxxQp_q_xQptq_RhzRvzRv_r0_lF"(%swift.opaque** noalias nocapture %0, %swift.opaque** noalias nocapture %1, i64 %2, %swift.type** %T, %swift.type** %U)
 func f3<T..., U...>(t: repeat each T, u: repeat each U) where (repeat (each T, each U)): Any {}
 
 protocol P {}

test/Interpreter/variadic_generic_types.swift

@@ -11,5 +11,8 @@ struct G<T...> {
   }
 }
 
+// CHECK: ()
+G< >().makeTuple()
+
 // CHECK: (Array<Int>, Array<String>, Array<Float>)
 G<Int, String, Float>().makeTuple()