Loosen restriction for building deprecated iOS targets

This patch loosens the restriction for building deprecated iOS targets
to only when the user attempts to compile a binary or emit IR.
This allows the compiler to continue building swift modules and
interfaces for newer deployment targets.

The error message is also slightly modified to allow the same message to
apply to different platforms.

resolves: <rdar://87898177>

Author: cyndyishida

Sources/SwiftDriver/Driver/Driver.swift

@@ -603,6 +603,7 @@ public struct Driver {
     try toolchain.validateArgs(&parsedOptions,
                                targetTriple: self.frontendTargetInfo.target.triple,
                                targetVariantTriple: self.frontendTargetInfo.targetVariant?.triple,
+                               compilerOutputType: self.compilerOutputType,
                                diagnosticsEngine: diagnosticEngine)
 
     // Compute debug information output.

Sources/SwiftDriver/Toolchains/DarwinToolchain.swift

@@ -143,16 +143,17 @@ public final class DarwinToolchain: Toolchain {
   public enum ToolchainValidationError: Error, DiagnosticData {
     case osVersionBelowMinimumDeploymentTarget(String)
     case argumentNotSupported(String)
-    case iOSVersionAboveMaximumDeploymentTarget(Int)
+    case invalidDeploymentTargetForIR(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 .iOSVersionAboveMaximumDeploymentTarget(let version):
-        return "iOS \(version) does not support 32-bit programs"
+      case .invalidDeploymentTargetForIR(let target):
+        return
+          "\(target) and above does not support emitting binaries or IR for 32-bit programs"
       case .unsupportedTargetVariant(variant: let variant):
         return "unsupported '\(variant.isiOS ? "-target-variant" : "-target")' value '\(variant.triple)'; use 'ios-macabi' instead"
       case .argumentNotSupported(let argument):
@@ -166,6 +167,7 @@ public final class DarwinToolchain: Toolchain {
   public func validateArgs(_ parsedOptions: inout ParsedOptions,
                            targetTriple: Triple,
                            targetVariantTriple: Triple?,
+                           compilerOutputType: FileType?,
                            diagnosticsEngine: DiagnosticsEngine) throws {
     // On non-darwin hosts, libArcLite won't be found and a warning will be emitted
     // Guard for the sake of tests running on all platforms
@@ -176,7 +178,8 @@ public final class DarwinToolchain: Toolchain {
                                       diagnosticsEngine: diagnosticsEngine)
     #endif
     // Validating apple platforms deployment targets.
-    try validateDeploymentTarget(&parsedOptions, targetTriple: targetTriple)
+    try validateDeploymentTarget(&parsedOptions, targetTriple: targetTriple, 
+                                 compilerOutputType: compilerOutputType)
     if let targetVariantTriple = targetVariantTriple,
        !targetTriple.isValidForZipperingWithTriple(targetVariantTriple) {
       throw ToolchainValidationError.unsupportedTargetVariant(variant: targetVariantTriple)
@@ -198,7 +201,7 @@ public final class DarwinToolchain: Toolchain {
   }
 
   func validateDeploymentTarget(_ parsedOptions: inout ParsedOptions,
-                                targetTriple: Triple) throws {
+                                targetTriple: Triple, compilerOutputType: FileType?) throws {
     // Check minimum supported OS versions.
     if targetTriple.isMacOSX,
        targetTriple.version(for: .macOS) < Triple.Version(10, 9, 0) {
@@ -213,8 +216,11 @@ public final class DarwinToolchain: Toolchain {
         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)
+         targetTriple.version(for: .iOS(.device)) >= Triple.Version(11, 0, 0), 
+         compilerOutputType != .swiftModule {
+        throw
+            ToolchainValidationError
+            .invalidDeploymentTargetForIR("iOS 11")
       }
     } else if targetTriple.isWatchOS,
               targetTriple.version(for: .watchOS(.device)) < Triple.Version(2, 0, 0) {

Sources/SwiftDriver/Toolchains/Toolchain.swift

@@ -66,7 +66,9 @@ public protocol Toolchain {
   /// Perform platform-specific argument validation.
   func validateArgs(_ parsedOptions: inout ParsedOptions,
                     targetTriple: Triple,
-                    targetVariantTriple: Triple?, diagnosticsEngine: DiagnosticsEngine) throws
+                    targetVariantTriple: Triple?,
+                    compilerOutputType: FileType?,
+                    diagnosticsEngine: DiagnosticsEngine) throws
 
   /// Adds platform-specific linker flags to the provided command line
   func addPlatformSpecificLinkerArgs(
@@ -214,8 +216,9 @@ extension Toolchain {
   }
 
   public func validateArgs(_ parsedOptions: inout ParsedOptions,
-                           targetTriple: Triple,
-                           targetVariantTriple: Triple?, diagnosticsEngine: DiagnosticsEngine) {}
+                           targetTriple: Triple, targetVariantTriple: Triple?,
+                           compilerOutputType: FileType?,
+                           diagnosticsEngine: DiagnosticsEngine) {}
 
   public func addPlatformSpecificCommonFrontendOptions(
     commandLine: inout [Job.ArgTemplate],

Sources/SwiftDriver/Toolchains/WindowsToolchain.swift

@@ -138,6 +138,7 @@ extension WindowsToolchain.ToolchainValidationError {
 
   public func validateArgs(_ parsedOptions: inout ParsedOptions,
                            targetTriple: Triple, targetVariantTriple: Triple?,
+                           compilerOutputType: FileType?,
                            diagnosticEngine: DiagnosticsEngine) throws {
     // TODO(compnerd) validate any options we can
   }

Tests/SwiftDriverTests/SwiftDriverTests.swift

@@ -3133,14 +3133,22 @@ final class SwiftDriverTests: XCTestCase {
       }
     }
 
-    XCTAssertThrowsError(try Driver(args: ["swiftc", "-c", "-target", "armv7-apple-ios12.0",
+    XCTAssertThrowsError(try Driver(args: ["swiftc", "-c", "-target", "armv7-apple-ios12.1",
                                            "foo.swift"])) { error in
-      guard case DarwinToolchain.ToolchainValidationError.iOSVersionAboveMaximumDeploymentTarget(12) = error else {
+      guard case DarwinToolchain.ToolchainValidationError.invalidDeploymentTargetForIR("iOS 11") = error else {
         XCTFail()
         return
       }
     }
 
+    XCTAssertThrowsError(try Driver(args: ["swiftc", "-emit-module", "-c", "-target", 
+                                           "armv7-apple-ios12.0", "foo.swift"])) { error in
+        guard case DarwinToolchain.ToolchainValidationError.invalidDeploymentTargetForIR("iOS 11") = 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