Use SwiftBuild API to reliably compute built artifacts (#9143)

Depends on swiftlang/swift-build#801

By querying the build system for the artifacts, we ensure we only report
any we will actually produce in the current build. At the same time,
pull in an alternative fix for
#9121 which
restores the original behavior of the native build system when
considering products in dependency packages.

Author: owenv

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 {