NCGenerics: fix runtime demangling strategy

We can obtain metadata on older runtimes for a concrete type with a
Copyable generic parameter via demangling. But if the generic argument
is noncopyable, we should use the metadata response strategy instead.

resolves rdar://131337585

Author: kavon

lib/IRGen/GenReflection.cpp

@@ -175,6 +175,52 @@ class PrintMetadataSource
   }
 };
 
+/// Any nominal type that has an inverse requirement in its generic signature
+/// uses NoncopyableGenerics. Since inverses are mangled into symbols,
+/// a Swift 6.0+ runtime is generally needed to demangle them.
+///
+/// But, if the type is a BoundGenericType, where the generic arguments are all
+/// concrete types that DO conform to ALL invertible protocols (Copyable, etc),
+/// then older runtimes can obtain the metadata via demangling using the
+/// \c swift_instantiateConcreteTypeFromMangledName runtime call.
+///
+/// \returns true if the Swift 6.0+ runtime is needed to demangle this type.
+static bool demanglingNeedsNeedsNoncopyableGenericsAwareness(
+    NominalOrBoundGenericNominalType *nominalTy) {
+  auto *nom = nominalTy->getDecl();
+  if (auto sig = nom->getGenericSignature()) {
+    SmallVector<InverseRequirement, 2> inverses;
+    SmallVector<Requirement, 2> reqs;
+    sig->getRequirementsWithInverses(reqs, inverses);
+    if (!inverses.empty()) { // then it's using NoncopyableGenerics.
+      if (!isa<BoundGenericType>(nominalTy))
+        return true;
+
+      // If all of the generic arguments in this BGT are Copyable/Escapable,
+      // then it should not require the newer runtime.
+      auto boundTy = cast<BoundGenericType>(nominalTy);
+      for (auto arg : boundTy->getGenericArgs()) {
+        // If the BGT is not fully concrete, assume it requires newer runtime.
+        if (arg->hasTypeParameter() || arg->hasUnboundGenericType())
+          return true;
+
+        for (auto ip : InvertibleProtocolSet::allKnown()) {
+          switch (ip) {
+          case InvertibleProtocolKind::Copyable:
+            if (arg->isNoncopyable())
+              return true;
+            break;
+          case InvertibleProtocolKind::Escapable:
+            if (!arg->isEscapable())
+              return true;
+          }
+        }
+      }
+    }
+  }
+  return false; // any runtime is fine
+}
+
 std::optional<llvm::VersionTuple>
 getRuntimeVersionThatSupportsDemanglingType(CanType type) {
   enum VersionRequirement {
@@ -226,6 +272,12 @@ getRuntimeVersionThatSupportsDemanglingType(CanType type) {
       // involving them.
     }
 
+
+    if (auto nominalTy = dyn_cast<NominalOrBoundGenericNominalType>(t)) {
+      if (demanglingNeedsNeedsNoncopyableGenericsAwareness(nominalTy))
+        return addRequirement(Swift_6_0);
+    }
+
     return false;
   });
 
@@ -358,6 +410,7 @@ getTypeRefByFunction(IRGenModule &IGM,
             Address(bindingsBufPtr, IGM.Int8Ty, IGM.getPointerAlignment()),
             MetadataState::Complete, subs);
 
+        substT = substT.getReferenceStorageReferent();
         auto ret = IGF.emitTypeMetadataRef(substT);
         IGF.Builder.CreateRet(ret);
       }

test/IRGen/noncopyable_metadata_requests.swift

@@ -0,0 +1,107 @@
+// RUN: %empty-directory(%t)
+// RUN: %swift-frontend %s -swift-version 6 -module-name main -emit-ir -o %t/new.ir
+// RUN: %FileCheck %s --check-prefix=NEW < %t/new.ir
+// RUN: %target-swift-frontend %s -target %target-cpu-apple-macosx11 -module-name main -emit-ir -o %t/old.ir
+// RUN: %FileCheck %s --check-prefix=OLD < %t/old.ir
+
+// Check that we add extra type metadata accessors for types with generic
+// parameters that have an inverse. These are used instead of using demangling
+// cache variables since old runtimes cannot synthesize type metadata based on
+// the new mangling.
+
+// RUN: %target-build-swift -target %target-cpu-apple-macosx11 %s -o %t/test_mangling
+// RUN: %target-run %t/test_mangling | %FileCheck %s
+
+// REQUIRES: OS=macosx
+// REQUIRES: executable_test
+
+
+// This type's generic parameter is noncopyable, so older runtimes can't
+// demangle the type's name to build the metadata.
+struct Foo<T: ~Copyable>: ~Copyable {
+  mutating func bar(_ i: Int) { print("Foo.bar(\(i))") }
+}
+
+func test() {
+  var foo = Foo<Int>()
+  foo.bar(1)
+}
+test()
+// CHECK: Foo.bar(1)
+
+// NEW: define hidden swiftcc void @"$s4main4testyyF"()
+// NEW-NOT: %swift.metadata_response
+// NEW: call ptr @__swift_instantiateConcreteTypeFromMangledName(ptr @"$s4main3FooVySiGMD")
+// NEW-NOT: %swift.metadata_response
+// NEW: }
+
+// OLD: define hidden swiftcc void @"$s4main4testyyF"()
+// OLD-NOT: %swift.metadata_response
+// OLD: call ptr @__swift_instantiateConcreteTypeFromMangledName(ptr @"$s4main3FooVySiGMD")
+// OLD-NOT: %swift.metadata_response
+// OLD: }
+
+struct NC: ~Copyable {}
+
+// NEW: define hidden swiftcc void @"$s4main10testWithNCyyF"()
+// NEW-NOT: %swift.metadata_response
+// NEW: call ptr @__swift_instantiateConcreteTypeFromMangledName(ptr @"$s4main3FooVyAA2NCVGMD")
+// NEW-NOT: %swift.metadata_response
+// NEW: }
+
+// OLD: define hidden swiftcc void @"$s4main10testWithNCyyF"()
+// OLD-NOT: __swift_instantiateConcreteTypeFromMangledName
+// OLD: call swiftcc %swift.metadata_response @"$s4main3FooVyAA2NCVGMa"(i64 0)
+// OLD-NOT: __swift_instantiateConcreteTypeFromMangledName
+// OLD: }
+func testWithNC() {
+  var foo = Foo<NC>()
+  foo.bar(2)
+}
+testWithNC()
+// CHECK: Foo.bar(2)
+
+
+// NEW: define hidden swiftcc void @"$s4main17testWithNCGenericyyxnRi_zlF"
+// NEW-NOT: __swift_instantiateConcreteTypeFromMangledName
+// NEW: call swiftcc %swift.metadata_response @"$s4main3FooVMa"
+// NEW-NOT: __swift_instantiateConcreteTypeFromMangledName
+// NEW: }
+
+// OLD: define hidden swiftcc void @"$s4main17testWithNCGenericyyxnRi_zlF"
+// OLD-NOT: __swift_instantiateConcreteTypeFromMangledName
+// OLD: call swiftcc %swift.metadata_response @"$s4main3FooVMa"
+// OLD-NOT: __swift_instantiateConcreteTypeFromMangledName
+// OLD: }
+func testWithNCGeneric<T: ~Copyable>(_ t: consuming T) {
+  var foo = Foo<T>()
+  foo.bar(3)
+}
+testWithNCGeneric(Foo<NC>())
+// CHECK: Foo.bar(3)
+
+
+// This type does not need a Swift 6.0 runtime, despite being noncopyable,
+// because it doesn't have a noncopyable generic parameter.
+struct JustNoncopyable<T>: ~Copyable {
+  mutating func bar() { print("JustNoncopyable.bar") }
+}
+
+func testNonGeneric() {
+    var ng = JustNoncopyable<Int>()
+    ng.bar()
+}
+testNonGeneric()
+// CHECK: JustNoncopyable.bar
+
+// NEW: define hidden swiftcc void @"$s4main14testNonGenericyyF"()
+// NEW-NOT: %swift.metadata_response
+// NEW: call ptr @__swift_instantiateConcreteTypeFromMangledName(ptr @"$s4main15JustNoncopyableVySiGMD")
+// NEW-NOT: %swift.metadata_response
+// NEW: }
+
+// OLD: define hidden swiftcc void @"$s4main14testNonGenericyyF"()
+// OLD-NOT: %swift.metadata_response
+// OLD: call ptr @__swift_instantiateConcreteTypeFromMangledName(ptr @"$s4main15JustNoncopyableVySiGMD")
+// OLD-NOT: %swift.metadata_response
+// OLD: }