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

@@ -226,6 +226,39 @@ getRuntimeVersionThatSupportsDemanglingType(CanType type) {
       // involving them.
     }
 
+    // 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 needed to demangle them.
+    if (auto nominalTy = dyn_cast<NominalOrBoundGenericNominalType>(t)) {
+      auto *nom = nominalTy->getDecl();
+      if (auto sig = nom->getGenericSignature()) {
+        SmallVector<InverseRequirement, 2> inverses;
+        SmallVector<Requirement, 2> reqs;
+        sig->getRequirementsWithInverses(reqs, inverses);
+        if (!inverses.empty()) {
+          if (!isa<BoundGenericType>(nominalTy))
+            return addRequirement(Swift_6_0);
+
+          // 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()) {
+            for (auto ip : InvertibleProtocolSet::allKnown()) {
+              switch (ip) {
+              case InvertibleProtocolKind::Copyable:
+                if (arg->isNoncopyable())
+                  return addRequirement(Swift_6_0);
+                break;
+              case InvertibleProtocolKind::Escapable:
+                if (!arg->isEscapable())
+                  return addRequirement(Swift_6_0);
+              }
+            }
+          }
+        }
+      }
+    }
+
     return false;
   });
 
@@ -358,6 +391,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: }