Activate swift build support for command plugins (#8845)

cmcgee1024 · marcprux · commit 647566c12f05 · 2025-07-07T17:48:07.000-04:00
Be consistent in the detection of the build system settings so that both
the build system and the build parameters are using the same setting. Use
the build system setting given after the command plugin name as the highest
precedence, followed by the one (if any) provided after the package
subcommand.

When building a specific target with the swiftbuild build system, set
the configured target in the build request to be the one that isn't a
dynamic target.

Tag the `TraitTest.packagePluginGetSymbolGraph_enablesAllTraits` with a
known issue when using the swiftbuild build system since the symbol graph
extraction is not yet working there.

Add the toolchain's runtime environment to the environment used when
running command plugins so that the tools have the necessary runtime
dependencies when the plugin decides to run them on platforms like Linux.
diff --git a/Sources/Commands/PackageCommands/PluginCommand.swift b/Sources/Commands/PackageCommands/PluginCommand.swift
@@ -205,12 +205,17 @@ struct PluginCommand: AsyncSwiftCommand {
         swiftCommandState.shouldDisableSandbox = swiftCommandState.shouldDisableSandbox || pluginArguments.globalOptions.security
             .shouldDisableSandbox
 
+        let buildSystemKind =
+            pluginArguments.globalOptions.build.buildSystem != .native ?
+                pluginArguments.globalOptions.build.buildSystem :
+                swiftCommandState.options.build.buildSystem
+
         // At this point we know we found exactly one command plugin, so we run it. In SwiftPM CLI, we have only one root package.
         try await PluginCommand.run(
             plugin: matchingPlugins[0],
             package: packageGraph.rootPackages[packageGraph.rootPackages.startIndex],
             packageGraph: packageGraph,
-            buildSystem: pluginArguments.globalOptions.build.buildSystem,
+            buildSystem: buildSystemKind,
             options: pluginOptions,
             arguments: unparsedArguments,
             swiftCommandState: swiftCommandState
@@ -327,7 +332,9 @@ struct PluginCommand: AsyncSwiftCommand {
         let toolSearchDirs = [try swiftCommandState.getTargetToolchain().swiftCompilerPath.parentDirectory]
             + getEnvSearchPaths(pathString: Environment.current[.path], currentWorkingDirectory: .none)
 
-        let buildParameters = try swiftCommandState.toolsBuildParameters
+        var buildParameters = try swiftCommandState.toolsBuildParameters
+        buildParameters.buildSystemKind = buildSystemKind
+
         // Build or bring up-to-date any executable host-side tools on which this plugin depends. Add them and any binary dependencies to the tool-names-to-path map.
         let buildSystem = try await swiftCommandState.createBuildSystem(
             explicitBuildSystem: buildSystemKind,
@@ -342,15 +349,21 @@ struct PluginCommand: AsyncSwiftCommand {
             fileSystem: swiftCommandState.fileSystem,
             environment: buildParameters.buildEnvironment,
             for: try pluginScriptRunner.hostTriple
-        ) { name, _ in
+        ) { name, path in
             // Build the product referenced by the tool, and add the executable to the tool map. Product dependencies are not supported within a package, so if the tool happens to be from the same package, we instead find the executable that corresponds to the product. There is always one, because of autogeneration of implicit executables with the same name as the target if there isn't an explicit one.
             try await buildSystem.build(subset: .product(name, for: .host))
-            if let builtTool = try buildSystem.buildPlan.buildProducts.first(where: {
-                $0.product.name == name && $0.buildParameters.destination == .host
-            }) {
-                return try builtTool.binaryPath
+
+            // TODO determine if there is a common way to calculate the build tool binary path that doesn't depend on the build system.
+            if buildSystemKind == .native {
+                if let builtTool = try buildSystem.buildPlan.buildProducts.first(where: {
+                    $0.product.name == name && $0.buildParameters.destination == .host
+                }) {
+                    return try builtTool.binaryPath
+                } else {
+                    return nil
+                }
             } else {
-                return nil
+                return buildParameters.buildPath.appending(path)
             }
         }
 
diff --git a/Sources/Commands/Utilities/PluginDelegate.swift b/Sources/Commands/Utilities/PluginDelegate.swift
@@ -181,30 +181,39 @@ final class PluginDelegate: PluginInvocationDelegate {
         // Run the build. This doesn't return until the build is complete.
         let success = await buildSystem.buildIgnoringError(subset: buildSubset)
 
-        // Create and return the build result record based on what the delegate collected and what's in the build plan.
-        let builtProducts = try buildSystem.buildPlan.buildProducts.filter {
-            switch subset {
-            case .all(let includingTests):
-                return includingTests ? true : $0.product.type != .test
-            case .product(let name):
-                return $0.product.name == name
-            case .target(let name):
-                return $0.product.name == name
+        let packageGraph = try await buildSystem.getPackageGraph()
+
+        var builtArtifacts: [PluginInvocationBuildResult.BuiltArtifact] = []
+
+        for rootPkg in packageGraph.rootPackages {
+            let builtProducts = rootPkg.products.filter {
+                switch subset {
+                case .all(let includingTests):
+                    return includingTests ? true : $0.type != .test
+                case .product(let name):
+                    return $0.name == name
+                case .target(let name):
+                    return $0.name == name
+                }
             }
-        }
-        let builtArtifacts: [PluginInvocationBuildResult.BuiltArtifact] = try builtProducts.compactMap {
-            switch $0.product.type {
-            case .library(let kind):
-                return try .init(
-                    path: $0.binaryPath.pathString,
-                    kind: (kind == .dynamic) ? .dynamicLibrary : .staticLibrary
-                )
-            case .executable:
-                return try .init(path: $0.binaryPath.pathString, kind: .executable)
-            default:
-                return nil
+
+            let artifacts: [PluginInvocationBuildResult.BuiltArtifact] = try builtProducts.compactMap {
+                switch $0.type {
+                case .library(let kind):
+                    return .init(
+                        path: try buildParameters.binaryPath(for: $0).pathString,
+                        kind: (kind == .dynamic) ? .dynamicLibrary : .staticLibrary
+                    )
+                case .executable:
+                    return .init(path: try buildParameters.binaryPath(for: $0).pathString, kind: .executable)
+                default:
+                    return nil
+                }
             }
+
+            builtArtifacts.append(contentsOf: artifacts)
         }
+
         return PluginInvocationBuildResult(
             succeeded: success,
             logText: bufferedOutputStream.bytes.cString,
diff --git a/Sources/SPMBuildCore/Plugins/DefaultPluginScriptRunner.swift b/Sources/SPMBuildCore/Plugins/DefaultPluginScriptRunner.swift
@@ -463,13 +463,22 @@ public struct DefaultPluginScriptRunner: PluginScriptRunner, Cancellable {
         let process = Foundation.Process()
         process.executableURL = URL(fileURLWithPath: command[0])
         process.arguments = Array(command.dropFirst())
-        process.environment = ProcessInfo.processInfo.environment
+
+        var env = Environment.current
+
+        // Update the environment for any runtime library paths that tools compiled
+        // for the command plugin might require after they have been built.
+        let runtimeLibPaths = self.toolchain.runtimeLibraryPaths
+        for libPath in runtimeLibPaths {
+            env.appendPath(key: .libraryPath, value: libPath.pathString)
+        }
+
 #if os(Windows)
         let pluginLibraryPath = self.toolchain.swiftPMLibrariesLocation.pluginLibraryPath.pathString
-        var env = Environment.current
         env.prependPath(key: .path, value: pluginLibraryPath)
-        process.environment = .init(env)
 #endif
+        process.environment = .init(env)
+
         process.currentDirectoryURL = workingDirectory.asURL
         
         // Set up a pipe for sending structured messages to the plugin on its stdin.
diff --git a/Sources/SwiftBuildSupport/SwiftBuildSystem.swift b/Sources/SwiftBuildSupport/SwiftBuildSystem.swift
@@ -317,7 +317,8 @@ public final class SwiftBuildSystem: SPMBuildCore.BuildSystem {
                         let workspaceInfo = try await session.workspaceInfo()
 
                         configuredTargets = try [pifTargetName].map { targetName in
-                            let infos = workspaceInfo.targetInfos.filter { $0.targetName == targetName }
+                            // TODO we filter dynamic targets until Swift Build doesn't give them to us anymore
+                            let infos = workspaceInfo.targetInfos.filter { $0.targetName == targetName && !TargetSuffix.dynamic.hasSuffix(id: GUID($0.guid)) }
                             switch infos.count {
                             case 0:
                                 self.observabilityScope.emit(error: "Could not find target named '\(targetName)'")
@@ -397,11 +398,20 @@ public final class SwiftBuildSystem: SPMBuildCore.BuildSystem {
                             self.observabilityScope.emit(info: "\(String(decoding: info.data, as: UTF8.self))")
                         case .taskStarted(let info):
                             try buildState.started(task: info)
+
                             if let commandLineDisplay = info.commandLineDisplayString {
                                 self.observabilityScope.emit(info: "\(info.executionDescription)\n\(commandLineDisplay)")
                             } else {
                                 self.observabilityScope.emit(info: "\(info.executionDescription)")
                             }
+
+                            if self.logLevel.isVerbose {
+                                if let commandLineDisplay = info.commandLineDisplayString {
+                                    self.outputStream.send("\(info.executionDescription)\n\(commandLineDisplay)")
+                                } else {
+                                    self.outputStream.send("\(info.executionDescription)")
+                                }
+                            }
                         case .taskComplete(let info):
                             let startedInfo = try buildState.completed(task: info)
                             if info.result != .success {
diff --git a/Tests/CommandsTests/PackageCommandTests.swift b/Tests/CommandsTests/PackageCommandTests.swift
@@ -2802,8 +2802,16 @@ class PackageCommandTestCase: CommandsBuildProviderTestCase {
         // Only run the test if the environment in which we're running actually supports Swift concurrency (which the plugin APIs require).
         try XCTSkipIf(!UserToolchain.default.supportsSwiftConcurrency(), "skipping because test environment doesn't support concurrency")
 
-        let debugTarget = [".build", "debug", executableName("placeholder")]
-        let releaseTarget = [".build", "release", executableName("placeholder")]
+        #if os(Linux)
+        let osSuffix = "-linux"
+        #elseif os(Windows)
+        let osSuffix = "-windows"
+        #else
+        let osSuffix = ""
+        #endif
+
+        let debugTarget = self.buildSystemProvider == .native ? [".build", "debug", executableName("placeholder")] : [".build", try UserToolchain.default.targetTriple.platformBuildPathComponent, "Products", "Debug\(osSuffix)", "placeholder"]
+        let releaseTarget = self.buildSystemProvider == .native ? [".build", "release", executableName("placeholder")] : [".build", try UserToolchain.default.targetTriple.platformBuildPathComponent, "Products", "Release\(osSuffix)", "placeholder"]
 
         func AssertIsExecutableFile(_ fixturePath: AbsolutePath, file: StaticString = #filePath, line: UInt = #line) {
             XCTAssert(
@@ -2837,6 +2845,10 @@ class PackageCommandTestCase: CommandsBuildProviderTestCase {
             AssertNotExists(fixturePath.appending(components: releaseTarget))
         }
 
+        if self.buildSystemProvider == .swiftbuild && ProcessInfo.hostOperatingSystem != .macOS {
+            throw XCTSkip("Failed to find dsymutil tool: https://github.com/swiftlang/swift-package-manager/issues/8862")
+        }
+
         // If the plugin requests a release binary, that is what will be built, regardless of overall configuration
         try await fixture(name: "Miscellaneous/Plugins/CommandPluginTestStub") { fixturePath in
             let _ = try await self.execute(["-c", "debug", "build-target", "build-release"], packagePath: fixturePath)
@@ -2868,6 +2880,8 @@ class PackageCommandTestCase: CommandsBuildProviderTestCase {
             await XCTAssertAsyncNoThrow(try await self.execute(["-c", "debug", "check-testability", "InternalModule", "debug", "true"], packagePath: fixturePath))
         }
 
+        if buildSystemProvider == .swiftbuild && ProcessInfo.hostOperatingSystem != .macOS { throw XCTSkip("Failed to find dsymutil tool: https://github.com/swiftlang/swift-package-manager/issues/8862") }
+
         // Overall configuration: debug, plugin build request: release -> without testability
         try await fixture(name: "Miscellaneous/Plugins/CommandPluginTestStub") { fixturePath in
             await XCTAssertAsyncNoThrow(try await self.execute(["-c", "debug", "check-testability", "InternalModule", "release", "false"], packagePath: fixturePath))
@@ -2914,7 +2928,8 @@ class PackageCommandTestCase: CommandsBuildProviderTestCase {
             XCTAssertMatch(stdout, isEmpty)
             // Filter some unrelated output that could show up on stderr.
             let filteredStderr = stderr.components(separatedBy: "\n")
-              .filter { !$0.contains("Unable to locate libSwiftScan") }.joined(separator: "\n")
+              .filter { !$0.contains("Unable to locate libSwiftScan") }
+              .filter { !($0.contains("warning: ") && $0.contains("unable to find libclang")) }.joined(separator: "\n")
             XCTAssertMatch(filteredStderr, isEmpty)
         }
 
@@ -2924,7 +2939,8 @@ class PackageCommandTestCase: CommandsBuildProviderTestCase {
             XCTAssertMatch(stdout, containsLogtext)
             // Filter some unrelated output that could show up on stderr.
             let filteredStderr = stderr.components(separatedBy: "\n")
-              .filter { !$0.contains("Unable to locate libSwiftScan") }.joined(separator: "\n")
+              .filter { !$0.contains("Unable to locate libSwiftScan") }
+              .filter { !($0.contains("warning: ") && $0.contains("unable to find libclang")) }.joined(separator: "\n")
             XCTAssertMatch(filteredStderr, isEmpty)
         }
 
@@ -3462,9 +3478,11 @@ class PackageCommandTestCase: CommandsBuildProviderTestCase {
                 let (stdout, _) = try await self.execute(["my-build-tester", "--product", "MyExecutable", "--print-commands"], packagePath: packageDir)
                 XCTAssertMatch(stdout, .contains("Building for debugging..."))
                 XCTAssertNoMatch(stdout, .contains("Building for production..."))
-                XCTAssertMatch(stdout, .contains("-module-name MyExecutable"))
-                XCTAssertMatch(stdout, .contains("-DEXTRA_SWIFT_FLAG"))
-                XCTAssertMatch(stdout, .contains("Build of product 'MyExecutable' complete!"))
+                if buildSystemProvider == .native {
+                    XCTAssertMatch(stdout, .contains("-module-name MyExecutable"))
+                    XCTAssertMatch(stdout, .contains("-DEXTRA_SWIFT_FLAG"))
+                    XCTAssertMatch(stdout, .contains("Build of product 'MyExecutable' complete!"))
+                }
                 XCTAssertMatch(stdout, .contains("succeeded: true"))
                 switch buildSystemProvider {
                 case .native:
@@ -3483,7 +3501,9 @@ class PackageCommandTestCase: CommandsBuildProviderTestCase {
                 XCTAssertMatch(stdout, .contains("Building for production..."))
                 XCTAssertNoMatch(stdout, .contains("Building for debug..."))
                 XCTAssertNoMatch(stdout, .contains("-module-name MyExecutable"))
-                XCTAssertMatch(stdout, .contains("Build of product 'MyExecutable' complete!"))
+                if buildSystemProvider == .native {
+                    XCTAssertMatch(stdout, .contains("Build of product 'MyExecutable' complete!"))
+                }
                 XCTAssertMatch(stdout, .contains("succeeded: true"))
                 switch buildSystemProvider {
                 case .native:
@@ -3494,6 +3514,11 @@ class PackageCommandTestCase: CommandsBuildProviderTestCase {
                     XCTFail("unimplemented assertion for --build-system xcode")
                 }
                 XCTAssertMatch(stdout, .and(.contains("artifact-kind:"), .contains("executable")))
+            } catch {
+                if ProcessInfo.hostOperatingSystem != .macOS && self.buildSystemProvider == .swiftbuild {
+                    throw XCTSkip("Failed to find dsymutil tool: https://github.com/swiftlang/swift-package-manager/issues/8862")
+                }
+                throw error
             }
 
             // Invoke the plugin with parameters choosing a verbose build of MyStaticLibrary for release.
@@ -3502,7 +3527,9 @@ class PackageCommandTestCase: CommandsBuildProviderTestCase {
                 XCTAssertMatch(stdout, .contains("Building for production..."))
                 XCTAssertNoMatch(stdout, .contains("Building for debug..."))
                 XCTAssertNoMatch(stdout, .contains("-module-name MyLibrary"))
-                XCTAssertMatch(stdout, .contains("Build of product 'MyStaticLibrary' complete!"))
+                if buildSystemProvider == .native {
+                    XCTAssertMatch(stdout, .contains("Build of product 'MyStaticLibrary' complete!"))
+                }
                 XCTAssertMatch(stdout, .contains("succeeded: true"))
                 switch buildSystemProvider {
                 case .native:
@@ -3513,6 +3540,11 @@ class PackageCommandTestCase: CommandsBuildProviderTestCase {
                     XCTFail("unimplemented assertion for --build-system xcode")
                 }
                 XCTAssertMatch(stdout, .and(.contains("artifact-kind:"), .contains("staticLibrary")))
+            } catch {
+                if ProcessInfo.hostOperatingSystem != .macOS && self.buildSystemProvider == .swiftbuild {
+                    throw XCTSkip("Failed to find dsymutil tool: https://github.com/swiftlang/swift-package-manager/issues/8862")
+                }
+                throw error
             }
 
             // Invoke the plugin with parameters choosing a verbose build of MyDynamicLibrary for release.
@@ -3521,7 +3553,9 @@ class PackageCommandTestCase: CommandsBuildProviderTestCase {
                 XCTAssertMatch(stdout, .contains("Building for production..."))
                 XCTAssertNoMatch(stdout, .contains("Building for debug..."))
                 XCTAssertNoMatch(stdout, .contains("-module-name MyLibrary"))
-                XCTAssertMatch(stdout, .contains("Build of product 'MyDynamicLibrary' complete!"))
+                if buildSystemProvider == .native {
+                    XCTAssertMatch(stdout, .contains("Build of product 'MyDynamicLibrary' complete!"))
+                }
                 XCTAssertMatch(stdout, .contains("succeeded: true"))
                 switch buildSystemProvider {
                 case .native:
@@ -3536,6 +3570,11 @@ class PackageCommandTestCase: CommandsBuildProviderTestCase {
                     XCTFail("unimplemented assertion for --build-system xcode")
                 }
                 XCTAssertMatch(stdout, .and(.contains("artifact-kind:"), .contains("dynamicLibrary")))
+            } catch {
+                if ProcessInfo.hostOperatingSystem != .macOS && self.buildSystemProvider == .swiftbuild {
+                    throw XCTSkip("Failed to find dsymutil tool: https://github.com/swiftlang/swift-package-manager/issues/8862")
+                }
+                throw error
             }
         }
     }
@@ -4097,9 +4136,14 @@ class PackageCommandSwiftBuildTests: PackageCommandTestCase {
     override func testNoParameters() async throws {
         try await super.testNoParameters()
     }
-    
-    override func testCommandPluginBuildTestability() async throws {
-        throw XCTSkip("SWBINTTODO: Test fails as plugins are not currenty supported")
+
+    override func testCommandPluginSymbolGraphCallbacks() async throws {
+        throw XCTSkip("SWBINTTODO: Symbol graph extraction does not yet work with swiftbuild build system")
+    }
+
+    override func testCommandPluginBuildingCallbacks() async throws {
+        try XCTSkipOnWindows(because: "TSCBasic/Path.swift:969: Assertion failed, https://github.com/swiftlang/swift-package-manager/issues/8602")
+        try await super.testCommandPluginBuildingCallbacks()
     }
 
     override func testMigrateCommand() async throws {
diff --git a/Tests/FunctionalTests/PluginTests.swift b/Tests/FunctionalTests/PluginTests.swift
diff --git a/Tests/FunctionalTests/TraitTests.swift b/Tests/FunctionalTests/TraitTests.swift
