Use SwiftBuild API to reliably compute built artifacts

Fixtures/PartiallyUnusedDependency/Dep/Package.swift

@@ -0,0 +1,27 @@
+// swift-tools-version: 6.0
+
+import PackageDescription
+
+let package = Package(
+    name: "Dep",
+    products: [
+        .library(
+            name: "MyDynamicLibrary",
+            type: .dynamic,
+            targets: ["MyDynamicLibrary"]
+        ),
+        .executable(
+            name: "MySupportExecutable",
+            targets: ["MySupportExecutable"]
+        )
+    ],
+    targets: [
+        .target(
+            name: "MyDynamicLibrary"
+        ),
+        .executableTarget(
+            name: "MySupportExecutable",
+            dependencies: ["MyDynamicLibrary"]
+        )
+    ]
+)

Fixtures/PartiallyUnusedDependency/Dep/Sources/MyDynamicLibrary/Dep.swift

@@ -0,0 +1,3 @@
+public func sayHello() {
+    print("hello!")
+}

Fixtures/PartiallyUnusedDependency/Dep/Sources/MySupportExecutable/exe.swift

@@ -0,0 +1,8 @@
+import MyDynamicLibrary
+
+@main struct Entry {
+    static func main() {
+        print("running support tool")
+        sayHello()
+    }
+}

Fixtures/PartiallyUnusedDependency/Package.swift

@@ -0,0 +1,29 @@
+// swift-tools-version: 6.0
+
+import PackageDescription
+
+let package = Package(
+    name: "PartiallyUnusedDependency",
+    products: [
+        .executable(
+            name: "MyExecutable",
+            targets: ["MyExecutable"]
+        ),
+    ],
+    dependencies: [
+        .package(path: "Dep")
+    ],
+    targets: [
+        .executableTarget(
+            name: "MyExecutable",
+            dependencies: [.product(name: "MyDynamicLibrary", package: "Dep")]
+        ),
+        .plugin(
+            name: "dump-artifacts-plugin",
+            capability: .command(
+                intent: .custom(verb: "dump-artifacts-plugin", description: "Dump Artifacts"),
+                permissions: []
+            )
+        )
+    ]
+)

Fixtures/PartiallyUnusedDependency/Plugins/dump-artifacts-plugin.swift

@@ -0,0 +1,24 @@
+import PackagePlugin
+
+@main
+struct DumpArtifactsPlugin: CommandPlugin {
+    func performCommand(
+        context: PluginContext,
+        arguments: [String]
+    ) throws {
+        do {
+            var parameters = PackageManager.BuildParameters()
+            parameters.configuration = .debug
+            parameters.logging = .concise
+            let result = try packageManager.build(.all(includingTests: false), parameters: parameters)
+            print("succeeded: \(result.succeeded)")
+            for artifact in result.builtArtifacts {
+                print("artifact-path: \(artifact.path.string)")
+                print("artifact-kind: \(artifact.kind)")
+            }
+        }
+        catch {
+            print("error from the plugin host: \\(error)")
+        }
+    }
+}

Fixtures/PartiallyUnusedDependency/Sources/MyExecutable/PartiallyUnusedDependency.swift

@@ -0,0 +1,8 @@
+import MyDynamicLibrary
+
+@main struct Entry {
+    static func main() {
+        print("Hello, world!")
+        sayHello()
+    }
+}

Sources/Build/BuildOperation.swift

@@ -461,11 +461,37 @@ public final class BuildOperation: PackageStructureDelegate, SPMBuildCore.BuildS
         let buildResultBuildPlan = buildOutputs.contains(.buildPlan) ? try buildPlan : nil
         let buildResultReplArgs = buildOutputs.contains(.replArguments) ? try buildPlan.createREPLArguments() : nil
 
+        let artifacts: [(String, PluginInvocationBuildResult.BuiltArtifact)]?
+        if buildOutputs.contains(.builtArtifacts) {
+            let builtProducts = try buildPlan.buildProducts
+            artifacts = try builtProducts.compactMap {
+                switch $0.product.type {
+                case .library(let kind):
+                    let artifactKind: PluginInvocationBuildResult.BuiltArtifact.Kind
+                    switch kind {
+                        case .dynamic: artifactKind = .dynamicLibrary
+                        case .static, .automatic: artifactKind = .staticLibrary
+                    }
+                    return try ($0.product.name, .init(
+                        path: $0.binaryPath.pathString,
+                        kind: artifactKind)
+                    )
+                case .executable:
+                    return try ($0.product.name, .init(path: $0.binaryPath.pathString, kind: .executable))
+                default:
+                    return nil
+                }
+            }
+        } else {
+            artifacts = nil
+        }
+
         result = BuildResult(
             serializedDiagnosticPathsByTargetName: result.serializedDiagnosticPathsByTargetName,
             symbolGraph: result.symbolGraph,
             buildPlan: buildResultBuildPlan,
             replArguments: buildResultReplArgs,
+            builtArtifacts: artifacts
         )
         var serializedDiagnosticPaths: [String: [AbsolutePath]] = [:]
         do {

Sources/Commands/Utilities/PluginDelegate.swift

@@ -178,40 +178,21 @@ final class PluginDelegate: PluginInvocationDelegate {
         )
 
         // Run the build. This doesn't return until the build is complete.
-        let success = await buildSystem.buildIgnoringError(subset: buildSubset)
+        let result = await buildSystem.buildIgnoringError(subset: buildSubset, buildOutputs: [.builtArtifacts])
+        let success = result != nil
 
         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 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
-                }
+        var builtArtifacts: [PluginInvocationBuildResult.BuiltArtifact] = (result?.builtArtifacts ?? []).filter { (name, _) in
+            switch subset {
+            case .all(let includingTests):
+                return true
+            case .product(let productName):
+                return name == productName
+            case .target(let targetName):
+                return name == targetName
             }
-
-            builtArtifacts.append(contentsOf: artifacts)
-        }
+        }.map(\.1)
 
         return PluginInvocationBuildResult(
             succeeded: success,
@@ -495,12 +476,11 @@ final class PluginDelegate: PluginInvocationDelegate {
 }
 
 extension BuildSystem {
-    fileprivate func buildIgnoringError(subset: BuildSubset) async -> Bool {
+    fileprivate func buildIgnoringError(subset: BuildSubset, buildOutputs: [BuildOutput]) async -> BuildResult? {
         do {
-            try await self.build(subset: subset, buildOutputs: [])
-            return true
+            return try await self.build(subset: subset, buildOutputs: buildOutputs)
         } catch {
-            return false
+            return nil
         }
     }
 }
@@ -533,4 +513,4 @@ fileprivate extension BuildOutput.SymbolGraphAccessLevel {
             .open
         }
     }
-}
+}

Sources/SPMBuildCore/BuildSystem/BuildSystem.swift

@@ -39,32 +39,6 @@ public enum BuildSubset {
 /// build systems can produce all possible build outputs. Check the build
 /// result for indication that the output was produced.
 public enum BuildOutput: Equatable {
-    public static func == (lhs: BuildOutput, rhs: BuildOutput) -> Bool {
-        switch lhs {    
-        case .symbolGraph(let leftOptions):
-            switch rhs {
-                case .symbolGraph(let rightOptions):
-                    return leftOptions == rightOptions
-                default:
-                    return false
-            }
-        case .buildPlan:
-            switch rhs {
-                case .buildPlan:
-                    return true
-                default:
-                    return false
-            }
-        case .replArguments:
-            switch rhs {
-                case .replArguments:
-                    return true
-                default:
-                    return false
-            }
-        }
-    }
-
     public enum SymbolGraphAccessLevel: String {
         case `private`, `fileprivate`, `internal`, `package`, `public`, `open`
     }
@@ -93,6 +67,7 @@ public enum BuildOutput: Equatable {
     case symbolGraph(SymbolGraphOptions)
     case buildPlan
     case replArguments
+    case builtArtifacts
 }
 
 /// A protocol that represents a build system used by SwiftPM for all build operations. This allows factoring out the
@@ -144,19 +119,22 @@ public struct BuildResult {
         serializedDiagnosticPathsByTargetName: Result<[String: [AbsolutePath]], Error>,
         symbolGraph: SymbolGraphResult? = nil,
         buildPlan: BuildPlan? = nil,
-        replArguments: CLIArguments?
+        replArguments: CLIArguments?,
+        builtArtifacts: [(String, PluginInvocationBuildResult.BuiltArtifact)]? = nil
     ) {
         self.serializedDiagnosticPathsByTargetName = serializedDiagnosticPathsByTargetName
         self.symbolGraph = symbolGraph
         self.buildPlan = buildPlan
         self.replArguments = replArguments
+        self.builtArtifacts = builtArtifacts
     }
 
     public let replArguments: CLIArguments?
     public let symbolGraph: SymbolGraphResult?
     public let buildPlan: BuildPlan?
 
     public var serializedDiagnosticPathsByTargetName: Result<[String: [AbsolutePath]], Error>
+    public var builtArtifacts: [(String, PluginInvocationBuildResult.BuiltArtifact)]?
 }
 
 public protocol ProductBuildDescription {