ModuleInterface: Canonicalize OS version numbers in loaded swiftinterfaces.

Author: tshortli

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,

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/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 =