[5.5] [SR-14896] swift build --build-system xcode doesn't respect SWIFT_EXEC (#3596) (#3600)

When using the `xcode` build system, SwiftPM isn't passing down the result of overriding SWIFT_EXEC.  The same is true for `-toolchain` and `-sdk` but this will be fixed in a different PR.

Besides being incorrect and thus a generally something that should be fixed, this also affects SwiftPM CI, where the newly built compiler isn't being used when cross-compilation is active (since SwiftPM currently implements multi-architecture builds by switching build system to use xcbuild).

This is the Swift 5.5 nomination of this fix.

rdar://80194565
(cherry picked from commit 9aab44d)

Author: abertelrud

Sources/XCBuildSupport/XcodeBuildSystem.swift

@@ -122,9 +122,7 @@ public final class XcodeBuildSystem: SPMBuildCore.BuildSystem {
     }
 
     func createBuildParametersFile() throws -> AbsolutePath? {
-        // We only generate the build parameters file if it's required.
-        guard !buildParameters.archs.isEmpty else { return nil }
-
+        // Generate the run destination parameters.
         let runDestination = XCBBuildParameters.RunDestination(
             platform: "macosx",
             sdk: "macosx",
@@ -133,20 +131,28 @@ public final class XcodeBuildSystem: SPMBuildCore.BuildSystem {
             supportedArchitectures: [],
             disableOnlyActiveArch: true
         )
+        
+        // Generate a table of any overriding build settings.
+        var settings: [String: String] = [:]
+        // Always specify the path of the effective Swift compiler, which was determined in the same way as for the native build system.
+        settings["SWIFT_EXEC"] = buildParameters.toolchain.swiftCompiler.pathString
+        // Optionally also set the list of architectures to build for.
+        if !buildParameters.archs.isEmpty {
+            settings["ARCHS"] = buildParameters.archs.joined(separator: " ")
+        }
+        
+        // Generate the build parameters.
         let params = XCBBuildParameters(
             configurationName: buildParameters.configuration.xcbuildName,
-            overrides: .init(commandLine: .init(table: [
-                "ARCHS": "\(buildParameters.archs.joined(separator: " "))",
-            ])),
+            overrides: .init(commandLine: .init(table: settings)),
             activeRunDestination: runDestination
         )
 
-        let encoder = JSONEncoder.makeWithDefaults()        
-
+        // Write out the parameters as a JSON file, and return the path.
+        let encoder = JSONEncoder.makeWithDefaults()
         let data = try encoder.encode(params)
         let file = try withTemporaryFile(deleteOnClose: false) { $0.path }
         try localFileSystem.writeFileContents(file, bytes: ByteString(data))
-
         return file
     }
 

Tests/CommandsTests/BuildToolTests.swift

@@ -26,9 +26,10 @@ final class BuildToolTests: XCTestCase {
     @discardableResult
     private func execute(
         _ args: [String],
+        environment: [String : String]? = nil,
         packagePath: AbsolutePath? = nil
     ) throws -> (stdout: String, stderr: String) {
-        return try SwiftPMProduct.SwiftBuild.execute(args, packagePath: packagePath)
+        return try SwiftPMProduct.SwiftBuild.execute(args, packagePath: packagePath, env: environment)
     }
 
     func build(_ args: [String], packagePath: AbsolutePath? = nil) throws -> BuildResult {
@@ -280,4 +281,36 @@ final class BuildToolTests: XCTestCase {
             }
         }
     }
+
+    func testXcodeBuildSystemOverrides() throws {
+        #if !os(macOS)
+        try XCTSkipIf(true, "test requires `xcbuild` and is therefore only supported on macOS")
+        #endif
+        fixture(name: "ValidLayouts/SingleModule/ExecutableNew") { path in
+            // Try building using XCBuild without specifying overrides.  This should succeed, and should use the default compiler path.
+            let defaultOutput = try execute(["-c", "debug", "-v"], packagePath: path).stdout
+            XCTAssert(defaultOutput.contains(Resources.default.swiftCompiler.pathString), defaultOutput)
+
+            // Now try building using XCBuild while specifying a faulty compiler override.  This should fail.  Note that we need to set the executable to use for the manifest itself to the default one, since it defaults to SWIFT_EXEC if not provided.
+            var overriddenOutput = ""
+            do {
+                overriddenOutput = try execute(["-c", "debug", "-v"], environment: ["SWIFT_EXEC": "/usr/bin/false", "SWIFT_EXEC_MANIFEST": Resources.default.swiftCompiler.pathString], packagePath: path).stdout
+                XCTFail("unexpected success (was SWIFT_EXEC not overridden properly?)")
+            }
+            catch SwiftPMProductError.executionFailure(let error, let stdout, _) {
+                switch error {
+                case ProcessResult.Error.nonZeroExit(let result) where result.exitStatus != .terminated(code: 0):
+                    overriddenOutput = stdout
+                    break
+                default:
+                    XCTFail("`swift build' failed in an unexpected manner")
+                }
+            }
+            catch {
+                XCTFail("`swift build' failed in an unexpected manner")
+            }
+            XCTAssert(overriddenOutput.contains("/usr/bin/false"), overriddenOutput)
+        }
+    }
+
 }