Merge pull request #64063 from slavapestov/more-variadic-generic-types-runtime-work

More variadic generic types runtime work

Author: slavapestov

include/swift/ABI/GenericContext.h

@@ -30,38 +30,6 @@ struct TargetProtocolConformanceDescriptor;
 template <typename Runtime>
 struct TargetGenericContext;
 
-class GenericContextDescriptorFlags {
-  uint16_t Value;
-
-public:
-  constexpr GenericContextDescriptorFlags() : Value(0) {}
-
-  explicit constexpr GenericContextDescriptorFlags(uint16_t value)
-    : Value(value) {}
-
-  constexpr GenericContextDescriptorFlags(bool hasTypePacks)
-    : GenericContextDescriptorFlags(
-        GenericContextDescriptorFlags((uint16_t)0)
-          .withHasTypePacks(hasTypePacks)) {}
-
-  /// Whether this generic context has at least one type parameter
-  /// pack, in which case the generic context will have a trailing
-  /// GenericPackShapeHeader.
-  constexpr bool hasTypePacks() const {
-    return (Value & 0x1) != 0;
-  }
-
-  constexpr GenericContextDescriptorFlags
-  withHasTypePacks(bool hasTypePacks) const {
-    return GenericContextDescriptorFlags((uint16_t)(
-      (Value & ~0x1) | (hasTypePacks ? 0x1 : 0)));
-  }
-
-  constexpr uint16_t getIntValue() const {
-    return Value;
-  }
-};
-
 template <typename Runtime>
 struct TargetGenericContextDescriptorHeader {
   /// The number of (source-written) generic parameters, and thus
@@ -87,15 +55,25 @@ struct TargetGenericContextDescriptorHeader {
   uint16_t NumRequirements;
 
   /// The size of the "key" area of the argument layout, in words.
-  /// Key arguments include generic parameters and conformance
-  /// requirements which are part of the identity of the context.
+  /// Key arguments include shape classes, generic parameters and
+  /// conformance requirements which are part of the identity of
+  /// the context.
+  ///
+  /// The key area of the argument layout consists of:
+  ///
+  /// - a sequence of pack lengths, in the same order as the parameter
+  ///   descriptors which satisfy getKind() == GenericParamKind::TypePack
+  ///   and hasKeyArgument();
+  ///
+  /// - a sequence of metadata or metadata pack pointers, in the same
+  ///   order as the parameter descriptors which satisfy hasKeyArgument();
   ///
-  /// The key area of the argument layout consists of a sequence
-  /// of type metadata pointers (in the same order as the parameter
-  /// descriptors, for those parameters which satisfy hasKeyArgument())
-  /// followed by a sequence of witness table pointers (in the same
-  /// order as the requirements, for those requirements which satisfy
-  /// hasKeyArgument()).
+  /// - a sequence of witness table or witness table pack pointers, in the
+  ///   same order as the requirement descriptors which satisfy
+  ///   hasKeyArgument().
+  ///
+  /// The elements above which are packs are precisely those appearing
+  /// in the sequence of trailing GenericPackShapeDescriptors.
   uint16_t NumKeyArguments;
 
   /// Originally this was the size of the "extra" area of the argument
@@ -260,11 +238,6 @@ struct GenericPackShapeHeader {
   uint16_t NumShapeClasses;
 };
 
-enum class GenericPackKind: uint16_t {
-  Metadata = 0,
-  WitnessTable = 1
-};
-
 /// The GenericPackShapeHeader is followed by an array of these descriptors,
 /// whose length is given by the header's NumPacks field.
 ///
@@ -536,13 +509,6 @@ class TrailingGenericContextObjects<TargetSelf<Runtime>,
             header.NumPacks};
   }
 
-  /// Return the amount of space that the generic arguments take up in
-  /// metadata of this type.
-  StoredSize getGenericArgumentsStorageSize() const {
-    return StoredSize(getGenericContextHeader().getNumArguments())
-             * sizeof(StoredPointer);
-  }
-
   RuntimeGenericSignature<Runtime> getGenericSignature() const {
     if (!asSelf()->isGeneric()) return RuntimeGenericSignature<Runtime>();
     return {getGenericContextHeader(),

include/swift/ABI/MetadataValues.h

@@ -1812,6 +1812,38 @@ class AnonymousContextDescriptorFlags : public FlagSet<uint16_t> {
                                 setHasMangledName)
 };
 
+class GenericContextDescriptorFlags {
+  uint16_t Value;
+
+public:
+  constexpr GenericContextDescriptorFlags() : Value(0) {}
+
+  explicit constexpr GenericContextDescriptorFlags(uint16_t value)
+    : Value(value) {}
+
+  constexpr GenericContextDescriptorFlags(bool hasTypePacks)
+    : GenericContextDescriptorFlags(
+        GenericContextDescriptorFlags((uint16_t)0)
+          .withHasTypePacks(hasTypePacks)) {}
+
+  /// Whether this generic context has at least one type parameter
+  /// pack, in which case the generic context will have a trailing
+  /// GenericPackShapeHeader.
+  constexpr bool hasTypePacks() const {
+    return (Value & 0x1) != 0;
+  }
+
+  constexpr GenericContextDescriptorFlags
+  withHasTypePacks(bool hasTypePacks) const {
+    return GenericContextDescriptorFlags((uint16_t)(
+      (Value & ~0x1) | (hasTypePacks ? 0x1 : 0)));
+  }
+
+  constexpr uint16_t getIntValue() const {
+    return Value;
+  }
+};
+
 enum class GenericParamKind : uint8_t {
   /// A type parameter.
   Type = 0,
@@ -1823,28 +1855,23 @@ enum class GenericParamKind : uint8_t {
 };
 
 class GenericParamDescriptor {
+  /// Don't set 0x40 for compatibility with pre-Swift 5.8 runtimes
   uint8_t Value;
 
   explicit constexpr GenericParamDescriptor(uint8_t Value)
     : Value(Value) {}
 public:
   constexpr GenericParamDescriptor(GenericParamKind kind,
-                                   bool hasKeyArgument,
-                                   bool hasExtraArgument)
+                                   bool hasKeyArgument)
     : GenericParamDescriptor(GenericParamDescriptor(0)
                          .withKind(kind)
-                         .withKeyArgument(hasKeyArgument)
-                         .withExtraArgument(hasExtraArgument))
+                         .withKeyArgument(hasKeyArgument))
   {}
 
   constexpr bool hasKeyArgument() const {
     return (Value & 0x80u) != 0;
   }
 
-  constexpr bool hasExtraArgument() const {
-    return (Value & 0x40u) != 0;
-  }
-
   constexpr GenericParamKind getKind() const {
     return GenericParamKind(Value & 0x3Fu);
   }
@@ -1855,12 +1882,6 @@ class GenericParamDescriptor {
       | (hasKeyArgument ? 0x80u : 0));
   }
 
-  constexpr GenericParamDescriptor
-  withExtraArgument(bool hasExtraArgument) const {
-    return GenericParamDescriptor((Value & 0xBFu)
-      | (hasExtraArgument ? 0x40u : 0));
-  }
-
   constexpr GenericParamDescriptor withKind(GenericParamKind kind) const {
     return assert((uint8_t(kind) & 0x3Fu) == uint8_t(kind)),
       GenericParamDescriptor((Value & 0xC0u) | uint8_t(kind));
@@ -1882,8 +1903,7 @@ class GenericParamDescriptor {
   /// The default parameter descriptor for an implicit parameter.
   static constexpr GenericParamDescriptor implicit() {
     return GenericParamDescriptor(GenericParamKind::Type,
-                                  /*key argument*/ true,
-                                  /*extra argument*/ false);
+                                  /*key argument*/ true);
   }
 };
 
@@ -1920,30 +1940,25 @@ enum class GenericRequirementKind : uint8_t {
 };
 
 class GenericRequirementFlags {
+  /// Don't set 0x40 for compatibility with pre-Swift 5.8 runtimes
   uint32_t Value;
 
   explicit constexpr GenericRequirementFlags(uint32_t Value)
     : Value(Value) {}
 public:
   constexpr GenericRequirementFlags(GenericRequirementKind kind,
                                     bool hasKeyArgument,
-                                    bool hasExtraArgument,
                                     bool isPackRequirement)
     : GenericRequirementFlags(GenericRequirementFlags(0)
                          .withKind(kind)
                          .withKeyArgument(hasKeyArgument)
-                         .withExtraArgument(hasExtraArgument)
                          .withPackRequirement(isPackRequirement))
   {}
 
   constexpr bool hasKeyArgument() const {
     return (Value & 0x80u) != 0;
   }
 
-  constexpr bool hasExtraArgument() const {
-    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.
@@ -1961,12 +1976,6 @@ class GenericRequirementFlags {
       | (hasKeyArgument ? 0x80u : 0));
   }
 
-  constexpr GenericRequirementFlags
-  withExtraArgument(bool hasExtraArgument) const {
-    return GenericRequirementFlags((Value & 0xBFu)
-      | (hasExtraArgument ? 0x40u : 0));
-  }
-
   constexpr GenericRequirementFlags
   withPackRequirement(bool isPackRequirement) const {
     return GenericRequirementFlags((Value & 0xBFu)
@@ -1989,6 +1998,11 @@ enum class GenericRequirementLayoutKind : uint32_t {
   Class = 0,
 };
 
+enum class GenericPackKind : uint16_t {
+  Metadata = 0,
+  WitnessTable = 1
+};
+
 class GenericEnvironmentFlags {
   uint32_t Value;
 

include/swift/Remote/MetadataReader.h

@@ -3026,11 +3026,6 @@ class MetadataReader {
     for (auto param : generics->getGenericParams()) {
       switch (param.getKind()) {
       case GenericParamKind::Type:
-        // We don't know about type parameters with extra arguments.
-        if (param.hasExtraArgument()) {
-          return {};
-        }
-        
         // The type should have a key argument unless it's been same-typed
         // to another type.
         if (param.hasKeyArgument()) {
@@ -3057,6 +3052,9 @@ class MetadataReader {
         }
         break;
 
+      case GenericParamKind::TypePack:
+        assert(false && "Packs not supported here yet");
+
       default:
         // We don't know about this kind of parameter.
         return {};

include/swift/Runtime/Metadata.h

@@ -457,7 +457,7 @@ bool swift_compareProtocolConformanceDescriptors(
 /// bit set to true.
 SWIFT_RUNTIME_EXPORT SWIFT_CC(swift)
 const Metadata * const *
-swift_allocateMetadataPack(const Metadata * const *ptr, unsigned count);
+swift_allocateMetadataPack(const Metadata * const *ptr, size_t count);
 
 /// Allocate a witness table pack on the heap, unless this pack is already on
 /// the heap.
@@ -472,7 +472,7 @@ swift_allocateMetadataPack(const Metadata * const *ptr, unsigned count);
 /// significant bit set to true.
 SWIFT_RUNTIME_EXPORT SWIFT_CC(swift)
 const WitnessTable * const *
-swift_allocateWitnessTablePack(const WitnessTable * const *ptr, unsigned count);
+swift_allocateWitnessTablePack(const WitnessTable * const *ptr, size_t count);
 
 /// Fetch a uniqued metadata for a function type.
 SWIFT_RUNTIME_EXPORT