Merge pull request #82151 from tshortli/rhombicuboctahedron-6.2

[6.2] Upstream support for the Xcode 26 SDKs

Author: tshortli

include/swift/AST/AvailabilityDomain.h

@@ -209,6 +209,10 @@ class AvailabilityDomain final {
   /// version ranges.
   bool isVersioned() const;
 
+  /// Returns true if the given version is a valid version number for this
+  /// domain. It is an error to call this on an un-versioned domain.
+  bool isVersionValid(const llvm::VersionTuple &version) const;
+
   /// Returns true if availability of the domain can be refined using
   /// `@available` attributes and `if #available` queries. If not, then the
   /// domain's availability is fixed by compilation settings. For example,

include/swift/AST/DiagnosticsSema.def

@@ -864,6 +864,14 @@ ERROR(serialization_failed,none,
 WARNING(can_import_invalid_swiftmodule,none,
         "canImport() evaluated to false due to invalid swiftmodule: %0", (StringRef))
 
+ERROR(map_os_version_from_textual_interface_failed,none,
+      "failed to map OS version from %0 to %1 in %2",
+      (StringRef, StringRef, StringRef))
+
+ERROR(target_os_version_from_textual_interface_invalid,none,
+      "invalid target triple %0 in %1",
+      (StringRef, StringRef))
+
 ERROR(serialization_load_failed,Fatal,
       "failed to load module '%0'", (StringRef))
 ERROR(module_interface_build_failed,Fatal,
@@ -6852,6 +6860,9 @@ GROUPED_ERROR(availability_suggest_platform_name,
         (Identifier, StringRef))
 WARNING(availability_unsupported_version_number, none,
         "'%0' is not a supported version number", (llvm::VersionTuple))
+WARNING(availability_invalid_version_number_for_domain, none,
+        "'%0' is not a valid version number for %1",
+        (llvm::VersionTuple, AvailabilityDomain))
 
 WARNING(attr_availability_expected_deprecated_version, none,
        "expected version number with 'deprecated' in '%0' attribute for %1",

include/swift/AST/PlatformKind.h

@@ -21,6 +21,7 @@
 #include "swift/Config.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/VersionTuple.h"
+#include "llvm/TargetParser/Triple.h"
 #include <optional>
 
 namespace swift {
@@ -91,6 +92,10 @@ PlatformKind targetVariantPlatform(const LangOptions &LangOpts);
 /// an explicit attribute for the child.
 bool inheritsAvailabilityFromPlatform(PlatformKind Child, PlatformKind Parent);
 
+/// Returns the LLVM triple OS type for the given platform, if there is one.
+std::optional<llvm::Triple::OSType>
+tripleOSTypeForPlatform(PlatformKind platform);
+
 llvm::VersionTuple canonicalizePlatformVersion(
     PlatformKind platform, const llvm::VersionTuple &version);
 

include/swift/Serialization/SerializedModuleLoader.h

@@ -580,7 +580,8 @@ class SerializedASTFile final : public LoadedFile {
 bool extractCompilerFlagsFromInterface(
     StringRef interfacePath, StringRef buffer, llvm::StringSaver &ArgSaver,
     SmallVectorImpl<const char *> &SubArgs,
-    std::optional<llvm::Triple> PreferredTarget = std::nullopt);
+    std::optional<llvm::Triple> PreferredTarget = std::nullopt,
+    DiagnosticEngine *diagEngine = nullptr);
 
 /// Extract the user module version number from an interface file.
 llvm::VersionTuple extractUserModuleVersionFromInterface(StringRef moduleInterfacePath);

lib/AST/Attr.cpp

@@ -2360,16 +2360,13 @@ static StringRef getLinkerModuleName(StringRef OriginalModuleName) {
 }
 
 OriginallyDefinedInAttr::OriginallyDefinedInAttr(
-    SourceLoc AtLoc, SourceRange Range,
-    StringRef OriginalModuleName,
-    PlatformKind Platform,
-    const llvm::VersionTuple MovedVersion, bool Implicit)
-  : DeclAttribute(DeclAttrKind::OriginallyDefinedIn, AtLoc, Range,
-                  Implicit),
-    ManglingModuleName(getManglingModuleName(OriginalModuleName)),
-    LinkerModuleName(getLinkerModuleName(OriginalModuleName)),
-    Platform(Platform),
-    MovedVersion(MovedVersion) {}
+    SourceLoc AtLoc, SourceRange Range, StringRef OriginalModuleName,
+    PlatformKind Platform, const llvm::VersionTuple MovedVersion, bool Implicit)
+    : DeclAttribute(DeclAttrKind::OriginallyDefinedIn, AtLoc, Range, Implicit),
+      ManglingModuleName(getManglingModuleName(OriginalModuleName)),
+      LinkerModuleName(getLinkerModuleName(OriginalModuleName)),
+      Platform(Platform),
+      MovedVersion(canonicalizePlatformVersion(Platform, MovedVersion)) {}
 
 std::optional<OriginallyDefinedInAttr::ActiveVersion>
 OriginallyDefinedInAttr::isActivePlatform(const ASTContext &ctx) const {

lib/AST/Availability.cpp

@@ -832,14 +832,27 @@ SemanticAvailableAttrRequest::evaluate(swift::Evaluator &evaluator,
 
   auto checkVersion = [&](std::optional<llvm::VersionTuple> version,
                           SourceRange sourceRange) {
-    if (version && !VersionRange::isValidVersion(*version)) {
+    if (!version)
+      return false;
+
+    if (!VersionRange::isValidVersion(*version)) {
       diags
           .diagnose(attrLoc, diag::availability_unsupported_version_number,
                     *version)
           .highlight(sourceRange);
       return true;
     }
 
+    // Warn if the version is not a valid one for the domain. For example, macOS
+    // 17 will never exist.
+    if (domain->isVersioned() && !domain->isVersionValid(*version)) {
+      diags
+          .diagnose(attrLoc,
+                    diag::availability_invalid_version_number_for_domain,
+                    *version, *domain)
+          .highlight(sourceRange);
+    }
+
     return false;
   };
 

lib/AST/AvailabilityDomain.cpp

@@ -109,6 +109,26 @@ bool AvailabilityDomain::isVersioned() const {
   }
 }
 
+bool AvailabilityDomain::isVersionValid(
+    const llvm::VersionTuple &version) const {
+  ASSERT(isVersioned());
+
+  switch (getKind()) {
+  case Kind::Universal:
+  case Kind::Embedded:
+    llvm_unreachable("unexpected domain kind");
+  case Kind::SwiftLanguage:
+  case Kind::PackageDescription:
+    return true;
+  case Kind::Platform:
+    if (auto osType = tripleOSTypeForPlatform(getPlatformKind()))
+      return llvm::Triple::isValidVersionForOS(*osType, version);
+    return true;
+  case Kind::Custom:
+    return true;
+  }
+}
+
 bool AvailabilityDomain::supportsContextRefinement() const {
   switch (getKind()) {
   case Kind::Universal:

lib/AST/PlatformKind.cpp

@@ -263,15 +263,43 @@ bool swift::inheritsAvailabilityFromPlatform(PlatformKind Child,
   return false;
 }
 
-llvm::VersionTuple swift::canonicalizePlatformVersion(
-    PlatformKind platform, const llvm::VersionTuple &version) {
-
-  // Canonicalize macOS version for macOS Big Sur to treat
-  // 10.16 as 11.0.
-  if (platform == PlatformKind::macOS ||
-      platform == PlatformKind::macOSApplicationExtension) {
-    return llvm::Triple::getCanonicalVersionForOS(llvm::Triple::MacOSX,
-                                                  version);
+std::optional<llvm::Triple::OSType>
+swift::tripleOSTypeForPlatform(PlatformKind platform) {
+  switch (platform) {
+  case PlatformKind::macOS:
+  case PlatformKind::macOSApplicationExtension:
+    return llvm::Triple::MacOSX;
+  case PlatformKind::iOS:
+  case PlatformKind::iOSApplicationExtension:
+  case PlatformKind::macCatalyst:
+  case PlatformKind::macCatalystApplicationExtension:
+    return llvm::Triple::IOS;
+  case PlatformKind::tvOS:
+  case PlatformKind::tvOSApplicationExtension:
+    return llvm::Triple::TvOS;
+  case PlatformKind::watchOS:
+  case PlatformKind::watchOSApplicationExtension:
+    return llvm::Triple::WatchOS;
+  case PlatformKind::visionOS:
+  case PlatformKind::visionOSApplicationExtension:
+    return llvm::Triple::XROS;
+  case PlatformKind::OpenBSD:
+    return llvm::Triple::OpenBSD;
+  case PlatformKind::Windows:
+    return llvm::Triple::Win32;
+  case PlatformKind::none:
+    return std::nullopt;
+  }
+  llvm_unreachable("bad PlatformKind");
+}
+
+llvm::VersionTuple
+swift::canonicalizePlatformVersion(PlatformKind platform,
+                                   const llvm::VersionTuple &version) {
+  if (auto osType = tripleOSTypeForPlatform(platform)) {
+    bool isInValidRange = llvm::Triple::isValidVersionForOS(*osType, version);
+    return llvm::Triple::getCanonicalVersionForOS(*osType, version,
+                                                  isInValidRange);
   }
 
   return version;

lib/Frontend/ModuleInterfaceLoader.cpp

@@ -1547,7 +1547,7 @@ static bool readSwiftInterfaceVersionAndArgs(
 
   if (extractCompilerFlagsFromInterface(interfacePath, SB, ArgSaver,
                                         interfaceInfo.Arguments,
-                                        preferredTarget)) {
+                                        preferredTarget, &Diags)) {
     InterfaceSubContextDelegateImpl::diagnose(
         interfacePath, diagnosticLoc, SM, &Diags,
         diag::error_extracting_version_from_module_interface);

lib/Serialization/SerializedModuleLoader.cpp

@@ -1476,30 +1476,70 @@ static std::optional<StringRef> getFlagsFromInterfaceFile(StringRef &file,
 bool swift::extractCompilerFlagsFromInterface(
     StringRef interfacePath, StringRef buffer, llvm::StringSaver &ArgSaver,
     SmallVectorImpl<const char *> &SubArgs,
-    std::optional<llvm::Triple> PreferredTarget) {
+    std::optional<llvm::Triple> PreferredTarget, DiagnosticEngine *Diag) {
   auto FlagMatch = getFlagsFromInterfaceFile(buffer, SWIFT_MODULE_FLAGS_KEY);
   if (!FlagMatch)
     return true;
   llvm::cl::TokenizeGNUCommandLine(*FlagMatch, ArgSaver, SubArgs);
 
-  // If the target triple parsed from the Swift interface file differs
-  // only in subarchitecture from the compatible target triple, then
-  // we have loaded a Swift interface from a different-but-compatible
-  // architecture slice. Use the compatible subarchitecture.
-  if (PreferredTarget) {
-    for (unsigned I = 1; I < SubArgs.size(); ++I) {
-      if (strcmp(SubArgs[I - 1], "-target") != 0 &&
-          strcmp(SubArgs[I - 1], "-target-variant") != 0)
-        continue;
+  for (unsigned I = 1; I < SubArgs.size(); ++I) {
+    if (strcmp(SubArgs[I - 1], "-target") != 0 &&
+        strcmp(SubArgs[I - 1], "-target-variant") != 0)
+      continue;
 
-      llvm::Triple triple(SubArgs[I]);
-      if (triple.getArch() != PreferredTarget->getArch())
-        continue;
-      if (triple.getSubArch() == PreferredTarget->getSubArch())
-        continue;
+    llvm::Triple triple(SubArgs[I]);
+    bool shouldModify = false;
+    // If the target triple parsed from the swiftinterface file differs
+    // only in subarchitecture from the compatible target triple, then
+    // we have loaded a Swift interface from a different-but-compatible
+    // architecture slice. Use the compatible subarchitecture.
+    if (PreferredTarget && triple.getArch() == PreferredTarget->getArch() &&
+        triple.getSubArch() != PreferredTarget->getSubArch()) {
       triple.setArch(PreferredTarget->getArch(), PreferredTarget->getSubArch());
-      SubArgs[I] = ArgSaver.save(triple.str()).data();
+      shouldModify = true;
     }
+
+    // Diagnose if the version in the target triple parsed from the
+    // swiftinterface is invalid for the OS.
+    const llvm::VersionTuple originalVer = triple.getOSVersion();
+    bool isValidVersion =
+        llvm::Triple::isValidVersionForOS(triple.getOS(), originalVer);
+    if (!isValidVersion) {
+      if (Diag) {
+        Diag->diagnose(SourceLoc(),
+                       diag::target_os_version_from_textual_interface_invalid,
+                       triple.str(), interfacePath);
+      }
+      break;
+    }
+
+    // Canonicalize the version in the target triple parsed from the
+    // swiftinterface.
+    llvm::VersionTuple newVer = llvm::Triple::getCanonicalVersionForOS(
+        triple.getOS(), originalVer, isValidVersion);
+    if (originalVer != newVer) {
+      std::string originalOSName = triple.getOSName().str();
+      std::string originalVerStr = originalVer.getAsString();
+      std::string newVerStr = newVer.getAsString();
+      const int OSNameWithoutVersionLength =
+          originalOSName.size() - originalVerStr.size();
+      if (!StringRef(originalOSName).ends_with(originalVerStr) ||
+          (OSNameWithoutVersionLength <= 0)) {
+        if (Diag) {
+          Diag->diagnose(SourceLoc(),
+                         diag::map_os_version_from_textual_interface_failed,
+                         originalVerStr, newVerStr, interfacePath);
+        }
+        break;
+      }
+      llvm::SmallString<64> buffer(
+          originalOSName.substr(0, OSNameWithoutVersionLength));
+      buffer.append(newVerStr);
+      triple.setOSName(buffer.str());
+      shouldModify = true;
+    }
+    if (shouldModify)
+      SubArgs[I] = ArgSaver.save(triple.str()).data();
   }
 
   auto IgnFlagMatch =