Runtime: Sketch out metadata for variadic generic types

Author: slavapestov

include/swift/ABI/GenericContext.h

@@ -244,6 +244,25 @@ class TargetGenericRequirementDescriptor {
 using GenericRequirementDescriptor =
   TargetGenericRequirementDescriptor<InProcess>;
 
+struct GenericParamPackShapeHeader {
+  /// The number of generic parameters which are packs.
+  ///
+  /// Must equal the number of GenericParamDescriptors whose kind is
+  /// GenericParamKind::TypePack.
+  uint16_t NumTypePacks;
+
+  /// The number of equivalence classes in the same-shape relation.
+  uint16_t NumShapeClasses;
+};
+
+struct GenericParamPackShapeDescriptor {
+  /// The equivalence class of this generic parameter pack under
+  /// the same-shape relation.
+  ///
+  /// Must be less than GenericParamPackShapeHeader::NumShapeClasses.
+  uint16_t ShapeClass;
+};
+
 /// An array of generic parameter descriptors, all
 /// GenericParamDescriptor::implicit(), which is by far
 /// the most common case.  Some generic context storage can
@@ -386,6 +405,8 @@ class TrailingGenericContextObjects<TargetSelf<Runtime>,
       TargetGenericContextHeaderType<Runtime>,
       GenericParamDescriptor,
       TargetGenericRequirementDescriptor<Runtime>,
+      GenericParamPackShapeHeader,
+      GenericParamPackShapeDescriptor,
       FollowingTrailingObjects...>
 {
 protected:
@@ -398,6 +419,8 @@ class TrailingGenericContextObjects<TargetSelf<Runtime>,
     GenericContextHeaderType,
     GenericParamDescriptor,
     GenericRequirementDescriptor,
+    GenericParamPackShapeHeader,
+    GenericParamPackShapeDescriptor,
     FollowingTrailingObjects...>;
   friend TrailingObjects;
 
@@ -451,6 +474,23 @@ class TrailingGenericContextObjects<TargetSelf<Runtime>,
     return {this->template getTrailingObjects<GenericRequirementDescriptor>(),
             getGenericContextHeader().NumRequirements};
   }
+  
+  const GenericParamPackShapeHeader *getGenericParamPackShapeHeader() const {
+    if (!asSelf()->isGeneric())
+      return nullptr;
+    if (!getGenericContextHeader().Flags.hasTypePacks())
+      return nullptr;
+    return this->template getTrailingObjects<GenericParamPackShapeHeader>();
+  }
+
+  llvm::ArrayRef<GenericParamPackShapeDescriptor> getGenericParamPackShapeDescriptors() const {
+    auto *header = getGenericParamPackShapeHeader();
+    if (header == nullptr)
+      return {};
+
+    return {this->template getTrailingObjects<GenericParamPackShapeDescriptor>(),
+            header->NumTypePacks};
+  }
 
   /// Return the amount of space that the generic arguments take up in
   /// metadata of this type.
@@ -479,6 +519,23 @@ class TrailingGenericContextObjects<TargetSelf<Runtime>,
     return asSelf()->isGeneric() ? getGenericContextHeader().NumRequirements : 0;
   }
 
+  size_t numTrailingObjects(OverloadToken<GenericParamPackShapeHeader>) const {
+    if (!asSelf()->isGeneric())
+      return 0;
+
+    return getGenericContextHeader().Flags.hasTypePacks() ? 1 : 0;
+  }
+
+  size_t numTrailingObjects(OverloadToken<GenericParamPackShapeDescriptor>) const {
+    if (!asSelf()->isGeneric())
+      return 0;
+
+    if (!getGenericContextHeader().Flags.hasTypePacks())
+      return 0;
+
+    return getGenericParamPackShapeHeader()->NumTypePacks;
+  }
+
 #if defined(_MSC_VER) && _MSC_VER < 1920
 #undef OverloadToken
 #endif

include/swift/ABI/MetadataValues.h

@@ -1793,6 +1793,9 @@ enum class GenericParamKind : uint8_t {
   /// A type parameter.
   Type = 0,
 
+  /// A type parameter pack.
+  TypePack = 1,
+
   Max = 0x3F,
 };
 
@@ -1899,11 +1902,13 @@ class GenericRequirementFlags {
 public:
   constexpr GenericRequirementFlags(GenericRequirementKind kind,
                                     bool hasKeyArgument,
-                                    bool hasExtraArgument)
+                                    bool hasExtraArgument,
+                                    bool isPackRequirement)
     : GenericRequirementFlags(GenericRequirementFlags(0)
                          .withKind(kind)
                          .withKeyArgument(hasKeyArgument)
-                         .withExtraArgument(hasExtraArgument))
+                         .withExtraArgument(hasExtraArgument)
+                         .withPackRequirement(isPackRequirement))
   {}
 
   constexpr bool hasKeyArgument() const {
@@ -1914,6 +1919,13 @@ class GenericRequirementFlags {
     return (Value & 0x40u) != 0;
   }
 
+  /// If this is true, the subject type of the requirement is a pack.
+  /// When the requirement is a conformance requirement, the corresponding
+  /// entry in the generic arguments array becomes a TargetWitnessTablePack.
+  constexpr bool isPackRequirement() const {
+    return (Value & 0x20u) != 0;
+  }
+
   constexpr GenericRequirementKind getKind() const {
     return GenericRequirementKind(Value & 0x1Fu);
   }
@@ -1930,6 +1942,12 @@ class GenericRequirementFlags {
       | (hasExtraArgument ? 0x40u : 0));
   }
 
+  constexpr GenericRequirementFlags
+  withPackRequirement(bool isPackRequirement) const {
+    return GenericRequirementFlags((Value & 0xBFu)
+      | (isPackRequirement ? 0x20u : 0));
+  }
+
   constexpr GenericRequirementFlags
   withKind(GenericRequirementKind kind) const {
     return assert((uint8_t(kind) & 0x1Fu) == uint8_t(kind)),

lib/IRGen/GenMeta.cpp

@@ -6126,6 +6126,8 @@ GenericRequirementsMetadata irgen::addGenericRequirements(
   assert(sig);
   GenericRequirementsMetadata metadata;
   for (auto &requirement : requirements) {
+    bool isPackRequirement = requirement.getFirstType()->isParameterPack();
+
     switch (auto kind = requirement.getKind()) {
     case RequirementKind::SameShape:
       llvm_unreachable("Same-shape requirement not supported here");
@@ -6139,7 +6141,8 @@ GenericRequirementsMetadata irgen::addGenericRequirements(
         // Encode the class constraint.
         auto flags = GenericRequirementFlags(GenericRequirementKind::Layout,
                                              /*key argument*/ false,
-                                             /*extra argument*/ false);
+                                             /*extra argument*/ false,
+                                             isPackRequirement);
         addGenericRequirement(IGM, B, metadata, sig, flags,
                               requirement.getFirstType(),
          [&]{ B.addInt32((uint32_t)GenericRequirementLayoutKind::Class); });
@@ -6165,7 +6168,8 @@ GenericRequirementsMetadata irgen::addGenericRequirements(
         Lowering::TypeConverter::protocolRequiresWitnessTable(protocol);
       auto flags = GenericRequirementFlags(GenericRequirementKind::Protocol,
                                            /*key argument*/needsWitnessTable,
-                                           /*extra argument*/false);
+                                           /*extra argument*/false,
+                                           isPackRequirement);
       auto descriptorRef =
         IGM.getConstantReferenceForProtocolDescriptor(protocol);
       addGenericRequirement(IGM, B, metadata, sig, flags,
@@ -6189,7 +6193,10 @@ GenericRequirementsMetadata irgen::addGenericRequirements(
         ? GenericRequirementKind::SameType
         : GenericRequirementKind::BaseClass;
 
-      auto flags = GenericRequirementFlags(abiKind, false, false);
+      auto flags = GenericRequirementFlags(abiKind,
+                                           /*key argument*/false,
+                                           /*extra argument*/false,
+                                           isPackRequirement);
       auto typeName =
           IGM.getTypeRef(requirement.getSecondType(), nullptr,
                          MangledTypeRefRole::Metadata).first;

unittests/runtime/SpecifierDSL.h

@@ -310,7 +310,8 @@ inline void addSameTypeRequirement(AnyObjectBuilder &builder,
                                    ObjectRef<const char> type2) {
   auto flags = GenericRequirementFlags(GenericRequirementKind::SameType,
                                        /*key argument*/ false,
-                                       /*extra argument*/ false);
+                                       /*extra argument*/ false,
+                                       /*is pack requirement*/ false);
   builder.add32(flags.getIntValue());
   builder.addRelativeReference(type1);
   builder.addRelativeReference(type2);
@@ -331,7 +332,8 @@ inline void addConformanceRequirement(AnyObjectBuilder &builder,
                                       bool isKeyArgument = true) {
   auto flags = GenericRequirementFlags(GenericRequirementKind::Protocol,
                                        isKeyArgument,
-                                       /*extra argument*/ false);
+                                       /*extra argument*/ false,
+                                       /*is pack requirement*/ false);
   builder.add32(flags.getIntValue());
   builder.addRelativeReference(type);
   addProtocolDescriptorRef(builder, protocol);