Runtime: Plumb through the pack shape stuff in more places

Author: slavapestov

include/swift/ABI/GenericContext.h

@@ -299,14 +299,21 @@ class RuntimeGenericSignature {
   TargetGenericContextDescriptorHeader<Runtime> Header;
   const GenericParamDescriptor *Params;
   const TargetGenericRequirementDescriptor<Runtime> *Requirements;
+  GenericParamPackShapeHeader PackShapeHeader;
+  const GenericParamPackShapeDescriptor *PackShapeDescriptors;
+
 public:
   RuntimeGenericSignature()
-    : Header{0, 0, 0, 0}, Params(nullptr), Requirements(nullptr) {}
+    : Header{0, 0, 0, 0}, Params(nullptr), Requirements(nullptr),
+      PackShapeHeader{0, 0}, PackShapeDescriptors(nullptr) {}
 
   RuntimeGenericSignature(const TargetGenericContextDescriptorHeader<Runtime> &header,
                           const GenericParamDescriptor *params,
-                          const TargetGenericRequirementDescriptor<Runtime> *requirements)
-    : Header(header), Params(params), Requirements(requirements) {}
+                          const TargetGenericRequirementDescriptor<Runtime> *requirements,
+                          const GenericParamPackShapeHeader &packShapeHeader,
+                          const GenericParamPackShapeDescriptor *packShapeDescriptors)
+    : Header(header), Params(params), Requirements(requirements),
+      PackShapeHeader(packShapeHeader), PackShapeDescriptors(packShapeDescriptors) {}
 
   llvm::ArrayRef<GenericParamDescriptor> getParams() const {
     return llvm::makeArrayRef(Params, Header.NumParams);
@@ -316,6 +323,10 @@ class RuntimeGenericSignature {
     return llvm::makeArrayRef(Requirements, Header.NumRequirements);
   }
 
+  llvm::ArrayRef<GenericParamPackShapeDescriptor> getPackShapeDescriptors() const {
+    return llvm::makeArrayRef(PackShapeDescriptors, PackShapeHeader.NumTypePacks);
+  }
+
   size_t getArgumentLayoutSizeInWords() const {
     return Header.getArgumentLayoutSizeInWords();
   }
@@ -476,21 +487,21 @@ class TrailingGenericContextObjects<TargetSelf<Runtime>,
             getGenericContextHeader().NumRequirements};
   }
 
-  const GenericParamPackShapeHeader *getGenericParamPackShapeHeader() const {
+  GenericParamPackShapeHeader getGenericParamPackShapeHeader() const {
     if (!asSelf()->isGeneric())
-      return nullptr;
+      return {0, 0};
     if (!getGenericContextHeader().Flags.hasTypePacks())
-      return nullptr;
-    return this->template getTrailingObjects<GenericParamPackShapeHeader>();
+      return {0, 0};
+    return *this->template getTrailingObjects<GenericParamPackShapeHeader>();
   }
 
   llvm::ArrayRef<GenericParamPackShapeDescriptor> getGenericParamPackShapeDescriptors() const {
-    auto *header = getGenericParamPackShapeHeader();
-    if (header == nullptr)
+    auto header = getGenericParamPackShapeHeader();
+    if (header.NumTypePacks == 0)
       return {};
 
     return {this->template getTrailingObjects<GenericParamPackShapeDescriptor>(),
-            header->NumTypePacks};
+            header.NumTypePacks};
   }
 
   /// Return the amount of space that the generic arguments take up in
@@ -504,7 +515,9 @@ class TrailingGenericContextObjects<TargetSelf<Runtime>,
     if (!asSelf()->isGeneric()) return RuntimeGenericSignature<Runtime>();
     return {getGenericContextHeader(),
             getGenericParams().data(),
-            getGenericRequirements().data()};
+            getGenericRequirements().data(),
+            getGenericParamPackShapeHeader(),
+            getGenericParamPackShapeDescriptors().data()};
   }
 
 protected:
@@ -534,7 +547,7 @@ class TrailingGenericContextObjects<TargetSelf<Runtime>,
     if (!getGenericContextHeader().Flags.hasTypePacks())
       return 0;
 
-    return getGenericParamPackShapeHeader()->NumTypePacks;
+    return getGenericParamPackShapeHeader().NumTypePacks;
   }
 
 #if defined(_MSC_VER) && _MSC_VER < 1920

include/swift/ABI/Metadata.h

@@ -1929,7 +1929,13 @@ struct TargetExtendedExistentialTypeShape
       GenericParamDescriptor,
       // Requirements for requirement signature, followed by requirements
       // for generalization signature
-      TargetGenericRequirementDescriptor<Runtime>> {
+      TargetGenericRequirementDescriptor<Runtime>,
+      // Optional header describing any type packs in the generalization
+      // signature.
+      GenericParamPackShapeHeader,
+      // For each type pack in the generalization signature, a descriptor
+      // storing the shape class.
+      GenericParamPackShapeDescriptor> {
 private:
   using RelativeValueWitnessTablePointer =
     TargetRelativeIndirectablePointer<Runtime,
@@ -1942,7 +1948,9 @@ struct TargetExtendedExistentialTypeShape
       TargetExistentialTypeExpression<Runtime>,
       RelativeValueWitnessTablePointer,
       GenericParamDescriptor,
-      TargetGenericRequirementDescriptor<Runtime>>;
+      TargetGenericRequirementDescriptor<Runtime>,
+      GenericParamPackShapeHeader,
+      GenericParamPackShapeDescriptor>;
   friend TrailingObjects;
 
   template<typename T>
@@ -1969,6 +1977,17 @@ struct TargetExtendedExistentialTypeShape
     return getNumGenSigRequirements() + getNumReqSigRequirements();
   }
 
+  size_t numTrailingObjects(OverloadToken<GenericParamPackShapeHeader>) const {
+    return (Flags.hasTypePacks() ? 1 : 0);
+  }
+
+  size_t numTrailingObjects(OverloadToken<GenericParamPackShapeDescriptor>) const {
+    if (!Flags.hasTypePacks())
+      return 0;
+
+    return getGenSigPackShapeHeader().NumTypePacks;
+  }
+
   const TargetGenericContextDescriptorHeader<Runtime> *
   getGenSigHeader() const {
     assert(hasGeneralizationSignature());
@@ -2013,7 +2032,8 @@ struct TargetExtendedExistentialTypeShape
   TargetGenericContextDescriptorHeader<Runtime> ReqSigHeader;
 
   RuntimeGenericSignature<Runtime> getRequirementSignature() const {
-    return {ReqSigHeader, getReqSigParams(), getReqSigRequirements()};
+    return {ReqSigHeader, getReqSigParams(), getReqSigRequirements(),
+            {0, 0}, nullptr};
   }
 
   unsigned getNumReqSigParams() const {
@@ -2092,7 +2112,8 @@ struct TargetExtendedExistentialTypeShape
 
   RuntimeGenericSignature<Runtime> getGeneralizationSignature() const {
     if (!hasGeneralizationSignature()) return RuntimeGenericSignature<Runtime>();
-    return {*getGenSigHeader(), getGenSigParams(), getGenSigRequirements()};
+    return {*getGenSigHeader(), getGenSigParams(), getGenSigRequirements(),
+            getGenSigPackShapeHeader(), getGenSigPackShapeDescriptors()};
   }
 
   unsigned getNumGenSigParams() const {
@@ -2121,6 +2142,20 @@ struct TargetExtendedExistentialTypeShape
     return getReqSigRequirements() + ReqSigHeader.NumRequirements;
   }
 
+  GenericParamPackShapeHeader getGenSigPackShapeHeader() const {
+    assert(hasGeneralizationSignature());
+    if (!Flags.hasTypePacks())
+      return {0, 0};
+    return *this->template getTrailingObjects<GenericParamPackShapeHeader>();
+  }
+
+  const GenericParamPackShapeDescriptor *getGenSigPackShapeDescriptors() const {
+    assert(hasGeneralizationSignature());
+    if (!Flags.hasTypePacks())
+      return nullptr;
+    return this->template getTrailingObjects<GenericParamPackShapeDescriptor>();
+  }
+
   /// Return the amount of space used in ExtendedExistentialTypeMetadata
   /// for this shape to store the generalization arguments.
   unsigned getGenSigArgumentLayoutSizeInWords() const {

include/swift/ABI/MetadataValues.h

@@ -853,6 +853,7 @@ class ExtendedExistentialTypeShapeFlags {
     HasSuggestedValueWitnesses  = 0x00000400U,
     HasImplicitReqSigParams     = 0x00000800U,
     HasImplicitGenSigParams     = 0x00001000U,
+    HasTypePacks                = 0x00002000U,
   };
   int_type Data;
 
@@ -894,6 +895,12 @@ class ExtendedExistentialTypeShapeFlags {
       implicit ? (Data | HasImplicitGenSigParams)
                : (Data & ~HasImplicitGenSigParams));
   }
+  constexpr ExtendedExistentialTypeShapeFlags
+  withTypePacks(bool hasTypePacks) const {
+    return ExtendedExistentialTypeShapeFlags(
+      hasTypePacks ? (Data | HasTypePacks)
+                   : (Data & ~HasTypePacks));
+  }
 
   /// Is this a special kind of existential?
   SpecialKind getSpecialKind() const {
@@ -939,6 +946,14 @@ class ExtendedExistentialTypeShapeFlags {
     return Data & HasImplicitGenSigParams;
   }
 
+  /// Whether the generic context has type parameter packs. This
+  /// occurs when the existential has a superclass requirement
+  /// whose class declaration has a type parameter pack, eg
+  /// `any P & C<...>` with `class C<each T> {}`.
+  bool hasTypePacks() const {
+    return Data & HasTypePacks;
+  }
+
   int_type getIntValue() const {
     return Data;
   }