Merge pull request #177 from owenv/deployment

Validate Darwin deployment targets and target variants

Author: owenv

Sources/SwiftDriver/Driver/Driver.swift

@@ -309,6 +309,9 @@ public struct Driver {
 
     try Self.validateWarningControlArgs(&parsedOptions)
     Self.validateCoverageArgs(&parsedOptions, diagnosticsEngine: diagnosticEngine)
+    try toolchain.validateArgs(&parsedOptions,
+                               targetTriple: self.frontendTargetInfo.target.triple,
+                               targetVariantTriple: self.frontendTargetInfo.targetVariant?.triple)
 
     // Compute debug information output.
     self.debugInfo = Self.computeDebugInfo(&parsedOptions, diagnosticsEngine: diagnosticEngine)

Sources/SwiftDriver/Toolchains/DarwinToolchain.swift

@@ -10,6 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 import TSCBasic
+import SwiftOptions
 
 /// Toolchain for Darwin-based platforms, such as macOS and iOS.
 ///
@@ -119,4 +120,62 @@ public final class DarwinToolchain: Toolchain {
     \(isShared ? "_dynamic.dylib" : ".a")
     """
   }
+
+  public enum ToolchainValidationError: Error, DiagnosticData {
+    case osVersionBelowMinimumDeploymentTarget(String)
+    case iOSVersionAboveMaximumDeploymentTarget(Int)
+    case unsupportedTargetVariant(variant: Triple)
+
+    public var description: String {
+      switch self {
+      case .osVersionBelowMinimumDeploymentTarget(let target):
+        return "Swift requires a minimum deployment target of \(target)"
+      case .iOSVersionAboveMaximumDeploymentTarget(let version):
+        return "iOS \(version) does not support 32-bit programs"
+      case .unsupportedTargetVariant(variant: let variant):
+        return "unsupported '\(variant.isiOS ? "-target" : "-target-variant")' value '\(variant)'; use 'ios-macabi' instead"
+      }
+    }
+  }
+
+  public func validateArgs(_ parsedOptions: inout ParsedOptions,
+                           targetTriple: Triple,
+                           targetVariantTriple: Triple?) throws {
+    // TODO: Validating arclite library path when link-objc-runtime.
+
+    // Validating apple platforms deployment targets.
+    try validateDeploymentTarget(&parsedOptions, targetTriple: targetTriple)
+    if let targetVariantTriple = targetVariantTriple,
+       !targetTriple.isValidForZipperingWithTriple(targetVariantTriple) {
+      throw ToolchainValidationError.unsupportedTargetVariant(variant: targetVariantTriple)
+    }
+
+    // TODO: Validating darwin unsupported -static-stdlib argument.
+    // TODO: If a C++ standard library is specified, it has to be libc++.
+  }
+
+  func validateDeploymentTarget(_ parsedOptions: inout ParsedOptions,
+                                targetTriple: Triple) 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")
+    }
+    // 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) {
+        throw ToolchainValidationError.iOSVersionAboveMaximumDeploymentTarget(targetTriple.version(for: .iOS(.device)).major)
+      }
+    } else if targetTriple.isWatchOS,
+              targetTriple.version(for: .watchOS(.device)) < Triple.Version(2, 0, 0) {
+      throw ToolchainValidationError.osVersionBelowMinimumDeploymentTarget("watchOS 2.0")
+    }
+  }
 }

Sources/SwiftDriver/Toolchains/Toolchain.swift

@@ -53,6 +53,11 @@ public protocol Toolchain {
   /// Constructs a proper output file name for a linker product.
   func makeLinkerOutputFilename(moduleName: String, type: LinkOutputType) -> String
 
+  /// Perform platform-specific argument validation.
+  func validateArgs(_ parsedOptions: inout ParsedOptions,
+                    targetTriple: Triple,
+                    targetVariantTriple: Triple?) throws
+
   /// Adds platform-specific linker flags to the provided command line
   func addPlatformSpecificLinkerArgs(
     to commandLine: inout [Job.ArgTemplate],
@@ -147,6 +152,10 @@ extension Toolchain {
     ).spm_chomp()
     return AbsolutePath(path)
   }
+
+  public func validateArgs(_ parsedOptions: inout ParsedOptions,
+                           targetTriple: Triple,
+                           targetVariantTriple: Triple?) {}
 }
 
 public enum ToolchainError: Swift.Error {

Tests/SwiftDriverTests/SwiftDriverTests.swift

@@ -1009,7 +1009,7 @@ final class SwiftDriverTests: XCTestCase {
   #if os(macOS)
     let commonArgs = [
       "swiftc", "foo.swift", "bar.swift",
-      "-emit-executable", "-target", "x86_64-apple-macosx",
+      "-emit-executable", "-target", "x86_64-apple-macosx10.9",
       "-module-name", "Test"
     ]
     do {
@@ -1507,6 +1507,41 @@ final class SwiftDriverTests: XCTestCase {
     }
   }
 
+  func testDarwinToolchainArgumentValidation() throws {
+    XCTAssertThrowsError(try Driver(args: ["swiftc", "-c", "-target", "x86_64-apple-ios6.0",
+                                           "foo.swift"])) { error in
+      guard case DarwinToolchain.ToolchainValidationError.osVersionBelowMinimumDeploymentTarget("iOS 7") = error else {
+        XCTFail()
+        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()
+        return
+      }
+    }
+
+    XCTAssertThrowsError(try Driver(args: ["swiftc", "-c", "-target", "armv7-apple-ios12.0",
+                                           "foo.swift"])) { error in
+      guard case DarwinToolchain.ToolchainValidationError.iOSVersionAboveMaximumDeploymentTarget(12) = error else {
+        XCTFail()
+        return
+      }
+    }
+
+    XCTAssertThrowsError(try Driver(args: ["swiftc", "-c", "-target", "x86_64-apple-ios13.0",
+                                           "-target-variant", "x86_64-apple-macosx10.14",
+                                           "foo.swift"])) { error in
+      guard case DarwinToolchain.ToolchainValidationError.unsupportedTargetVariant(variant: _) = error else {
+        XCTFail()
+        return
+      }
+    }
+  }
+
   func testDSYMGeneration() throws {
     let commonArgs = [
       "swiftc", "foo.swift", "bar.swift",