Merge pull request #69115 from Azoy/revert-thing

Revert "Merge pull request #68844 from Azoy/gather-no-parameters"

Author: Azoy

stdlib/public/runtime/MetadataLookup.cpp

@@ -2876,29 +2876,17 @@ const Metadata *swift::_swift_instantiateCheckedGenericMetadata(
     return nullptr;
   }
 
-  llvm::SmallVector<const void *, 8> extraArguments;
-
-  for (size_t i = 0; i != genericArgsSize; i += 1) {
-    extraArguments.push_back(genericArgs[i]);
-  }
+  DemanglerForRuntimeTypeResolution<StackAllocatedDemangler<2048>> demangler;
 
-  // Check whether the generic requirements are satisfied, collecting
-  // any extra arguments we need for the instantiation function.
-  //
-  // Note: The extra arguemnts provided are not complete and do not include
-  // witness tables. This is fine for _checkGenericRequirements because it does
-  // not look for any of those.
-  SubstGenericParametersFromMetadata substitutions(context, extraArguments.data());
+  llvm::ArrayRef<MetadataOrPack> genericArgsRef(
+      reinterpret_cast<const MetadataOrPack *>(genericArgs), genericArgsSize);
+  llvm::SmallVector<unsigned, 8> genericParamCounts;
+  llvm::SmallVector<const void *, 8> allGenericArgs;
 
-  auto result = _checkGenericRequirements(
-      context->getGenericContext()->getGenericRequirements(), extraArguments,
-      [&substitutions](unsigned depth, unsigned index) {
-        return substitutions.getMetadata(depth, index).Ptr;
-      },
-      [](const Metadata *type, unsigned index) {
-        // In fact, just don't offer any witness tables if asked for one.
-        return nullptr;
-      }, /* allowsUnresolvedSubject */ true);
+  auto result = _gatherGenericParameters(context, genericArgsRef,
+                                         /* parent */ nullptr,
+                                         genericParamCounts, allGenericArgs,
+                                         demangler);
 
   // _gatherGenericParameters returns llvm::None on success.
   if (result.hasValue()) {
@@ -2907,7 +2895,7 @@ const Metadata *swift::_swift_instantiateCheckedGenericMetadata(
 
   auto accessFunction = context->getAccessFunction();
 
-  return accessFunction(MetadataState::Complete, extraArguments).Value;
+  return accessFunction(MetadataState::Complete, allGenericArgs).Value;
 }
 
 #if SWIFT_OBJC_INTEROP

stdlib/public/runtime/Private.h

@@ -523,8 +523,7 @@ class TypeInfo {
       llvm::ArrayRef<GenericRequirementDescriptor> requirements,
       llvm::SmallVectorImpl<const void *> &extraArguments,
       SubstGenericParameterFn substGenericParam,
-      SubstDependentWitnessTableFn substWitnessTable,
-      bool allowsUnresolvedSubject = false);
+      SubstDependentWitnessTableFn substWitnessTable);
 
   /// A helper function which avoids performing a store if the destination
   /// address already contains the source value.  This is useful when

stdlib/public/runtime/ProtocolConformance.cpp

@@ -1344,37 +1344,24 @@ static llvm::Optional<TypeLookupError>
 checkGenericRequirement(const GenericRequirementDescriptor &req,
                         llvm::SmallVectorImpl<const void *> &extraArguments,
                         SubstGenericParameterFn substGenericParam,
-                        SubstDependentWitnessTableFn substWitnessTable,
-                        bool allowsUnresolvedSubject) {
+                        SubstDependentWitnessTableFn substWitnessTable) {
   assert(!req.getFlags().isPackRequirement());
 
   // Make sure we understand the requirement we're dealing with.
   if (!req.hasKnownKind())
     return TypeLookupError("unknown kind");
 
-  const Metadata *subjectType = nullptr;
-
   // Resolve the subject generic parameter.
   auto result = swift_getTypeByMangledName(
       MetadataState::Abstract, req.getParam(), extraArguments.data(),
       substGenericParam, substWitnessTable);
-
-  if (!allowsUnresolvedSubject && result.isError()) {
+  if (result.getError())
     return *result.getError();
-  }
-
-  if (!result.isError()) {
-    subjectType = result.getType().getMetadata();
-  }
+  const Metadata *subjectType = result.getType().getMetadata();
 
   // Check the requirement.
   switch (req.getKind()) {
   case GenericRequirementKind::Protocol: {
-    // Protocol requirements _require_ a subject type.
-    if (result.isError()) {
-      return *result.getError();
-    }
-
     const WitnessTable *witnessTable = nullptr;
     if (!_conformsToProtocol(nullptr, subjectType, req.getProtocol(),
                              &witnessTable)) {
@@ -1395,37 +1382,16 @@ checkGenericRequirement(const GenericRequirementDescriptor &req,
   }
 
   case GenericRequirementKind::SameType: {
-    // Same type requirements don't require a valid subject.
-
-    const Metadata *sameType = nullptr;
-
     // Demangle the second type under the given substitutions.
     auto result = swift_getTypeByMangledName(
         MetadataState::Abstract, req.getMangledTypeName(),
         extraArguments.data(), substGenericParam, substWitnessTable);
-
-    if (!allowsUnresolvedSubject && result.isError()) {
+    if (result.getError())
       return *result.getError();
-    }
-
-    if (!result.isError()) {
-      sameType = result.getType().getMetadata();
-    }
-
-    // If we don't have one of either the subject type or the same type and we
-    // have the other, then return this as a success. This assumes the given
-    // extra arguments have provided only the required key arguments in which
-    // case some same type constraints may concretize some generic arguments
-    // making them non-key.
-    //
-    // Note: We don't need to check for allowsUnresolvedSubject here because
-    // these can only be null in the case where we do allow it.
-    if ((!subjectType && sameType) || (subjectType && !sameType)) {
-      return llvm::None;
-    }
+    auto otherType = result.getType().getMetadata();
 
     // Check that the types are equivalent.
-    if (subjectType != sameType) {
+    if (subjectType != otherType) {
       return TYPE_LOOKUP_ERROR_FMT(
           "subject type %.*s does not match %.*s", (int)req.getParam().size(),
           req.getParam().data(), (int)req.getMangledTypeName().size(),
@@ -1436,20 +1402,10 @@ checkGenericRequirement(const GenericRequirementDescriptor &req,
   }
 
   case GenericRequirementKind::Layout: {
-    // Layout requirements _require_ a subject type.
-    if (result.isError()) {
-      return *result.getError();
-    }
-
     return satisfiesLayoutConstraint(req, subjectType);
   }
 
   case GenericRequirementKind::BaseClass: {
-    // Base class requirements _require_ a subject type.
-    if (result.isError()) {
-      return *result.getError();
-    }
-
     // Demangle the base type under the given substitutions.
     auto result = swift_getTypeByMangledName(
         MetadataState::Abstract, req.getMangledTypeName(),
@@ -1638,8 +1594,7 @@ llvm::Optional<TypeLookupError> swift::_checkGenericRequirements(
     llvm::ArrayRef<GenericRequirementDescriptor> requirements,
     llvm::SmallVectorImpl<const void *> &extraArguments,
     SubstGenericParameterFn substGenericParam,
-    SubstDependentWitnessTableFn substWitnessTable,
-    bool allowsUnresolvedSubject) {
+    SubstDependentWitnessTableFn substWitnessTable) {
   for (const auto &req : requirements) {
     if (req.getFlags().isPackRequirement()) {
       auto error = checkGenericPackRequirement(req, extraArguments,
@@ -1650,8 +1605,7 @@ llvm::Optional<TypeLookupError> swift::_checkGenericRequirements(
     } else {
       auto error = checkGenericRequirement(req, extraArguments,
                                            substGenericParam,
-                                           substWitnessTable,
-                                           allowsUnresolvedSubject);
+                                           substWitnessTable);
       if (error)
         return error;
     }

test/Runtime/check_create_type.swift

@@ -30,7 +30,7 @@ func metaPointer(_ x: Any.Type) -> UnsafeRawPointer {
   unsafeBitCast(x, to: UnsafeRawPointer.self)
 }
 
-testSuite.test("_swift_instantiateCheckedGenericMetadata non-variadic") {
+testSuite.test("_swift_checkedCreateType non-variadic") {
   let dictMeta = unsafeBitCast(
     [Int: Int].self as Any.Type,
     to: UnsafeRawPointer.self
@@ -53,7 +53,7 @@ testSuite.test("_swift_instantiateCheckedGenericMetadata non-variadic") {
   }
 }
 
-testSuite.test("_swift_instantiateCheckedGenericMetadata variadic") {
+testSuite.test("_swift_checkedCreateType variadic") {
   let variMeta = unsafeBitCast(
     Variadic< >.self as Any.Type,
     to: UnsafeRawPointer.self
@@ -70,9 +70,7 @@ testSuite.test("_swift_instantiateCheckedGenericMetadata variadic") {
       UnsafeRawPointer(pack.baseAddress!),
       UInt(pack.count)
     )
-
-    // The 3 is the shape of the pack
-    let genericArgs = [UnsafeRawPointer(bitPattern: 3)!, packPointer]
+    let genericArgs = [packPointer]
 
     genericArgs.withUnsafeBufferPointer { genericArgs in
       let newVari = _instantiateCheckedGenericMetadata(
@@ -86,7 +84,7 @@ testSuite.test("_swift_instantiateCheckedGenericMetadata variadic") {
   }
 }
 
-testSuite.test("_swift_instantiateCheckedGenericMetadata variadic nested with requirements") {
+testSuite.test("_swift_checkedCreateType variadic nested with requirements") {
   let nestedMeta = unsafeBitCast(
     Variadic< >.Nested<()>.self as Any.Type,
     to: UnsafeRawPointer.self
@@ -103,10 +101,6 @@ testSuite.test("_swift_instantiateCheckedGenericMetadata variadic nested with re
   nestedPack.withUnsafeBufferPointer { nestedPack in
     variPack.withUnsafeBufferPointer { variPack in
       let nestedGenericArgs = [
-        // First shape class
-        UnsafeRawPointer(bitPattern: 3)!,
-        // Second shape class
-        UnsafeRawPointer(bitPattern: 3)!,
         allocateMetadataPack(
           UnsafeRawPointer(variPack.baseAddress!),
           UInt(variPack.count)
@@ -132,53 +126,4 @@ testSuite.test("_swift_instantiateCheckedGenericMetadata variadic nested with re
   }
 }
 
-struct Generic<T> {}
-struct Generic2<T, U> {}
-
-extension Generic where T == Int {
-  struct Nested {}
-}
-
-extension Generic2 where T == U? {
-  struct Nested {}
-}
-
-testSuite.test("_swift_instantiateCheckedGenericMetadata concrete generic types (same type conretized)") {
-  let nestedMeta1 = metaPointer(Generic<Int>.Nested.self)
-  let nestedDesc1 = nestedMeta1.load(
-    fromByteOffset: MemoryLayout<Int>.size,
-    as: UnsafeRawPointer.self
-  )
-
-  let genericArgs1: [UnsafeRawPointer?] = []
-
-  genericArgs1.withUnsafeBufferPointer {
-    let nested = _instantiateCheckedGenericMetadata(
-      nestedDesc1,
-      UnsafeRawPointer($0.baseAddress!),
-      UInt($0.count)
-    )
-
-    expectTrue(nested == Generic<Int>.Nested.self)
-  }
-
-  let nestedMeta2 = metaPointer(Generic2<Int?, Int>.Nested.self)
-  let nestedDesc2 = nestedMeta2.load(
-    fromByteOffset: MemoryLayout<Int>.size,
-    as: UnsafeRawPointer.self
-  )
-
-  let genericArgs2 = [metaPointer(String.self)]
-
-  genericArgs2.withUnsafeBufferPointer {
-    let nested = _instantiateCheckedGenericMetadata(
-      nestedDesc2,
-      UnsafeRawPointer($0.baseAddress!),
-      UInt($0.count)
-    )
-
-    expectTrue(nested == Generic2<String?, String>.Nested.self)
-  }
-}
-
 runAllTests()