Merge pull request #38986 from varungandhi-apple/vg-refactor-runtime-version-check

[IRGen] De-duplicate implementations of minimum OS versions supporting mangling.

Author: varungandhi-apple

include/swift/AST/ASTContext.h

@@ -769,6 +769,11 @@ class ASTContext final {
   /// compiler for the target platform.
   AvailabilityContext getSwift56Availability();
 
+  // Note: Update this function if you add a new getSwiftXYAvailability above.
+  /// Get the runtime availability for a particular version of Swift (5.0+).
+  AvailabilityContext
+  getSwift5PlusAvailability(llvm::VersionTuple swiftVersion);
+
   /// Get the runtime availability of features that have been introduced in the
   /// Swift compiler for future versions of the target platform.
   AvailabilityContext getSwiftFutureAvailability();

lib/AST/Availability.cpp

@@ -457,3 +457,21 @@ AvailabilityContext ASTContext::getSwiftFutureAvailability() {
     return AvailabilityContext::alwaysAvailable();
   }
 }
+
+AvailabilityContext
+ASTContext::getSwift5PlusAvailability(llvm::VersionTuple swiftVersion) {
+  if (swiftVersion.getMajor() == 5) {
+    switch (*swiftVersion.getMinor()) {
+    case 0: return getSwift50Availability();
+    case 1: return getSwift51Availability();
+    case 2: return getSwift52Availability();
+    case 3: return getSwift53Availability();
+    case 4: return getSwift54Availability();
+    case 5: return getSwift55Availability();
+    case 6: return getSwift56Availability();
+    default: break;
+    }
+  }
+  llvm::report_fatal_error("Missing call to getSwiftXYAvailability for Swift " +
+                           swiftVersion.getAsString());
+}

lib/IRGen/GenReflection.cpp

@@ -172,11 +172,8 @@ class PrintMetadataSource
   }
 };
 
-// Return the minimum Swift runtime version that supports demangling a given
-// type.
-static llvm::VersionTuple
-getRuntimeVersionThatSupportsDemanglingType(IRGenModule &IGM,
-                                            CanType type) {
+Optional<llvm::VersionTuple>
+swift::irgen::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()) {
@@ -194,8 +191,7 @@ getRuntimeVersionThatSupportsDemanglingType(IRGenModule &IGM,
     // guards, so we don't need to limit availability of mangled names
     // involving them.
   }
-  
-  return llvm::VersionTuple(5, 0);
+  return None;
 }
 
 // Produce a fallback mangled type name that uses an open-coded callback
@@ -289,9 +285,11 @@ getTypeRefImpl(IRGenModule &IGM,
     // symbolic reference with a callback function.
     if (auto runtimeCompatVersion = getSwiftRuntimeCompatibilityVersionForTarget
                                       (IGM.Context.LangOpts.Target)) {
-      if (*runtimeCompatVersion <
-            getRuntimeVersionThatSupportsDemanglingType(IGM, type)) {
-        return getTypeRefByFunction(IGM, sig, type);
+      if (auto minimumSupportedRuntimeVersion =
+              getRuntimeVersionThatSupportsDemanglingType(type)) {
+        if (*runtimeCompatVersion < *minimumSupportedRuntimeVersion) {
+          return getTypeRefByFunction(IGM, sig, type);
+        }
       }
     }
 

lib/IRGen/IRGenMangler.h

@@ -650,6 +650,11 @@ 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);
+
 } // end namespace irgen
 } // end namespace swift
 

lib/IRGen/MetadataRequest.cpp

@@ -2487,18 +2487,10 @@ static bool shouldAccessByMangledName(IRGenModule &IGM, CanType type) {
   }
 
   // The Swift 5.1 runtime fails to demangle associated types of opaque types.
-  if (!IGM.getAvailabilityContext().isContainedIn(IGM.Context.getSwift52Availability())) {
-    auto hasNestedOpaqueArchetype = type.findIf([](CanType sub) -> bool {
-      if (auto archetype = dyn_cast<NestedArchetypeType>(sub)) {
-        if (isa<OpaqueTypeArchetypeType>(archetype->getRoot())) {
-          return true;
-        }
-      }
-      return false;
-    });
-    
-    if (hasNestedOpaqueArchetype)
-      return false;
+  if (auto minimumSwiftVersion =
+          getRuntimeVersionThatSupportsDemanglingType(type)) {
+    return IGM.getAvailabilityContext().isContainedIn(
+        IGM.Context.getSwift5PlusAvailability(*minimumSwiftVersion));
   }
 
   return true;