Propagate driver-specified clang-target flags even when no SDK is specified

artemcm · artemcm · commit 6750873eb21c · 2025-06-24T10:43:58.000-07:00
diff --git a/Sources/SwiftDriver/Driver/Driver.swift b/Sources/SwiftDriver/Driver/Driver.swift
@@ -59,6 +59,7 @@ public struct Driver {
     case cannotSpecify_OForMultipleOutputs
     case conflictingOptions(Option, Option)
     case unableToLoadOutputFileMap(String, String)
+    case malformedChainedBridgingHeader(String)
     case unableToDecodeFrontendTargetInfo(String?, [String], String)
     case failedToRetrieveFrontendTargetInfo
     case failedToRunFrontendToRetrieveTargetInfo(Int, String?)
@@ -111,6 +112,8 @@ public struct Driver {
         return "failed to retrieve frontend target info"
       case .unableToReadFrontendTargetInfo:
         return "could not read frontend target info"
+      case .malformedChainedBridgingHeader(let content):
+        return "could not convert bridging header content to utf-8: \(content)"
       case let .failedToRunFrontendToRetrieveTargetInfo(returnCode, stderr):
         return "frontend job retrieving target info failed with code \(returnCode)"
           + (stderr.map {": \($0)"} ?? "")
@@ -3107,7 +3110,10 @@ extension Driver {
       if !fileSystem.exists(path.parentDirectory) {
         try fileSystem.createDirectory(path.parentDirectory, recursive: true)
       }
-      return try VirtualPath.createBuildProductFileWithKnownContents(path, chainedHeader.content.data(using: .utf8)!).intern()
+      guard let headerData = chainedHeader.content.data(using: .utf8) else {
+        throw Driver.Error.malformedChainedBridgingHeader(chainedHeader.content)
+      }
+      return try VirtualPath.createBuildProductFileWithKnownContents(path, headerData).intern()
     }
     return originalObjCHeaderFile
   }
diff --git a/Sources/SwiftDriver/Jobs/ReplJob.swift b/Sources/SwiftDriver/Jobs/ReplJob.swift
@@ -15,8 +15,7 @@ extension Driver {
     var commandLine: [Job.ArgTemplate] = swiftCompilerPrefixArgs.map { Job.ArgTemplate.flag($0) }
     var inputs: [TypedVirtualPath] = []
 
-    try addCommonFrontendOptions(commandLine: &commandLine, inputs: &inputs, kind: .repl,
-                                 explicitModulePlanner: nil)
+    try addCommonFrontendOptions(commandLine: &commandLine, inputs: &inputs, kind: .repl)
     try addRuntimeLibraryFlags(commandLine: &commandLine)
 
     try commandLine.appendLast(.importObjcHeader, from: &parsedOptions)
diff --git a/Sources/SwiftDriver/Toolchains/DarwinToolchain.swift b/Sources/SwiftDriver/Toolchains/DarwinToolchain.swift
@@ -409,8 +409,57 @@ public final class DarwinToolchain: Toolchain {
     driver: inout Driver,
     skipMacroOptions: Bool
   ) throws {
-    guard let sdkPath = frontendTargetInfo.sdkPath?.path,
-          let sdkInfo = getTargetSDKInfo(sdkPath: sdkPath) else { return }
+    let sdkPath = frontendTargetInfo.sdkPath?.path
+    let sdkInfo: DarwinSDKInfo? = sdkPath != nil ? getTargetSDKInfo(sdkPath: sdkPath!) : nil
+
+    // Pass down -clang-target.
+    // If not specified otherwise, we should use the same triple as -target
+    if !driver.parsedOptions.hasArgument(.disableClangTarget) &&
+        driver.isFrontendArgSupported(.clangTarget) &&
+        driver.parsedOptions.contains(.driverExplicitModuleBuild) {
+      // The common target triple for all Clang dependencies of this compilation,
+      // both direct and transitive is computed as:
+      // 1. An explicitly-specified `-clang-target` argument to this driver invocation
+      // 2. (On Darwin) The target triple of the selected SDK
+      var clangTargetTriple: String? = nil
+      if let explicitClangTripleArg = driver.parsedOptions.getLastArgument(.clangTarget)?.asSingle {
+        clangTargetTriple = explicitClangTripleArg
+      } else if let sdkInfo = sdkInfo {
+        let currentTriple = frontendTargetInfo.target.triple
+        let sdkVersionedOSString = currentTriple.osNameUnversioned + sdkInfo.sdkVersion(for: currentTriple).sdkVersionString
+        clangTargetTriple = currentTriple.triple.replacingOccurrences(of: currentTriple.osName, with: sdkVersionedOSString)
+      }
+
+      if let clangTargetTriple {
+        commandLine.appendFlag(.clangTarget)
+        commandLine.appendFlag(clangTargetTriple)
+      }
+
+      // Repeat the above for the '-target-variant' flag
+      if driver.parsedOptions.contains(.targetVariant),
+        driver.isFrontendArgSupported(.clangTargetVariant),
+        let targetVariantTripleStr = frontendTargetInfo.targetVariant?.triple
+      {
+        var clangTargetVariantTriple: String? = nil
+        if let explicitClangTargetVariantArg = driver.parsedOptions.getLastArgument(.clangTargetVariant)?.asSingle {
+          clangTargetVariantTriple = explicitClangTargetVariantArg
+        } else if let sdkInfo {
+          let currentVariantTriple = targetVariantTripleStr
+          let sdkVersionedOSSString =
+            currentVariantTriple.osNameUnversioned
+            + sdkInfo.sdkVersion(for: currentVariantTriple).sdkVersionString
+          clangTargetVariantTriple = currentVariantTriple.triple.replacingOccurrences(
+            of: currentVariantTriple.osName, with: sdkVersionedOSSString)
+        }
+
+        if let clangTargetVariantTriple {
+          commandLine.appendFlag(.clangTargetVariant)
+          commandLine.appendFlag(clangTargetVariantTriple)
+        }
+      }
+    }
+
+    guard let sdkPath, let sdkInfo else { return }
 
     commandLine.append(.flag("-target-sdk-version"))
     commandLine.append(.flag(sdkInfo.sdkVersion(for: frontendTargetInfo.target.triple).sdkVersionString))
@@ -453,45 +502,6 @@ public final class DarwinToolchain: Toolchain {
       commandLine.appendPath(prebuiltModulesPath)
     }
 
-    // Pass down -clang-target.
-    // If not specified otherwise, we should use the same triple as -target
-    if !driver.parsedOptions.hasArgument(.disableClangTarget) &&
-        driver.isFrontendArgSupported(.clangTarget) &&
-        driver.parsedOptions.contains(.driverExplicitModuleBuild) {
-      // The common target triple for all Clang dependencies of this compilation,
-      // both direct and transitive is computed as:
-      // 1. An explicitly-specified `-clang-target` argument to this driver invocation
-      // 2. (On Darwin) The target triple of the selected SDK
-      let clangTargetTriple: String
-      if let explicitClangTripleArg = driver.parsedOptions.getLastArgument(.clangTarget)?.asSingle {
-        clangTargetTriple = explicitClangTripleArg
-      } else {
-        let currentTriple = frontendTargetInfo.target.triple
-        let sdkVersionedOSString = currentTriple.osNameUnversioned + sdkInfo.sdkVersion(for: currentTriple).sdkVersionString
-        clangTargetTriple = currentTriple.triple.replacingOccurrences(of: currentTriple.osName, with: sdkVersionedOSString)
-      }
-
-      commandLine.appendFlag(.clangTarget)
-      commandLine.appendFlag(clangTargetTriple)
-
-      // Repeat the above for the '-target-variant' flag
-      if driver.parsedOptions.contains(.targetVariant),
-         driver.isFrontendArgSupported(.clangTargetVariant),
-         let targetVariantTripleStr = frontendTargetInfo.targetVariant?.triple {
-        let clangTargetVariantTriple: String
-        if let explicitClangTargetVariantArg = driver.parsedOptions.getLastArgument(.clangTargetVariant)?.asSingle {
-          clangTargetVariantTriple = explicitClangTargetVariantArg
-        } else {
-          let currentVariantTriple = targetVariantTripleStr
-          let sdkVersionedOSSString = currentVariantTriple.osNameUnversioned + sdkInfo.sdkVersion(for: currentVariantTriple).sdkVersionString
-          clangTargetVariantTriple = currentVariantTriple.triple.replacingOccurrences(of: currentVariantTriple.osName, with: sdkVersionedOSSString)
-        }
-
-        commandLine.appendFlag(.clangTargetVariant)
-        commandLine.appendFlag(clangTargetVariantTriple)
-      }
-    }
-
     if driver.isFrontendArgSupported(.externalPluginPath) && !skipMacroOptions {
       // If the PLATFORM_DIR environment variable is set, also add plugin
       // paths into it. Since this is a user override, it comes beore the
diff --git a/Sources/SwiftDriver/Utilities/VirtualPath.swift b/Sources/SwiftDriver/Utilities/VirtualPath.swift
@@ -47,7 +47,8 @@ public enum VirtualPath: Hashable {
   /// Standard output
   case standardOutput
 
-  /// ACTODO: Comment
+  /// A file with a known absolute path and contents computed by
+  /// the driver, it gets written to the filesystem at resolution time
   case buildArtifactWithKnownContents(AbsolutePath, Data)
 
   /// We would like to direct clients to use the temporary file creation utilities `createUniqueTemporaryFile`, etc.
diff --git a/TestInputs/mock-sdk.sdk/SDKSettings.json b/TestInputs/mock-sdk.sdk/SDKSettings.json
@@ -1,8 +1,8 @@
 {
 	"Version": "10.15",
 	"VersionMap": {
-		"macOS_iOSMac": {},
-		"iOSMac_macOS": {}
+		"macOS_iOSMac": {"10.15":"13.1"},
+		"iOSMac_macOS": {"13.1":"10.15"}
 	},
 	"CanonicalName": "macosx10.15"
 }
diff --git a/Tests/SwiftDriverTests/ExplicitModuleBuildTests.swift b/Tests/SwiftDriverTests/ExplicitModuleBuildTests.swift
@@ -2591,6 +2591,142 @@ final class ExplicitModuleBuildTests: XCTestCase {
     }
   }
 
+  func testClangTargetOptionsExplicit() throws {
+    let (stdlibPath, shimsPath, _, _) = try getDriverArtifactsForScanning()
+    let cHeadersPath: AbsolutePath =
+      try testInputsPath.appending(component: "ExplicitModuleBuilds")
+        .appending(component: "CHeaders")
+    let swiftModuleInterfacesPath: AbsolutePath =
+      try testInputsPath.appending(component: "ExplicitModuleBuilds")
+        .appending(component: "Swift")
+    let mockSDKPath: AbsolutePath =
+      try testInputsPath.appending(component: "mock-sdk.sdk")
+
+    // Only '-target' is specified, the driver infers '-clang-target' from SDK deployment target
+    do {
+      try withTemporaryDirectory { path in
+        let main = path.appending(component: "testDependencyScanning.swift")
+        try localFileSystem.writeFileContents(main, bytes:
+          """
+          import A;
+          """
+        )
+        var driver = try Driver(args: ["swiftc",
+                                       "-target", "x86_64-apple-macosx10.10",
+                                       "-Xfrontend", "-disable-implicit-concurrency-module-import",
+                                       "-Xfrontend", "-disable-implicit-string-processing-module-import",
+                                       "-emit-module",
+                                       "-emit-module-path", "foo.swiftmodule/target.swiftmodule",
+                                       "-I", cHeadersPath.nativePathString(escaped: true),
+                                       "-I", swiftModuleInterfacesPath.nativePathString(escaped: true),
+                                       "-I", stdlibPath.nativePathString(escaped: true),
+                                       "-I", shimsPath.nativePathString(escaped: true),
+                                       "-explicit-module-build",
+                                       "-sdk", mockSDKPath.nativePathString(escaped: true),
+                                       main.pathString])
+        let plannedJobs = try driver.planBuild().removingAutolinkExtractJobs()
+        let emitModuleJob = try XCTUnwrap(plannedJobs.findJobs(.emitModule).spm_only)
+        XCTAssertTrue(emitModuleJob.commandLine.contains(subsequence: [.flag("-sdk"), .path(.absolute(mockSDKPath))]))
+        XCTAssertTrue(emitModuleJob.commandLine.contains(subsequence: [.flag("-clang-target"), .flag("x86_64-apple-macosx10.15")]))
+      }
+    }
+
+    // User-specified '-clang-target'
+    do {
+      try withTemporaryDirectory { path in
+        let main = path.appending(component: "testDependencyScanning.swift")
+        try localFileSystem.writeFileContents(main, bytes:
+          """
+          import A;
+          """
+        )
+        var driver = try Driver(args: ["swiftc",
+                                       "-target", "x86_64-apple-macosx10.10",
+                                       "-clang-target", "x86_64-apple-macosx10.12",
+                                       "-Xfrontend", "-disable-implicit-concurrency-module-import",
+                                       "-Xfrontend", "-disable-implicit-string-processing-module-import",
+                                       "-emit-module",
+                                       "-emit-module-path", "foo.swiftmodule/target.swiftmodule",
+                                       "-I", cHeadersPath.nativePathString(escaped: true),
+                                       "-I", swiftModuleInterfacesPath.nativePathString(escaped: true),
+                                       "-I", stdlibPath.nativePathString(escaped: true),
+                                       "-I", shimsPath.nativePathString(escaped: true),
+                                       "-explicit-module-build",
+                                       "-sdk", mockSDKPath.nativePathString(escaped: true),
+                                       main.pathString])
+        let plannedJobs = try driver.planBuild().removingAutolinkExtractJobs()
+        let emitModuleJob = try XCTUnwrap(plannedJobs.findJobs(.emitModule).spm_only)
+        XCTAssertTrue(emitModuleJob.commandLine.contains(subsequence: [.flag("-sdk"), .path(.absolute(mockSDKPath))]))
+        XCTAssertTrue(emitModuleJob.commandLine.contains(subsequence: [.flag("-clang-target"), .flag("x86_64-apple-macosx10.12")]))
+      }
+    }
+
+    // Only '-target' and '-target-variant' is specified, the driver infers '-clang-target' from SDK deployment target
+    // and '-clang-target-variant' form the
+    do {
+      try withTemporaryDirectory { path in
+        let main = path.appending(component: "testDependencyScanning.swift")
+        try localFileSystem.writeFileContents(main, bytes:
+          """
+          import A;
+          """
+        )
+        var driver = try Driver(args: ["swiftc",
+                                       "-target", "x86_64-apple-macosx10.10",
+                                       "-target-variant", "x86_64-apple-ios13.0-macabi",
+                                       "-Xfrontend", "-disable-implicit-concurrency-module-import",
+                                       "-Xfrontend", "-disable-implicit-string-processing-module-import",
+                                       "-emit-module",
+                                       "-emit-module-path", "foo.swiftmodule/target.swiftmodule",
+                                       "-I", cHeadersPath.nativePathString(escaped: true),
+                                       "-I", swiftModuleInterfacesPath.nativePathString(escaped: true),
+                                       "-I", stdlibPath.nativePathString(escaped: true),
+                                       "-I", shimsPath.nativePathString(escaped: true),
+                                       "-explicit-module-build",
+                                       "-sdk", mockSDKPath.nativePathString(escaped: true),
+                                       main.pathString])
+        let plannedJobs = try driver.planBuild().removingAutolinkExtractJobs()
+        let emitModuleJob = try XCTUnwrap(plannedJobs.findJobs(.emitModule).spm_only)
+        XCTAssertTrue(emitModuleJob.commandLine.contains(subsequence: [.flag("-sdk"), .path(.absolute(mockSDKPath))]))
+        XCTAssertTrue(emitModuleJob.commandLine.contains(subsequence: [.flag("-clang-target"), .flag("x86_64-apple-macosx10.15")]))
+        XCTAssertTrue(emitModuleJob.commandLine.contains(subsequence: [.flag("-clang-target-variant"), .flag("x86_64-apple-ios13.1-macabi")]))
+      }
+    }
+
+    // User-specified '-clang-target' and '-clang-target-variant'
+    do {
+      try withTemporaryDirectory { path in
+        let main = path.appending(component: "testDependencyScanning.swift")
+        try localFileSystem.writeFileContents(main, bytes:
+          """
+          import A;
+          """
+        )
+        var driver = try Driver(args: ["swiftc",
+                                       "-target", "x86_64-apple-macosx10.10",
+                                       "-target-variant", "x86_64-apple-ios13.0-macabi",
+                                       "-clang-target", "x86_64-apple-macosx10.12",
+                                       "-clang-target-variant", "x86_64-apple-ios14.0-macabi",
+                                       "-Xfrontend", "-disable-implicit-concurrency-module-import",
+                                       "-Xfrontend", "-disable-implicit-string-processing-module-import",
+                                       "-emit-module",
+                                       "-emit-module-path", "foo.swiftmodule/target.swiftmodule",
+                                       "-I", cHeadersPath.nativePathString(escaped: true),
+                                       "-I", swiftModuleInterfacesPath.nativePathString(escaped: true),
+                                       "-I", stdlibPath.nativePathString(escaped: true),
+                                       "-I", shimsPath.nativePathString(escaped: true),
+                                       "-explicit-module-build",
+                                       "-sdk", mockSDKPath.nativePathString(escaped: true),
+                                       main.pathString])
+        let plannedJobs = try driver.planBuild().removingAutolinkExtractJobs()
+        let emitModuleJob = try XCTUnwrap(plannedJobs.findJobs(.emitModule).spm_only)
+        XCTAssertTrue(emitModuleJob.commandLine.contains(subsequence: [.flag("-sdk"), .path(.absolute(mockSDKPath))]))
+        XCTAssertTrue(emitModuleJob.commandLine.contains(subsequence: [.flag("-clang-target"), .flag("x86_64-apple-macosx10.12")]))
+        XCTAssertTrue(emitModuleJob.commandLine.contains(subsequence: [.flag("-clang-target-variant"), .flag("x86_64-apple-ios14.0-macabi")]))
+      }
+    }
+  }
+
   func testTargetVariantEmitModuleExplicit() throws {
     let (stdlibPath, shimsPath, _, _) = try getDriverArtifactsForScanning()
     let cHeadersPath: AbsolutePath =
@@ -2623,8 +2759,8 @@ final class ExplicitModuleBuildTests: XCTestCase {
                                        "-emit-variant-module-path", "foo.swiftmodule/variant.swiftmodule",
                                        "-emit-module-interface-path", "foo.swiftmodule/target.swiftinterface",
                                        "-emit-variant-module-interface-path", "foo.swiftmodule/variant.swiftinterface",
-                                       "-disable-implicit-concurrency-module-import",
-                                       "-disable-implicit-string-processing-module-import",
+                                       "-Xfrontend", "-disable-implicit-concurrency-module-import",
+                                       "-Xfrontend", "-disable-implicit-string-processing-module-import",
                                        "-I", cHeadersPath.nativePathString(escaped: true),
                                        "-I", swiftModuleInterfacesPath.nativePathString(escaped: true),
                                        "-I", stdlibPath.nativePathString(escaped: true),
@@ -2725,8 +2861,8 @@ final class ExplicitModuleBuildTests: XCTestCase {
                                        "-emit-module",
                                        "-emit-module-path", "foo.swiftmodule/target.swiftmodule",
                                        "-emit-variant-module-path", "foo.swiftmodule/variant.swiftmodule",
-                                       "-disable-implicit-concurrency-module-import",
-                                       "-disable-implicit-string-processing-module-import",
+                                       "-Xfrontend", "-disable-implicit-concurrency-module-import",
+                                       "-Xfrontend", "-disable-implicit-string-processing-module-import",
                                        "-I", cHeadersPath.nativePathString(escaped: true),
                                        "-I", swiftModuleInterfacesPath.nativePathString(escaped: true),
                                        "-I", stdlibPath.nativePathString(escaped: true),

Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,8 @@`
`1`	`1`	`{`
`2`	`2`	`"Version": "10.15",`
`3`	`3`	`"VersionMap": {`
`4`		`- "macOS_iOSMac": {},`
`5`		`- "iOSMac_macOS": {}`
	`4`	`+ "macOS_iOSMac": {"10.15":"13.1"},`
	`5`	`+ "iOSMac_macOS": {"13.1":"10.15"}`
`6`	`6`	`},`
`7`	`7`	`"CanonicalName": "macosx10.15"`
`8`	`8`	`}`