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/GenMeta.cpp

@@ -7003,7 +7003,7 @@ static void addGenericRequirement(IRGenModule &IGM, ConstantStructBuilder &B,
     ++metadata.NumGenericKeyArguments;
 
   B.addInt(IGM.Int32Ty, flags.getIntValue());
-  addRelativeAddressOfTypeRef(IGM, B, paramType, nullptr);
+  addRelativeAddressOfTypeRef(IGM, B, paramType, sig);
   addReference();
 }
 

lib/IRGen/GenReflection.cpp

@@ -176,7 +176,8 @@ class PrintMetadataSource
 };
 
 std::optional<llvm::VersionTuple>
-getRuntimeVersionThatSupportsDemanglingType(CanType type) {
+getRuntimeVersionThatSupportsDemanglingType(CanGenericSignature sig,
+                                            CanType type) {
   enum VersionRequirement {
     None,
     Swift_5_2,
@@ -197,6 +198,19 @@ getRuntimeVersionThatSupportsDemanglingType(CanType type) {
   };
 
   (void) type.findIf([&](CanType t) -> bool {
+    if (auto gtpt = dyn_cast<GenericTypeParamType>(t)) {
+      assert(sig && "no signature for generic parameter?");
+      auto &ctx = sig->getASTContext();
+
+      // Check for conformance to all invertible protocols. If conformance is
+      // missing, then we'd mangle the absence as an inverse requirement.
+      for (auto ip : InvertibleProtocolSet::allKnown()) {
+        auto kp = getKnownProtocolKind(ip);
+       if (!sig->requiresProtocol(gtpt, ctx.getProtocol(kp)))
+         return addRequirement(Swift_6_0);
+      }
+    }
+
     if (auto fn = dyn_cast<AnyFunctionType>(t)) {
       // The Swift 6.0 runtime is the first version able to demangle types
       // that involve typed throws or @isolated(any), or for that matter
@@ -226,6 +240,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 +405,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);
       }
@@ -378,11 +426,12 @@ getTypeRefByFunction(IRGenModule &IGM,
 }
 
 bool swift::irgen::mangledNameIsUnknownToDeployTarget(IRGenModule &IGM,
+                                                      CanGenericSignature sig,
                                                       CanType type) {
   if (auto runtimeCompatVersion = getSwiftRuntimeCompatibilityVersionForTarget(
           IGM.Context.LangOpts.Target)) {
     if (auto minimumSupportedRuntimeVersion =
-            getRuntimeVersionThatSupportsDemanglingType(type)) {
+            getRuntimeVersionThatSupportsDemanglingType(sig, type)) {
       if (*runtimeCompatVersion < *minimumSupportedRuntimeVersion) {
         return true;
       }
@@ -450,7 +499,7 @@ getTypeRefImpl(IRGenModule &IGM,
     // If the minimum deployment target's runtime demangler wouldn't understand
     // this mangled name, then fall back to generating a "mangled name" with a
     // symbolic reference with a callback function.
-    if (mangledNameIsUnknownToDeployTarget(IGM, type)) {
+    if (mangledNameIsUnknownToDeployTarget(IGM, sig, type)) {
       return getTypeRefByFunction(IGM, sig, type);
     }
 

lib/IRGen/IRGenMangler.h

@@ -728,7 +728,9 @@ class IRGenMangler : public Mangle::ASTMangler {
 /// Determines if the minimum deployment target's runtime demangler will not
 /// understand the mangled name for the given type.
 /// \returns true iff the target's runtime does not understand the mangled name.
-bool mangledNameIsUnknownToDeployTarget(IRGenModule &IGM, CanType type);
+bool mangledNameIsUnknownToDeployTarget(IRGenModule &IGM,
+                                        CanGenericSignature sig,
+                                        CanType type);
 
 } // end namespace irgen
 } // end namespace swift

lib/IRGen/MetadataRequest.cpp

@@ -2933,7 +2933,7 @@ static bool shouldAccessByMangledName(IRGenModule &IGM, CanType type) {
     return false;
 
   // Do not access by mangled name if the runtime won't understand it.
-  if (mangledNameIsUnknownToDeployTarget(IGM, type))
+  if (mangledNameIsUnknownToDeployTarget(IGM, /*sig=*/nullptr, type))
     return false;
 
   // A nongeneric nominal type with nontrivial metadata has an accessor

test/Backdeploy/Noncopyable/mangling.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: }

test/IRGen/reflection_metadata_noncopyable.swift

@@ -0,0 +1,19 @@
+// RUN: %target-swift-frontend -emit-ir -target %target-cpu-apple-macos99.99 %s \
+// RUN:     | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-PRESENT %s
+
+// RUN: %target-swift-frontend -emit-ir -target %target-cpu-apple-macos14.4 %s \
+// RUN:     | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-OLDER %s
+
+// REQUIRES: OS=macosx
+// UNSUPPORTED: CPU=arm64e
+
+public struct MyStruct<T: ~Copyable> {
+  let fn: (borrowing T) -> ()
+}
+
+// Make sure that we only emit a demangling-based type description
+// for noncopyable generic parameters when deploying to runtimes supporting it.
+
+// CHECK-LABEL: @"$s31reflection_metadata_noncopyable8MyStructVMF" = internal constant
+// CHECK-PRESENT-SAME: ptr @"symbolic yxc"
+// CHECK-OLDER-SAME: ptr @"get_type_metadata Ri_zlyxc.2"