[IRGen][backdeploy] fix infinite recursion in metadata queries

One of the places where we ask whether a type's metadata should
be obtained via its mangled name was missing the newer, more
robust checking for minimum deployment target.

Author: kavon

lib/IRGen/GenReflection.cpp

@@ -173,7 +173,7 @@ class PrintMetadataSource
 };
 
 Optional<llvm::VersionTuple>
-swift::irgen::getRuntimeVersionThatSupportsDemanglingType(CanType type) {
+getRuntimeVersionThatSupportsDemanglingType(CanType type) {
   // Associated types of opaque types weren't mangled in a usable form by the
   // Swift 5.1 runtime, so we needed to add a new mangling in 5.2.
   if (type->hasOpaqueArchetype()) {
@@ -278,6 +278,20 @@ getTypeRefByFunction(IRGenModule &IGM,
   return {constant, 6};
 }
 
+bool swift::irgen::mangledNameIsUnknownToDeployTarget(IRGenModule &IGM,
+                                                      CanType type) {
+  if (auto runtimeCompatVersion = getSwiftRuntimeCompatibilityVersionForTarget(
+          IGM.Context.LangOpts.Target)) {
+    if (auto minimumSupportedRuntimeVersion =
+            getRuntimeVersionThatSupportsDemanglingType(type)) {
+      if (*runtimeCompatVersion < *minimumSupportedRuntimeVersion) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
 static std::pair<llvm::Constant *, unsigned>
 getTypeRefImpl(IRGenModule &IGM,
                CanType type,
@@ -294,16 +308,10 @@ 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 (auto runtimeCompatVersion = getSwiftRuntimeCompatibilityVersionForTarget
-                                      (IGM.Context.LangOpts.Target)) {
-      if (auto minimumSupportedRuntimeVersion =
-              getRuntimeVersionThatSupportsDemanglingType(type)) {
-        if (*runtimeCompatVersion < *minimumSupportedRuntimeVersion) {
-          return getTypeRefByFunction(IGM, sig, type);
-        }
-      }
+    if (mangledNameIsUnknownToDeployTarget(IGM, type)) {
+      return getTypeRefByFunction(IGM, sig, type);
     }
-      
+
     break;
 
   case MangledTypeRefRole::Reflection:

lib/IRGen/IRGenMangler.h

@@ -634,10 +634,10 @@ class IRGenMangler : public Mangle::ASTMangler {
   }
 };
 
-/// Does this type require a special minimum Swift runtime version which
-/// supports demangling it?
-Optional<llvm::VersionTuple>
-getRuntimeVersionThatSupportsDemanglingType(CanType type);
+/// 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);
 
 } // end namespace irgen
 } // end namespace swift

lib/IRGen/MetadataRequest.cpp

@@ -2484,7 +2484,11 @@ static bool shouldAccessByMangledName(IRGenModule &IGM, CanType type) {
   // Never access by mangled name if we've been asked not to.
   if (IGM.getOptions().DisableConcreteTypeMetadataMangledNameAccessors)
     return false;
-  
+
+  // Do not access by mangled name if the runtime won't understand it.
+  if (mangledNameIsUnknownToDeployTarget(IGM, type))
+    return false;
+
   // A nongeneric nominal type with nontrivial metadata has an accessor
   // already we can just call.
   if (auto nom = dyn_cast<NominalType>(type)) {
@@ -2494,14 +2498,7 @@ static bool shouldAccessByMangledName(IRGenModule &IGM, CanType type) {
       return false;
     }
   }
-  
-  // The Swift 5.1 runtime fails to demangle associated types of opaque types.
-  if (auto minimumSwiftVersion =
-          getRuntimeVersionThatSupportsDemanglingType(type)) {
-    return IGM.getAvailabilityContext().isContainedIn(
-        IGM.Context.getSwift5PlusAvailability(*minimumSwiftVersion));
-  }
-  
+
   return true;
 
 // The visitor below can be used to fine-tune a heuristic to decide whether