Fix some correctness issues in target triple validation and improve test coverage

Fixes "off by one" type error in watchOS validation - 32-bit archs should be blocked for watchOS >= 9.0, not >= 8.7. Fixes an incorrect fallthrough where invalid tvOS archs would issue errors about 32-bit iOS archs not being supported on iOS 11 and later. Fixes labeling of "macOS" as "OS X" in an error. Fixes an issue where arm64_32 would incorrectly be blocked for watchOS >= 8.7. Generally simplifies the validation code. Improves the test coverage to cover all of these scenarios.

Author: jakepetroules

Sources/SwiftDriver/Toolchains/DarwinToolchain.swift

@@ -154,19 +154,18 @@ public final class DarwinToolchain: Toolchain {
   }
 
   public enum ToolchainValidationError: Error, DiagnosticData {
-    case osVersionBelowMinimumDeploymentTarget(String)
+    case osVersionBelowMinimumDeploymentTarget(platform: DarwinPlatform, version: Triple.Version)
     case argumentNotSupported(String)
-    case invalidDeploymentTargetForIR(String, String)
+    case invalidDeploymentTargetForIR(platform: DarwinPlatform, version: Triple.Version, archName: String)
     case unsupportedTargetVariant(variant: Triple)
     case darwinOnlySupportsLibCxx
 
     public var description: String {
       switch self {
-      case .osVersionBelowMinimumDeploymentTarget(let target):
-        return "Swift requires a minimum deployment target of \(target)"
-      case .invalidDeploymentTargetForIR(let target, let archName):
-        return
-          "\(target) and above does not support emitting binaries or IR for \(archName)"
+      case .osVersionBelowMinimumDeploymentTarget(let platform, let version):
+        return "Swift requires a minimum deployment target of \(platform.platformDisplayName) \(version.description)"
+      case .invalidDeploymentTargetForIR(let platform, let version, let archName):
+        return "\(platform.platformDisplayName) \(version.description) and above does not support emitting binaries or IR for \(archName)"
       case .unsupportedTargetVariant(variant: let variant):
         return "unsupported '\(variant.isiOS ? "-target-variant" : "-target")' value '\(variant.triple)'; use 'ios-macabi' instead"
       case .argumentNotSupported(let argument):
@@ -215,36 +214,29 @@ public final class DarwinToolchain: Toolchain {
 
   func validateDeploymentTarget(_ parsedOptions: inout ParsedOptions,
                                 targetTriple: Triple, compilerOutputType: FileType?) throws {
-    // Check minimum supported OS versions.
-    if targetTriple.isMacOSX,
-       targetTriple.version(for: .macOS) < Triple.Version(10, 9, 0) {
-      throw ToolchainValidationError.osVersionBelowMinimumDeploymentTarget("OS X 10.9")
+    guard let os = targetTriple.os else {
+      return
     }
-    // tvOS triples are also iOS, so check it first.
-    else if targetTriple.isTvOS,
-            targetTriple.version(for: .tvOS(.device)) < Triple.Version(9, 0, 0) {
-      throw ToolchainValidationError.osVersionBelowMinimumDeploymentTarget("tvOS 9.0")
-    } else if targetTriple.isiOS {
-      if targetTriple.version(for: .iOS(.device)) < Triple.Version(7, 0, 0) {
-        throw ToolchainValidationError.osVersionBelowMinimumDeploymentTarget("iOS 7")
-      }
-      if targetTriple.arch?.is32Bit == true,
-         targetTriple.version(for: .iOS(.device)) >= Triple.Version(11, 0, 0), 
-         compilerOutputType != .swiftModule {
-        throw
-            ToolchainValidationError
-              .invalidDeploymentTargetForIR("iOS 11", targetTriple.archName)
-      }
-    } else if targetTriple.isWatchOS {
-      if targetTriple.version(for: .watchOS(.device)) < Triple.Version(2, 0, 0) {
-        throw ToolchainValidationError.osVersionBelowMinimumDeploymentTarget("watchOS 2.0")
-      }
-      if targetTriple.arch?.is32Bit == true,
-         targetTriple.version(for: .watchOS(.device)) >= Triple.Version(8, 7, 0),
-         compilerOutputType != .swiftModule {
-        throw
-            ToolchainValidationError
-              .invalidDeploymentTargetForIR("watchOS 8.7", targetTriple.archName)
+
+    // Check minimum supported OS versions. Note that Mac Catalyst falls into the iOS device case. The driver automatically uplevels the deployment target to iOS >= 13.1.
+    let minVersions: [Triple.OS: (DarwinPlatform, Triple.Version)] = [
+      .macosx: (.macOS, Triple.Version(10, 9, 0)),
+      .ios: (.iOS(targetTriple._isSimulatorEnvironment ? .simulator : .device), Triple.Version(7, 0, 0)),
+      .tvos: (.tvOS(targetTriple._isSimulatorEnvironment ? .simulator : .device), Triple.Version(9, 0, 0)),
+      .watchos: (.watchOS(targetTriple._isSimulatorEnvironment ? .simulator : .device), Triple.Version(2, 0, 0))
+    ]
+    if let (platform, minVersion) = minVersions[os], targetTriple.version(for: platform) < minVersion {
+      throw ToolchainValidationError.osVersionBelowMinimumDeploymentTarget(platform: platform, version: minVersion)
+    }
+
+    // Check 32-bit deprecation. Exclude watchOS's arm64_32, which is 32-bit but not deprecated.
+    if targetTriple.arch?.is32Bit == true && compilerOutputType != .swiftModule && targetTriple.arch != .aarch64_32 {
+      let minVersions: [Triple.OS: (DarwinPlatform, Triple.Version)] = [
+        .ios: (.iOS(targetTriple._isSimulatorEnvironment ? .simulator : .device), Triple.Version(11, 0, 0)),
+        .watchos: (.watchOS(targetTriple._isSimulatorEnvironment ? .simulator : .device), targetTriple._isSimulatorEnvironment ? Triple.Version(7, 0, 0) : Triple.Version(9, 0, 0)),
+      ]
+      if let (platform, minVersion) = minVersions[os], targetTriple.version(for: platform) >= minVersion {
+        throw ToolchainValidationError.invalidDeploymentTargetForIR(platform: platform, version: minVersion, archName: targetTriple.archName)
       }
     }
   }

Sources/SwiftDriver/Utilities/Triple+Platforms.swift

@@ -79,6 +79,27 @@ public enum DarwinPlatform: Hashable {
     }
   }
 
+  public var platformDisplayName: String {
+    switch self {
+    case .macOS:
+      return "macOS"
+    case .iOS(.device):
+      return "iOS"
+    case .iOS(.simulator):
+      return "iOS Simulator"
+    case .iOS(.catalyst):
+      return "Mac Catalyst"
+    case .tvOS(.device):
+      return "tvOS"
+    case .tvOS(.simulator):
+      return "tvOS Simulator"
+    case .watchOS(.device):
+      return "watchOS"
+    case .watchOS(.simulator):
+      return "watchOS Simulator"
+    }
+  }
+
   /// The platform name, i.e. the name clang uses to identify this platform in its
   /// resource directory.
   public var platformName: String {

Tests/SwiftDriverTests/SwiftDriverTests.swift

@@ -3460,42 +3460,98 @@ final class SwiftDriverTests: XCTestCase {
   }
 
   func testDarwinToolchainArgumentValidation() throws {
-    XCTAssertThrowsError(try Driver(args: ["swiftc", "-c", "-target", "x86_64-apple-ios6.0",
+    XCTAssertThrowsError(try Driver(args: ["swiftc", "-c", "-target", "arm64-apple-ios6.0",
                                            "foo.swift"])) { error in
-      guard case DarwinToolchain.ToolchainValidationError.osVersionBelowMinimumDeploymentTarget("iOS 7") = error else {
-        XCTFail()
+      guard case DarwinToolchain.ToolchainValidationError.osVersionBelowMinimumDeploymentTarget(platform: .iOS(.device), version: Triple.Version(7, 0, 0)) = error else {
+        XCTFail("Unexpected error: \(error)")
+        return
+      }
+    }
+
+    XCTAssertThrowsError(try Driver(args: ["swiftc", "-c", "-target", "x86_64-apple-ios6.0-simulator",
+                                           "foo.swift"])) { error in
+      guard case DarwinToolchain.ToolchainValidationError.osVersionBelowMinimumDeploymentTarget(platform: .iOS(.simulator), version: Triple.Version(7, 0, 0)) = error else {
+        XCTFail("Unexpected error: \(error)")
+        return
+      }
+    }
+
+    XCTAssertThrowsError(try Driver(args: ["swiftc", "-c", "-target", "arm64-apple-tvos6.0",
+                                           "foo.swift"])) { error in
+      guard case DarwinToolchain.ToolchainValidationError.osVersionBelowMinimumDeploymentTarget(platform: .tvOS(.device), version: Triple.Version(9, 0, 0)) = error else {
+        XCTFail("Unexpected error: \(error)")
+        return
+      }
+    }
+
+    XCTAssertThrowsError(try Driver(args: ["swiftc", "-c", "-target", "x86_64-apple-tvos6.0-simulator",
+                                           "foo.swift"])) { error in
+      guard case DarwinToolchain.ToolchainValidationError.osVersionBelowMinimumDeploymentTarget(platform: .tvOS(.simulator), version: Triple.Version(9, 0, 0)) = error else {
+        XCTFail("Unexpected error: \(error)")
+        return
+      }
+    }
+
+    XCTAssertThrowsError(try Driver(args: ["swiftc", "-c", "-target", "arm64-apple-watchos1.0",
+                                           "foo.swift"])) { error in
+      guard case DarwinToolchain.ToolchainValidationError.osVersionBelowMinimumDeploymentTarget(platform: .watchOS(.device), version: Triple.Version(2, 0, 0)) = error else {
+        XCTFail("Unexpected error: \(error)")
+        return
+      }
+    }
+
+    XCTAssertThrowsError(try Driver(args: ["swiftc", "-c", "-target", "x86_64-apple-watchos1.0-simulator",
+                                           "foo.swift"])) { error in
+      guard case DarwinToolchain.ToolchainValidationError.osVersionBelowMinimumDeploymentTarget(platform: .watchOS(.simulator), version: Triple.Version(2, 0, 0)) = error else {
+        XCTFail("Unexpected error: \(error)")
         return
       }
     }
 
     XCTAssertThrowsError(try Driver(args: ["swiftc", "-c", "-target", "x86_64-apple-macosx10.4",
                                            "foo.swift"])) { error in
-      guard case DarwinToolchain.ToolchainValidationError.osVersionBelowMinimumDeploymentTarget("OS X 10.9") = error else {
-        XCTFail()
+      guard case DarwinToolchain.ToolchainValidationError.osVersionBelowMinimumDeploymentTarget(platform: .macOS, version: Triple.Version(10, 9, 0)) = error else {
+        XCTFail("Unexpected error: \(error)")
         return
       }
     }
 
     XCTAssertThrowsError(try Driver(args: ["swiftc", "-c", "-target", "armv7-apple-ios12.1",
                                            "foo.swift"])) { error in
-      guard case DarwinToolchain.ToolchainValidationError.invalidDeploymentTargetForIR("iOS 11", "armv7") = error else {
-        XCTFail()
+      guard case DarwinToolchain.ToolchainValidationError.invalidDeploymentTargetForIR(platform: .iOS(.device), version: Triple.Version(11, 0, 0), archName: "armv7") = error else {
+        XCTFail("Unexpected error: \(error)")
         return
       }
     }
 
     XCTAssertThrowsError(try Driver(args: ["swiftc", "-emit-module", "-c", "-target", 
                                            "armv7s-apple-ios12.0", "foo.swift"])) { error in
-      guard case DarwinToolchain.ToolchainValidationError.invalidDeploymentTargetForIR("iOS 11", "armv7s") = error else {
-        XCTFail()
+      guard case DarwinToolchain.ToolchainValidationError.invalidDeploymentTargetForIR(platform: .iOS(.device), version: Triple.Version(11, 0, 0), archName: "armv7s") = error else {
+        XCTFail("Unexpected error: \(error)")
+        return
+      }
+    }
+
+    XCTAssertThrowsError(try Driver(args: ["swiftc", "-emit-module", "-c", "-target",
+                                           "i386-apple-ios12.0-simulator", "foo.swift"])) { error in
+      guard case DarwinToolchain.ToolchainValidationError.invalidDeploymentTargetForIR(platform: .iOS(.simulator), version: Triple.Version(11, 0, 0), archName: "i386") = error else {
+        XCTFail("Unexpected error: \(error)")
         return
       }
     }
 
     XCTAssertThrowsError(try Driver(args: ["swiftc", "-emit-module", "-c", "-target",
                                              "armv7k-apple-watchos12.0", "foo.swift"])) { error in
-      guard case DarwinToolchain.ToolchainValidationError.invalidDeploymentTargetForIR("watchOS 8.7", "armv7k") = error else {
-        XCTFail()
+      guard case DarwinToolchain.ToolchainValidationError.invalidDeploymentTargetForIR(platform: .watchOS(.device), version: Triple.Version(9, 0, 0), archName: "armv7k") = error else {
+        XCTFail("Unexpected error: \(error)")
+        return
+      }
+    }
+
+    XCTAssertThrowsError(try Driver(args: ["swiftc", "-emit-module", "-c", "-target",
+                                           "i386-apple-watchos12.0", "foo.swift"])) { error in
+      guard case DarwinToolchain.ToolchainValidationError.invalidDeploymentTargetForIR(platform: .watchOS(.simulator), version: Triple.Version(7, 0, 0), archName: "i386") = error else {
+        XCTFail("Unexpected error: \(error)")
         return
       }
     }
@@ -3504,34 +3560,41 @@ final class SwiftDriverTests: XCTestCase {
                                            "-target-variant", "x86_64-apple-macosx10.14",
                                            "foo.swift"])) { error in
       guard case DarwinToolchain.ToolchainValidationError.unsupportedTargetVariant(variant: _) = error else {
-        XCTFail()
+        XCTFail("Unexpected error: \(error)")
         return
       }
     }
 
     XCTAssertThrowsError(try Driver(args: ["swiftc", "-c", "-static-stdlib", "-target", "x86_64-apple-macosx10.14",
                                            "foo.swift"])) { error in
       guard case DarwinToolchain.ToolchainValidationError.argumentNotSupported("-static-stdlib") = error else {
-        XCTFail()
+        XCTFail("Unexpected error: \(error)")
         return
       }
     }
 
     XCTAssertThrowsError(try Driver(args: ["swiftc", "-c", "-static-executable", "-target", "x86_64-apple-macosx10.14",
                                            "foo.swift"])) { error in
       guard case DarwinToolchain.ToolchainValidationError.argumentNotSupported("-static-executable") = error else {
-        XCTFail()
+        XCTFail("Unexpected error: \(error)")
         return
       }
     }
 
     XCTAssertThrowsError(try Driver(args: ["swiftc", "-c", "-target", "x86_64-apple-macosx10.14", "-experimental-cxx-stdlib", "libstdc++",
                                            "foo.swift"])) { error in
         guard case DarwinToolchain.ToolchainValidationError.darwinOnlySupportsLibCxx = error else {
-        XCTFail()
+          XCTFail("Unexpected error: \(error)")
         return
       }
     }
+
+    // Not actually a valid arch for tvOS, but we shouldn't fall into the iOS case by mistake and emit a message about iOS >= 11 not supporting armv7.
+    XCTAssertNoThrow(try Driver(args: ["swiftc", "-c", "-target", "armv7-apple-tvos9.0", "foo.swift"]))
+
+    // Ensure arm64_32 is not restricted to back-deployment like other 32-bit archs (armv7k/i386).
+    XCTAssertNoThrow(try Driver(args: ["swiftc", "-emit-module", "-c", "-target", "arm64_32-apple-watchos12.0", "foo.swift"]))
+
     // On non-darwin hosts, libArcLite won't be found and a warning will be emitted
     #if os(macOS)
     try assertNoDriverDiagnostics(args: "swiftc", "-c", "-target", "x86_64-apple-macosx10.14", "-link-objc-runtime", "foo.swift")