plugins: Global compiler flags should not be used when building plugin dependencies

Build tools and end products are built with separate toolchains:
* Plugins and any targets they depend on, such as helper tools, are
built with the host toolchain.
* End products are built with the target toolchain.

Compiler flags set with -Xswiftc are intended to be applied only
to end product builds, but they are incorrectly being applied to
plugin tool builds as well.   This can cause problems because target
toolchain flags might not be suitable for a tools build.   In the
worst case, the build might fail completely if the host toolchain
rejects the target toolchain flag.    For example, Linux toochains
accept the `-static-executable` flag, but macOS toolchains reject
it.

Fixes: rdar://127813618

Author: euanh

Sources/CoreCommands/Options.swift

@@ -316,28 +316,28 @@ package struct BuildOptions: ParsableArguments {
     @Option(
         name: .customLong("Xcc", withSingleDash: true),
         parsing: .unconditionalSingleValue,
-        help: "Pass flag through to all C compiler invocations"
+        help: "Pass flag through to C compiler invocations for the target triple"
     )
     var cCompilerFlags: [String] = []
 
     @Option(
         name: .customLong("Xswiftc", withSingleDash: true),
         parsing: .unconditionalSingleValue,
-        help: "Pass flag through to all Swift compiler invocations"
+        help: "Pass flag through to Swift compiler invocations for the target triple"
     )
     var swiftCompilerFlags: [String] = []
 
     @Option(
         name: .customLong("Xlinker", withSingleDash: true),
         parsing: .unconditionalSingleValue,
-        help: "Pass flag through to all linker invocations"
+        help: "Pass flag through to linker invocations for the target triple"
     )
     var linkerFlags: [String] = []
 
     @Option(
         name: .customLong("Xcxx", withSingleDash: true),
         parsing: .unconditionalSingleValue,
-        help: "Pass flag through to all C++ compiler invocations"
+        help: "Pass flag through to C++ compiler invocations for the target triple"
     )
     var cxxCompilerFlags: [String] = []
 

Sources/CoreCommands/SwiftCommandState.swift

@@ -725,7 +725,7 @@ package final class SwiftCommandState {
     when building on macOS.
     """
 
-    private func _buildParams(toolchain: UserToolchain) throws -> BuildParameters {
+    private func _buildParams(toolchain: UserToolchain, buildFlags: PackageModel.BuildFlags) throws -> BuildParameters {
         let triple = toolchain.targetTriple
 
         let dataPath = self.scratchDirectory.appending(
@@ -741,7 +741,7 @@ package final class SwiftCommandState {
             configuration: options.build.configuration,
             toolchain: toolchain,
             triple: triple,
-            flags: options.build.buildFlags,
+            flags: buildFlags,
             pkgConfigDirectories: options.locations.pkgConfigDirectories,
             architectures: options.build.architectures,
             workers: options.build.jobs ?? UInt32(ProcessInfo.processInfo.activeProcessorCount),
@@ -796,7 +796,7 @@ package final class SwiftCommandState {
 
     private lazy var _toolsBuildParameters: Result<BuildParameters, Swift.Error> = {
         Result(catching: {
-            try _buildParams(toolchain: self.getHostToolchain())
+            try _buildParams(toolchain: self.getHostToolchain(), buildFlags: .init())
         })
     }()
 
@@ -808,7 +808,7 @@ package final class SwiftCommandState {
 
     private lazy var _productsBuildParameters: Result<BuildParameters, Swift.Error> = {
         Result(catching: {
-            try _buildParams(toolchain: self.getTargetToolchain())
+            try _buildParams(toolchain: self.getTargetToolchain(), buildFlags: options.build.buildFlags)
         })
     }()
 

Tests/CommandsTests/SwiftCommandStateTests.swift

@@ -322,6 +322,72 @@ final class SwiftCommandStateTests: CommandsTestCase {
         try XCTAssertMatch(plan.buildProducts.compactMap { $0 as? Build.ProductBuildDescription }.first?.linkArguments() ?? [],
                            [.anySequence, "-gnone", .anySequence])
     }
+
+    func testSeparateProductAndToolBuildParameters() throws {
+        let fs = InMemoryFileSystem(emptyFiles: [
+            "/Pkg/Sources/exe/main.swift",
+            "/Pkg/Sources/helper/main.swift",
+            "/Pkg/Plugins/plugin/main.swift",
+        ])
+
+        let observer = ObservabilitySystem.makeForTesting()
+        let graph = try loadModulesGraph(
+            fileSystem: fs,
+            manifests: [
+                Manifest.createRootManifest(
+                    displayName: "Pkg",
+                    path: "/Pkg",
+                    targets: [
+                        TargetDescription(name: "exe", dependencies: []),
+                        TargetDescription(name: "helper", dependencies: []),
+                        TargetDescription(
+                            name: "plugin",
+                            dependencies: ["helper"],
+                            type: .plugin,
+                            pluginCapability: .command(
+                                intent: .sourceCodeFormatting,
+                                permissions: []
+                            )
+                        )
+                    ]
+                )
+            ],
+            observabilityScope: observer.topScope
+        )
+
+        var plan: BuildPlan
+
+        /* Set up flags which should only be used for product builds */
+        let staticExecutableOptions = try GlobalOptions.parse(["-Xswiftc", "-static-executable"])
+        let staticExecutable = try SwiftCommandState.makeMockState(options: staticExecutableOptions)
+
+        XCTAssert(try staticExecutable.productsBuildParameters.flags.swiftCompilerFlags.contains("-static-executable"))
+        XCTAssertFalse(try staticExecutable.toolsBuildParameters.flags.swiftCompilerFlags.contains("-static-executable"))
+
+        // Verify that the flags are used appropriately in the build plan
+        plan = try BuildPlan(
+            destinationBuildParameters: staticExecutable.productsBuildParameters,
+            toolsBuildParameters: staticExecutable.toolsBuildParameters,
+            graph: graph,
+            fileSystem: fs,
+            observabilityScope: observer.topScope
+        )
+        let result = try BuildPlanResult(plan: plan)
+
+        // exe should be built with -static-executable
+        let exe = try result.target(for: "exe")
+        XCTAssert(try exe.swiftTarget().compileArguments().contains("-static-executable"))
+
+        // helper should be built without -static-executable
+        // There are 2 helper targets in the plan:
+        // - one will yield a normal target,
+        // - the other is for the use of the command plugin
+        // We can find the correct one via the plugin's dependency chain.
+        let plugin = plan.graph.allTargets.first(where: { $0.name == "plugin" })!
+        let helper = (plugin.dependencies.first(where: { $0.name == "helper"})?.target)!
+        let helperTarget = plan.targetMap[helper.id]!
+        XCTAssertFalse(try helperTarget.swiftTarget().compileArguments().contains("-static-executable"))
+    }
 }
 
 extension SwiftCommandState {