[Triple] Fix Apple-OS triple version mapping for the 26-aligned releases

Port LLVM's `isValidVersionForOS` / `getCanonicalVersionForOS` and rewrite
`_iOSVersion` to match `getiOSVersion`: iOS & tvOS 19 -> 26, xrOS 1/2 ->
iOS 17/18, xrOS 3 -> 26, watchOS 12 -> 26, with gap versions canonicalized
into the 26+ space.

Author: nkcsgexi

Sources/SwiftDriver/Utilities/Triple.swift

@@ -1573,6 +1573,60 @@ extension Triple {
 // MARK: - Darwin Versions
 
 extension Triple {
+  // Version 26 alignment helpers, ported from LLVM's `isValidVersionForOS` /
+  // `getCanonicalVersionForOS`. Each Apple OS jumped to the version 26, leaving
+  // an unshipped version gap below 26. Only `_iOSVersion` consumes these.
+
+  /// False if `version` is in the unshipped gap.
+  static func _isValidVersion(_ version: Version, for os: OS) -> Bool {
+    let commonMajor = 26
+    func valid(after starting: Int) -> Bool {
+      !(version.major > starting && version.major < commonMajor)
+    }
+    switch os {
+    case .watchos:    return valid(after: 12)
+    case .ios, .tvos: return valid(after: 19)
+    case .macosx:     return valid(after: 16)
+    case .visionos:   return valid(after: 3)
+    default:          return true
+    }
+  }
+
+  /// Canonicalize a pre-26 or gap version into the year-aligned (26+) space.
+  static func _canonicalVersion(_ version: Version, for os: OS,
+                                isInValidRange: Bool) -> Version {
+    func bumped(by delta: Int) -> Version {
+      Version(version.major + delta, version.minor, version.micro)
+    }
+    func isExactly(_ major: Int) -> Bool {
+      version.major == major && version.minor == 0 && version.micro == 0
+    }
+    switch os {
+    case .macosx:
+      if version.major == 10 && version.minor == 16 { return Version(11, 0, 0) }
+      if isExactly(16) { return Version(26, 0, 0) }
+      if !isInValidRange { return bumped(by: 10) }
+    case .ios, .tvos:
+      if isExactly(19) { return Version(26, 0, 0) }
+      if !isInValidRange { return bumped(by: 7) }
+    case .visionos:
+      if isExactly(3) { return Version(26, 0, 0) }
+      if !isInValidRange { return bumped(by: 23) }
+    case .watchos:
+      if isExactly(12) { return Version(26, 0, 0) }
+      if !isInValidRange { return bumped(by: 14) }
+    default:
+      break
+    }
+    return version
+  }
+
+  /// Canonicalize using the platform's own validity check.
+  static func _canonicalVersion(_ version: Version, for os: OS) -> Version {
+    _canonicalVersion(version, for: os,
+                      isInValidRange: _isValidVersion(version, for: os))
+  }
+
   /// Parse the version number as with getOSVersion and then
   /// translate generic "darwin" versions to the corresponding OS X versions.
   /// This may also be called with IOS triples but the OS X version number is
@@ -1649,19 +1703,29 @@ extension Triple {
       // toolchain that wants to know the iOS version number even when targeting
       // OS X.
       return Version(5, 0, 0)
-    case .ios:
+    case .ios, .tvos:
       var version = self.osVersion
       // Default to 5.0 (or 7.0 for arm64).
       if version.major == 0 {
         version.major = arch == .aarch64 ? 7 : 5
       }
-      return version
-    case .tvos:
-      return osVersion
+      // iOS & tvOS 19 correspond to iOS 26.
+      if version.major == 19 {
+        return Version(26, 0, 0)
+      }
+      return Triple._canonicalVersion(version, for: .ios)
     case .visionos:
-      return Version(15, 0, 0)
+      let version = self.osVersion
+      // xrOS 1/2 are aligned with iOS 17/18.
+      if version.major < 3 {
+        return Version(version.major + 16, version.minor, version.micro)
+      }
+      // visionOS 3 corresponds to iOS 26.
+      return Triple._canonicalVersion(version, for: .visionos)
     case .watchos:
-      fatalError("conflicting triple info")
+      let version = self.osVersion
+      // watchOS 12 corresponds to iOS 26.
+      return Triple._canonicalVersion(version, for: .watchos)
     default:
       fatalError("unexpected OS for Darwin triple")
     }

Tests/SwiftDriverTests/TripleTests.swift

@@ -1180,6 +1180,29 @@ import class TSCBasic.DiagnosticsEngine
     #expect(!T.isMacCatalyst)
   }
 
+  /// Mirrors LLVM `getiOSVersion` / `getCanonicalVersionForOS` year-26 alignment.
+  @Test func iOSVersionAlignment() {
+    func iOSVersion(_ triple: String) -> Triple.Version { Triple(triple)._iOSVersion }
+
+    // iOS / tvOS 19 -> iOS 26; already-aligned and pre-jump values pass through;
+    // a gap version (20-25) bumps by 7.
+    #expect(iOSVersion("arm64-apple-ios19.0") == Triple.Version(26, 0, 0))
+    #expect(iOSVersion("arm64-apple-ios26.0") == Triple.Version(26, 0, 0))
+    #expect(iOSVersion("arm64-apple-ios18.0") == Triple.Version(18, 0, 0))
+    #expect(iOSVersion("arm64-apple-ios21.0") == Triple.Version(28, 0, 0))
+    #expect(iOSVersion("arm64-apple-tvos19.0") == Triple.Version(26, 0, 0))
+
+    // visionOS (xrOS): 1/2 align with iOS 17/18, 3 -> iOS 26.
+    #expect(iOSVersion("arm64-apple-xros1.0") == Triple.Version(17, 0, 0))
+    #expect(iOSVersion("arm64-apple-xros2.0") == Triple.Version(18, 0, 0))
+    #expect(iOSVersion("arm64-apple-xros3.0") == Triple.Version(26, 0, 0))
+    #expect(iOSVersion("arm64-apple-xros26.0") == Triple.Version(26, 0, 0))
+
+    // watchOS 12 -> iOS 26.
+    #expect(iOSVersion("arm64-apple-watchos12.0") == Triple.Version(26, 0, 0))
+    #expect(iOSVersion("arm64-apple-watchos11.0") == Triple.Version(11, 0, 0))
+  }
+
   @Test func fileFormat() {
     #expect(.elf == Triple("i686-unknown-linux-gnu").objectFormat)
     #expect(.elf == Triple("x86_64-unknown-linux-gnu").objectFormat)