Expect caller heap pack and rename

Fix comment

Author: Azoy

include/swift/Runtime/Metadata.h

@@ -1047,14 +1047,16 @@ void swift_initRawStructMetadata(StructMetadata *self,
                                  int32_t count);
 
 /// Check if the given generic arguments are valid inputs for the generic type
-/// context and if so call the access function to return 
+/// context and if so call the metadata access function and return the metadata.
+///
+/// Note: This expects the caller to heap allocate all pack pointers within the
+/// generic arguments via 'swift_allocateMetadataPack'.
 SWIFT_RUNTIME_STDLIB_SPI
 SWIFT_CC(swift)
-const Metadata *_swift_checkedCreateType(const TypeContextDescriptor *context,
-                                         const void * const *genericArgs,
-                                         size_t genericArgsSize,
-                                         const int32_t *packCounts,
-                                         size_t packCountsSize);
+const Metadata *_swift_instantiateCheckedGenericMetadata(
+    const TypeContextDescriptor *context,
+    const void * const *genericArgs,
+    size_t genericArgsSize);
 
 #pragma clang diagnostic pop
 

stdlib/public/runtime/MetadataLookup.cpp

@@ -2832,45 +2832,25 @@ swift_getOpaqueTypeConformance(const void * const *arguments,
 
 SWIFT_RUNTIME_STDLIB_SPI
 SWIFT_CC(swift)
-const Metadata *swift::_swift_checkedCreateType(const TypeContextDescriptor *context,
-                                                const void * const *genericArgs,
-                                                size_t genericArgsSize,
-                                                const int32_t *packCounts,
-                                                size_t packCountsSize) {
+const Metadata *swift::_swift_instantiateCheckedGenericMetadata(
+    const TypeContextDescriptor *context,
+    const void * const *genericArgs,
+    size_t genericArgsSize) {
   context = swift_auth_data_non_address(
       context, SpecialPointerAuthDiscriminators::ContextDescriptor);
 
   if (!context->isGeneric()) {
     return nullptr;
   }
 
-  if (packCounts && genericArgsSize != packCountsSize) {
-    return nullptr;
-  }
-
-  llvm::SmallVector<MetadataOrPack, 8> fixedGenericArgs;
-
-  // Heap allocate all of the potential stack allocated pack pointers
-  for (size_t i = 0; i != genericArgsSize; i += 1) {
-    // Use -1 to indicate that this is not a pack pointer and instead just
-    // metadata. If we were not passed a packCount array, treat all elements as
-    // if they were just metadata.
-    if ((packCounts && packCounts[i] == -1) || !packCounts) {
-      fixedGenericArgs.push_back(MetadataOrPack(genericArgs[i]));
-      continue;
-    }
-
-    auto packPointer = swift_allocateMetadataPack(
-      reinterpret_cast<const Metadata *const *>(genericArgs[i]), packCounts[i]);
-    fixedGenericArgs.push_back(MetadataOrPack(packPointer));
-  }
-
   DemanglerForRuntimeTypeResolution<StackAllocatedDemangler<2048>> demangler;
 
+  llvm::ArrayRef<MetadataOrPack> genericArgsRef(
+      reinterpret_cast<const MetadataOrPack *>(genericArgs), genericArgsSize);
   llvm::SmallVector<unsigned, 8> genericParamCounts;
   llvm::SmallVector<const void *, 8> allGenericArgs;
 
-  auto result = _gatherGenericParameters(context, fixedGenericArgs,
+  auto result = _gatherGenericParameters(context, genericArgsRef,
                                          /* parent */ nullptr,
                                          genericParamCounts, allGenericArgs,
                                          demangler);

test/Runtime/check_create_type.swift

@@ -13,13 +13,17 @@ struct Variadic<each T> {
   struct Nested<U, each V: Equatable> {}
 }
 
-@_silgen_name("_swift_checkedCreateType")
-func _checkedCreateType(
+@_silgen_name("swift_allocateMetadataPack")
+func allocateMetadataPack(
+  _ packPointer: UnsafeRawPointer,
+  _ packCount: UInt
+) -> UnsafeRawPointer
+
+@_silgen_name("_swift_instantiateCheckedGenericMetadata")
+func _instantiateCheckedGenericMetadata(
   _ descriptor: UnsafeRawPointer,
   _ genericArgs: UnsafeRawPointer,
-  _ genericArgsSize: UInt,
-  _ packCounts: UnsafeRawPointer?,
-  _ packCountsSize: UInt
+  _ genericArgsSize: UInt
 ) -> Any.Type?
 
 func metaPointer(_ x: Any.Type) -> UnsafeRawPointer {
@@ -39,12 +43,10 @@ testSuite.test("_swift_checkedCreateType non-variadic") {
   let dictGenericArgs: [Any.Type] = [String.self, Double.self]
 
   dictGenericArgs.withUnsafeBufferPointer {
-    let newDict = _checkedCreateType(
+    let newDict = _instantiateCheckedGenericMetadata(
       dictDesc,
       UnsafeRawPointer($0.baseAddress!),
-      UInt($0.count),
-      nil,
-      0
+      UInt($0.count)
     )
 
     expectTrue(newDict == [String: Double].self)
@@ -62,23 +64,22 @@ testSuite.test("_swift_checkedCreateType variadic") {
   )
 
   let variPack: [Any.Type] = [Int.self, Int8.self, UInt8.self]
-  let variPackCounts: [Int32] = [3]
 
   variPack.withUnsafeBufferPointer { pack in
-    let genericArgs = [UnsafeRawPointer(pack.baseAddress!)]
+    let packPointer = allocateMetadataPack(
+      UnsafeRawPointer(pack.baseAddress!),
+      UInt(pack.count)
+    )
+    let genericArgs = [packPointer]
 
     genericArgs.withUnsafeBufferPointer { genericArgs in
-      variPackCounts.withUnsafeBufferPointer { packCounts in
-        let newVari = _checkedCreateType(
-          variDesc,
-          UnsafeRawPointer(genericArgs.baseAddress!),
-          UInt(genericArgs.count),
-          UnsafeRawPointer(packCounts.baseAddress!),
-          UInt(packCounts.count)
-        )
+      let newVari = _instantiateCheckedGenericMetadata(
+        variDesc,
+        UnsafeRawPointer(genericArgs.baseAddress!),
+        UInt(genericArgs.count)
+      )
 
-        expectTrue(newVari == Variadic<Int, Int8, UInt8>.self)
-      }
+      expectTrue(newVari == Variadic<Int, Int8, UInt8>.self)
     }
   }
 }
@@ -100,26 +101,26 @@ testSuite.test("_swift_checkedCreateType variadic nested with requirements") {
   nestedPack.withUnsafeBufferPointer { nestedPack in
     variPack.withUnsafeBufferPointer { variPack in
       let nestedGenericArgs = [
-        UnsafeRawPointer(variPack.baseAddress!),
+        allocateMetadataPack(
+          UnsafeRawPointer(variPack.baseAddress!),
+          UInt(variPack.count)
+        ),
         metaPointer(Int16.self),
-        UnsafeRawPointer(nestedPack.baseAddress!)
+        allocateMetadataPack(
+          UnsafeRawPointer(nestedPack.baseAddress!),
+          UInt(nestedPack.count)
+        )
       ]
 
       nestedGenericArgs.withUnsafeBufferPointer { nestedGenericArgs in
-        // 3 for each T, -1 for U, and 3 for each V
-        let nestedPackCounts: [Int32] = [3, -1, 3]
-
-        nestedPackCounts.withUnsafeBufferPointer { nestedPackCounts in
-          let newNested = _checkedCreateType(
-            nestedDesc,
-            UnsafeRawPointer(nestedGenericArgs.baseAddress!),
-            UInt(nestedGenericArgs.count),
-            UnsafeRawPointer(nestedPackCounts.baseAddress!),
-            UInt(nestedPackCounts.count)
-          )
-
-          expectTrue(newNested == Variadic<String, [Int], UInt64>.Nested<Int16, Int, Substring, Bool>.self)
-        }
+
+        let newNested = _instantiateCheckedGenericMetadata(
+          nestedDesc,
+          UnsafeRawPointer(nestedGenericArgs.baseAddress!),
+          UInt(nestedGenericArgs.count)
+        )
+
+        expectTrue(newNested == Variadic<String, [Int], UInt64>.Nested<Int16, Int, Substring, Bool>.self)
       }
     }
   }