Generate getSwiftRuntimeCompatibilityVersionForTarget from

RuntimeVersions.def.

NFC except that it no longer treats arbitrary versions in the future as
non-deployment-limited; you have to specifically use a future release to
get that behavior.

Author: rjmccall

lib/Basic/Platform.cpp

@@ -431,147 +431,139 @@ llvm::Triple swift::getUnversionedTriple(const llvm::Triple &triple) {
                       unversionedOSName);
 }
 
+namespace {
+
+enum class Platform {
+  macOS,
+  iOS,
+  watchOS,
+  visionOS
+};
+
+/// A specific platform release.
+struct PlatformRelease {
+  Platform platform;
+  llvm::VersionTuple version;
+};
+
+struct SwiftRelease {
+  /// The release version of the Swift runtime.
+  llvm::VersionTuple version;
+
+  /// Platform releases that provide this release of the Swift runtime.
+  std::initializer_list<PlatformRelease> providers;
+};
+
+} // end anonymous namespace
+
+// TODO: do some constexpr trickery to split these out by platform
+static constexpr SwiftRelease swiftReleases[] = {
+#define PLATFORM(NAME, VERSION)     \
+      {                             \
+        Platform::NAME,             \
+        llvm::VersionTuple VERSION  \
+      },
+#define FUTURE
+#define RUNTIME_VERSION(SWIFT_TUPLE, PROVIDERS) \
+  {                                             \
+    llvm::VersionTuple SWIFT_TUPLE,             \
+    {                                           \
+      PROVIDERS                                 \
+    }                                           \
+  },
+#include "swift/AST/RuntimeVersions.def"
+};
+
+/// Return the highest Swift release that matches the given platform and
+/// has a version no greater than the target version. Don't return a version
+/// older that the minimum. Returns null if the target version matches the
+/// notional future release version.
+static std::optional<llvm::VersionTuple>
+findSwiftRuntimeVersion(Platform targetPlatform,
+                        llvm::VersionTuple targetVersion,
+                        llvm::VersionTuple minimumRelease) {
+  #define MAX(a, b) ((a) > (b) ? (a) : (b))
+
+  // Just do a simple reverse scan for now.
+  for (auto &swiftRelease : llvm::reverse(llvm::ArrayRef(swiftReleases))) {
+    for (auto &provider : swiftRelease.providers) {
+      // If the provider version is <= the deployment target, then
+      // the deployment target includes support for the given Swift
+      // release. Since we're scanning in reverse order of Swift
+      // releases (because of the order of entries in RuntimeVersions.def),
+      // this must be the highest supported Swift release.
+      if (provider.platform == targetPlatform &&
+          provider.version <= targetVersion) {
+        return MAX(swiftRelease.version, minimumRelease);
+      }
+    }
+  }
+
+  // If we didn't find anything, but the target release is at least the
+  // notional future-release version, return that we aren't
+  // deployment-limited.
+  if (targetVersion >= llvm::VersionTuple(99, 99))
+    return std::nullopt;
+
+  // Otherwise, return the minimum release.
+  return minimumRelease;
+}
+
 std::optional<llvm::VersionTuple>
 swift::getSwiftRuntimeCompatibilityVersionForTarget(
     const llvm::Triple &Triple) {
-#define MAX(a, b) ((a) > (b) ? (a) : (b))
 
   if (Triple.isMacOSX()) {
     llvm::VersionTuple OSVersion;
     Triple.getMacOSXVersion(OSVersion);
-    unsigned Major = OSVersion.getMajor();
-    unsigned Minor = OSVersion.getMinor().value_or(0);
-
-    auto floorFor64 = [&Triple](llvm::VersionTuple v) {
-      if (!Triple.isAArch64()) return v;
-      // macOS got first arm64(e) support in 11.0, i.e. VersionTuple(5, 3)
-      return MAX(v, llvm::VersionTuple(5, 3));
-    };
-
-    if (Major == 10) {
-      if (Triple.isAArch64() && Minor <= 16)
-        return floorFor64(llvm::VersionTuple(5, 3));
-
-      if (Minor <= 14) {
-        return floorFor64(llvm::VersionTuple(5, 0));
-      } else if (Minor <= 15) {
-        if (OSVersion.getSubminor().value_or(0) <= 3) {
-          return floorFor64(llvm::VersionTuple(5, 1));
-        } else {
-          return floorFor64(llvm::VersionTuple(5, 2));
-        }
-      }
-    } else if (Major == 11) {
-      if (Minor <= 2)
-        return floorFor64(llvm::VersionTuple(5, 3));
-      return floorFor64(llvm::VersionTuple(5, 4));
-    } else if (Major == 12) {
-      if (Minor <= 2)
-        return floorFor64(llvm::VersionTuple(5, 5));
-      return floorFor64(llvm::VersionTuple(5, 6));
-    } else if (Major == 13) {
-      if (Minor <= 2)
-        return floorFor64(llvm::VersionTuple(5, 7));
-      return floorFor64(llvm::VersionTuple(5, 8));
-    } else if (Major == 14) {
-      if (Minor <= 3)
-        return floorFor64(llvm::VersionTuple(5, 9));
-      return floorFor64(llvm::VersionTuple(5, 10));
-    }
+
+    // macOS releases predate the stable ABI, so use Swift 5.0 as our base.
+    auto baseRelease = llvm::VersionTuple(5, 0);
+
+    // macOS got its first arm64(e) support in 11.0, which included Swift 5.3.
+    if (Triple.isAArch64())
+      baseRelease = llvm::VersionTuple(5, 3);
+
+    return findSwiftRuntimeVersion(Platform::macOS, OSVersion, baseRelease);
+
   } else if (Triple.isiOS()) { // includes tvOS
     llvm::VersionTuple OSVersion = Triple.getiOSVersion();
-    unsigned Major = OSVersion.getMajor();
-    unsigned Minor = OSVersion.getMinor().value_or(0);
-
-    auto floorForArchitecture = [&Triple, Major](llvm::VersionTuple v) {
-      // arm64 simulators and macCatalyst are introduced in iOS 14.0/tvOS 14.0
-      // with Swift 5.3
-      if (Triple.isAArch64() && Major <= 14 &&
-          (Triple.isSimulatorEnvironment() ||
-           Triple.isMacCatalystEnvironment()))
-        return MAX(v, llvm::VersionTuple(5, 3));
-
-      if (Triple.getArchName() != "arm64e") return v;
-
-      // iOS got first arm64e support in 12.0, which has a Swift runtime version
-      // older than 5.0, so let's floor at VersionTuple(5, 0) instead.
-      return MAX(v, llvm::VersionTuple(5, 0));
-    };
-
-    if (Major <= 12) {
-      return floorForArchitecture(llvm::VersionTuple(5, 0));
-    } else if (Major <= 13) {
-      if (Minor <= 3) {
-        return floorForArchitecture(llvm::VersionTuple(5, 1));
-      } else {
-        return floorForArchitecture(llvm::VersionTuple(5, 2));
-      }
-    } else if (Major <= 14) {
-      if (Minor <= 4)
-        return floorForArchitecture(llvm::VersionTuple(5, 3));
-
-      return floorForArchitecture(llvm::VersionTuple(5, 4));
-    } else if (Major <= 15) {
-      if (Minor <= 3)
-        return floorForArchitecture(llvm::VersionTuple(5, 5));
-      return floorForArchitecture(llvm::VersionTuple(5, 6));
-    } else if (Major <= 16) {
-      if (Minor <= 3)
-        return floorForArchitecture(llvm::VersionTuple(5, 7));
-      return floorForArchitecture(llvm::VersionTuple(5, 8));
-    } else if (Major <= 17) {
-      if (Minor <= 3)
-        return floorForArchitecture(llvm::VersionTuple(5, 9));
-      return floorForArchitecture(llvm::VersionTuple(5, 10));
-    }
+
+    // iOS releases predate the stable ABI, so use Swift 5.0 as our base.
+    auto baseRelease = llvm::VersionTuple(5, 0);
+
+    // arm64 simulators and macCatalyst were introduced in iOS 14.0/tvOS 14.0,
+    // which included Swift 5.3.
+    if (Triple.isAArch64() &&
+        (Triple.isSimulatorEnvironment() ||
+         Triple.isMacCatalystEnvironment()))
+      baseRelease = llvm::VersionTuple(5, 3);
+
+    // iOS first got arm64e support in 12.0, which did not yet support the
+    // Swift stable ABI, so it does not provide a useful version bump.
+
+    return findSwiftRuntimeVersion(Platform::iOS, OSVersion, baseRelease);
+
   } else if (Triple.isWatchOS()) {
     llvm::VersionTuple OSVersion = Triple.getWatchOSVersion();
-    unsigned Major = OSVersion.getMajor();
-    unsigned Minor = OSVersion.getMinor().value_or(0);
-
-    auto floorFor64bits = [&Triple](llvm::VersionTuple v) {
-      if (!Triple.isArch64Bit()) return v;
-      // 64-bit watchOS was introduced with Swift 5.3
-      return MAX(v, llvm::VersionTuple(5, 3));
-    };
-
-    if (Major <= 5) {
-      return floorFor64bits(llvm::VersionTuple(5, 0));
-    } else if (Major <= 6) {
-      if (Minor <= 1) {
-        return floorFor64bits(llvm::VersionTuple(5, 1));
-      } else {
-        return floorFor64bits(llvm::VersionTuple(5, 2));
-      }
-    } else if (Major <= 7) {
-      if (Minor <= 3)
-        return floorFor64bits(llvm::VersionTuple(5, 3));
-
-      return floorFor64bits(llvm::VersionTuple(5, 4));
-    } else if (Major <= 8) {
-      if (Minor <= 4)
-        return floorFor64bits(llvm::VersionTuple(5, 5));
-      return floorFor64bits(llvm::VersionTuple(5, 6));
-    } else if (Major <= 9) {
-      if (Minor <= 3)
-        return floorFor64bits(llvm::VersionTuple(5, 7));
-      return floorFor64bits(llvm::VersionTuple(5, 8));
-    } else if (Major <= 10) {
-      if (Minor <= 3)
-        return floorFor64bits(llvm::VersionTuple(5, 9));
-      return floorFor64bits(llvm::VersionTuple(5, 10));
-    }
-  }
-  else if (Triple.isXROS()) {
+
+    // tvOS releases predate the stable ABI, so use Swift 5.0 as our base.
+    auto baseRelease = llvm::VersionTuple(5, 0);
+
+    // 64-bit watchOS was first supported by watchOS 7, which provided
+    // Swift 5.3.
+    if (Triple.isArch64Bit())
+      baseRelease = llvm::VersionTuple(5, 3);
+
+    return findSwiftRuntimeVersion(Platform::watchOS, OSVersion, baseRelease);
+
+  } else if (Triple.isXROS()) {
     llvm::VersionTuple OSVersion = Triple.getOSVersion();
-    unsigned Major = OSVersion.getMajor();
-    unsigned Minor = OSVersion.getMinor().value_or(0);
 
-    if (Major <= 1) {
-      if (Minor <= 0)
-        return llvm::VersionTuple(5, 9);
-      return llvm::VersionTuple(5, 10);
-    }
+    // visionOS 1.0 provided Swift 5.9.
+    auto baseRelease = llvm::VersionTuple(5, 9);
+
+    return findSwiftRuntimeVersion(Platform::visionOS, OSVersion, baseRelease);
   }
 
   return std::nullopt;