Update Target Based Resolution

Package.swift

@@ -597,3 +597,14 @@ if ProcessInfo.processInfo.environment["SWIFTCI_USE_LOCAL_DEPS"] == nil {
         .package(path: "../swift-collections"),
     ]
 }
+
+// FIXME: Once we are confident target based dependency resolution is reliable, this switch can be removed.
+if ProcessInfo.processInfo.environment["DISABLE_TARGET_BASED_DEPENDENCY_RESOLUTION"] == nil {  // Currently enabled by default.
+    for target in package.targets {
+        var swiftSettings = target.swiftSettings ?? []
+        defer { target.swiftSettings = swiftSettings }
+        if target.name != "SPMSQLite3" {
+            swiftSettings.append(.define("ENABLE_TARGET_BASED_DEPENDENCY_RESOLUTION"))
+        }
+    }
+}

Sources/PackageGraph/DependencyResolutionNode.swift

@@ -60,23 +60,38 @@ public enum DependencyResolutionNode {
     ///   to the information needed in order to provide actionable suggestions to help the user stitch up the dependency declarations properly.
     case root(package: PackageReference)
 
+    // FIXME: If command plugins become explicit in the manifest, or are extricated from the main graph, `implicitCommands` should be removed.
+    /// A node representing any implicit command plugins vended by a package.
+    ///
+    /// This type of node is equivalent to a product node in all respects,
+    /// except that the number and names of the products are unkown,
+    /// because the manifest contains no explicit reference to them.
+    case implicitCommands(package: PackageReference)
+
     /// The package.
     public var package: PackageReference {
         switch self {
-        case .empty(let package), .product(_, let package), .root(let package):
+        case .empty(let package), .product(_, let package), .root(let package), .implicitCommands(package: let package):
             return package
         }
     }
 
     /// The name of the specific product if the node is a product node, otherwise `nil`.
     public var specificProduct: String? {
         switch self {
-        case .empty, .root:
+        case .empty, .root, .implicitCommands:
             return nil
         case .product(let product, _):
             return product
         }
     }
+    public var isImplicitCommandsNode: Bool {
+        if case .implicitCommands = self {
+            return true
+        } else {
+            return false
+        }
+    }
 
     /// Assembles the product filter to use on the manifest for this node to determine its dependencies.
     public var productFilter: ProductFilter {
@@ -87,6 +102,8 @@ public enum DependencyResolutionNode {
             return .specific([product])
         case .root:
             return .everything
+        case .implicitCommands:
+            return .specific([], includeCommands: true)
         }
     }
 
@@ -95,7 +112,7 @@ public enum DependencyResolutionNode {
     /// This is the constraint that requires all products from a package resolve to the same version.
     internal func versionLock(version: Version) -> PackageContainerConstraint? {
         // Don’t create a version lock for anything but a product.
-        guard specificProduct != nil else { return nil }
+        guard specificProduct != nil || isImplicitCommandsNode else { return nil }
         return PackageContainerConstraint(
             package: self.package,
             versionRequirement: .exact(version),
@@ -108,7 +125,7 @@ public enum DependencyResolutionNode {
     /// This is the constraint that requires all products from a package resolve to the same revision.
     internal func revisionLock(revision: String) -> PackageContainerConstraint? {
         // Don’t create a revision lock for anything but a product.
-        guard specificProduct != nil else { return nil }
+        guard specificProduct != nil || isImplicitCommandsNode else { return nil }
         return PackageContainerConstraint(
             package: self.package,
             requirement: .revision(revision),
@@ -119,14 +136,17 @@ public enum DependencyResolutionNode {
 
 extension DependencyResolutionNode: Equatable {
     public static func ==(lhs: DependencyResolutionNode, rhs: DependencyResolutionNode) -> Bool {
-        return (lhs.package, lhs.specificProduct) == (rhs.package, rhs.specificProduct)
+        return lhs.package == rhs.package
+        && lhs.specificProduct == rhs.specificProduct
+        && lhs.isImplicitCommandsNode == rhs.isImplicitCommandsNode
     }
 }
 
 extension DependencyResolutionNode: Hashable {
     public func hash(into hasher: inout Hasher) {
         hasher.combine(self.package)
         hasher.combine(self.specificProduct)
+        hasher.combine(self.isImplicitCommandsNode)
     }
 }
 

Sources/PackageGraph/GraphLoadingNode.swift

@@ -61,7 +61,7 @@ extension GraphLoadingNode: CustomStringConvertible {
         switch productFilter {
         case .everything:
             return self.identity.description
-        case .specific(let set):
+        case .specific(let set, _):
             return "\(self.identity.description)[\(set.sorted().joined(separator: ", "))]"
         }
     }

Sources/PackageGraph/PackageModel+Extensions.swift

@@ -57,12 +57,17 @@ extension PackageContainerConstraint {
             case .everything:
                 assertionFailure("Attempted to enumerate a root package’s product filter; root packages have no filter.")
                 return []
-            case .specific(let set):
+            case .specific(let set, let includeCommands):
+                var nodes: [DependencyResolutionNode]
                 if set.isEmpty { // Pointing at the package without a particular product.
-                    return [.empty(package: self.package)]
+                    nodes = [.empty(package: self.package)]
                 } else {
-                    return set.sorted().map { .product($0, package: self.package) }
+                    nodes = set.sorted().map { .product($0, package: self.package) }
                 }
+                if includeCommands {
+                    nodes.append(.implicitCommands(package: self.package))
+                }
+                return nodes
             }
         }
     }

Sources/PackageLoading/PackageBuilder.swift

@@ -1146,8 +1146,11 @@ public final class PackageBuilder {
         switch productFilter {
         case .everything:
             filteredProducts = self.manifest.products
-        case .specific(let set):
-            filteredProducts = self.manifest.products.filter { set.contains($0.name) }
+        case .specific(let set, let includeCommands):
+            filteredProducts = self.manifest.products.filter { product in
+                return set.contains(product.name)
+                || (includeCommands && self.manifest.productIsCommandPlugin(product))
+            }
         }
         for product in filteredProducts {
             if product.name.isEmpty {

Sources/PackageModel/Manifest.swift

@@ -152,6 +152,24 @@ public final class Manifest {
         self.targetMap = Dictionary(targets.lazy.map({ ($0.name, $0) }), uniquingKeysWith: { $1 })
     }
 
+    public func productIsCommandPlugin(_ product: ProductDescription) -> Bool {
+        return product.type == .plugin
+        && self.targets.contains(where: { target in
+            if case .command = target.pluginCapability,
+               product.targets.contains(target.name) {
+                return true
+            } else {
+                return false
+            }
+        })
+    }
+    internal func productIsCommandPlugin(_ product: String) -> Bool {
+        return products.contains(where: { possibleMatch in
+            return possibleMatch.name == product
+            && self.productIsCommandPlugin(possibleMatch)
+        })
+    }
+
     /// Returns the targets required for a particular product filter.
     public func targetsRequired(for productFilter: ProductFilter) -> [TargetDescription] {
         #if ENABLE_TARGET_BASED_DEPENDENCY_RESOLUTION
@@ -163,8 +181,11 @@ public final class Manifest {
             switch productFilter {
             case .everything:
                 return self.targets
-            case .specific(let productFilter):
-                let products = self.products.filter { productFilter.contains($0.name) }
+            case .specific(let productFilter, let includeCommands):
+                let products = self.products.filter { product in
+                    return productFilter.contains(product.name)
+                    || (includeCommands && productIsCommandPlugin(product))
+                }
                 targets = targetsRequired(for: products)
             }
 
@@ -184,7 +205,11 @@ public final class Manifest {
             return dependencies
         } else {
             let targets = self.targetsRequired(for: productFilter)
-            let dependencies = self.dependenciesRequired(for: targets, keepUnused: productFilter == .everything)
+            let dependencies = self.dependenciesRequired(
+                for: targets,
+                keepImplicitCommandPlugins: productFilter == .everything,
+                keepUnused: productFilter == .everything
+            )
             self._requiredDependencies[productFilter] = dependencies
             return dependencies
         }
@@ -264,6 +289,7 @@ public final class Manifest {
     /// The returned dependencies have their particular product filters registered. (To determine product filters without removing any dependencies from the list, specify `keepUnused: true`.)
     private func dependenciesRequired(
         for targets: [TargetDescription],
+        keepImplicitCommandPlugins: Bool,
         keepUnused: Bool = false
     ) -> [PackageDependency] {
 
@@ -291,13 +317,13 @@ public final class Manifest {
 
         return dependencies.compactMap { dependency in
             if let filter = associations[dependency.identity] {
-                return dependency.filtered(by: filter)
+                return dependency.filtered(by: keepImplicitCommandPlugins ? filter.includingImplicitCommands() : filter)
             } else if keepUnused {
                 // Register that while the dependency was kept, no products are needed.
-                return dependency.filtered(by: .nothing)
+                return dependency.filtered(by: keepImplicitCommandPlugins ? .nothing.includingImplicitCommands() : .nothing)
             } else {
                 // Dependencies known to not have any relevant products are discarded.
-                return nil
+                return keepImplicitCommandPlugins ? dependency.filtered(by: .nothing.includingImplicitCommands()) : nil
             }
         }
     }

Sources/PackageModel/Product.swift

@@ -113,15 +113,18 @@ public enum ProductType: Equatable, Hashable {
 /// Any product which matches the filter will be used for dependency resolution, whereas unrequested products will be ignored.
 ///
 /// Requested products need not actually exist in the package. Under certain circumstances, the resolver may request names whose package of origin are unknown. The intended package will recognize and fulfill the request; packages that do not know what it is will simply ignore it.
-public enum ProductFilter: Equatable, Hashable {
+public enum ProductFilter: Codable, Equatable, Hashable {
 
     /// All products, targets, and tests are requested.
     ///
     /// This is used for root packages.
     case everything
 
+    // FIXME: If command plugins become explicit in the manifest, or are extricated from the main graph, `includeCommands` should be removed.
     /// A set of specific products requested by one or more client packages.
-    case specific(Set<String>)
+    ///
+    /// `includeCommands` is used by first‐level dependencies to also request any command plugins, regardless of whether they are referenced anywhere.
+    case specific(Set<String>, includeCommands: Bool = false)
 
     /// No products, targets, or tests are requested.
     public static var nothing: ProductFilter { .specific([]) }
@@ -130,12 +133,15 @@ public enum ProductFilter: Equatable, Hashable {
         switch self {
         case .everything:
             return .everything
-        case .specific(let set):
+        case .specific(let set, let includeCommands):
             switch other {
             case .everything:
                 return .everything
-            case .specific(let otherSet):
-                return .specific(set.union(otherSet))
+            case .specific(let otherSet, let otherIncludeCommands):
+                return .specific(
+                    set.union(otherSet),
+                    includeCommands: includeCommands || otherIncludeCommands
+                )
             }
         }
     }
@@ -144,23 +150,22 @@ public enum ProductFilter: Equatable, Hashable {
         self = self.union(other)
     }
 
-    public func contains(_ product: String) -> Bool {
+    public func contains(_ product: String, isCommandPlugin: (String) -> Bool) -> Bool {
         switch self {
         case .everything:
             return true
-        case .specific(let set):
+        case .specific(let set, let includeCommands):
             return set.contains(product)
+            || (includeCommands && isCommandPlugin(product))
         }
     }
 
-    public func merge(_ other: ProductFilter) -> ProductFilter {
-        switch (self, other) {
-        case (.everything, _):
-            return .everything
-        case (_, .everything):
-            return .everything
-        case (.specific(let mine), .specific(let other)):
-            return .specific(mine.union(other))
+    internal func includingImplicitCommands() -> ProductFilter {
+        switch self {
+        case .everything:
+            return self
+        case .specific(let set, _):
+            return .specific(set, includeCommands: true)
         }
     }
 }
@@ -203,8 +208,8 @@ extension ProductFilter: CustomStringConvertible {
         switch self {
         case .everything:
             return "[everything]"
-        case .specific(let set):
-            return "[\(set.sorted().joined(separator: ", "))]"
+        case .specific(let set, let includeCommands):
+            return "[\(set.sorted().joined(separator: ", "))\(includeCommands ? " (including commands)" : "")]"
         }
     }
 }
@@ -254,26 +259,3 @@ extension ProductType: Codable {
         }
     }
 }
-
-extension ProductFilter: Codable {
-    public func encode(to encoder: Encoder) throws {
-        let optionalSet: Set<String>?
-        switch self {
-        case .everything:
-            optionalSet = nil
-        case .specific(let set):
-            optionalSet = set
-        }
-        var container = encoder.singleValueContainer()
-        try container.encode(optionalSet?.sorted())
-    }
-
-    public init(from decoder: Decoder) throws {
-        let container = try decoder.singleValueContainer()
-        if container.decodeNil() {
-            self = .everything
-        } else {
-            self = .specific(Set(try container.decode([String].self)))
-        }
-    }
-}

Sources/Workspace/Workspace.swift

@@ -1946,7 +1946,7 @@ extension Workspace {
         var allManifests = [(identity: PackageIdentity, manifest: Manifest, productFilter: ProductFilter)]()
         for pair in allManifestsWithPossibleDuplicates {
             if let index = deduplication[pair.key.identity]  {
-                let productFilter = allManifests[index].productFilter.merge(pair.key.productFilter)
+                let productFilter = allManifests[index].productFilter.union(pair.key.productFilter)
                 allManifests[index] = (pair.key.identity, pair.item, productFilter)
             } else {
                 deduplication[pair.key.identity] = allManifests.count

Tests/BuildTests/ModuleAliasingBuildTests.swift

@@ -2165,13 +2165,21 @@ final class ModuleAliasingBuildTests: XCTestCase {
         ))
 
         result.checkProductsCount(1)
+        #if ENABLE_TARGET_BASED_DEPENDENCY_RESOLUTION
+        result.checkTargetsCount(6)
+        #else
         result.checkTargetsCount(7)
+        #endif
 
         XCTAssertTrue(result.targetMap.values.contains { $0.target.name == "Lib" && $0.target.moduleAliases?["Utils"] == "LibUtils" && $0.target.moduleAliases?["Render"] == "LibRender" })
         XCTAssertTrue(result.targetMap.values.contains { $0.target.name == "LibRender" && $0.target.moduleAliases?["Render"] == "LibRender" })
         XCTAssertTrue(result.targetMap.values.contains { $0.target.name == "LibUtils" && $0.target.moduleAliases?["Utils"] == "LibUtils" })
         XCTAssertFalse(result.targetMap.values.contains { $0.target.name == "DrawRender" || $0.target.moduleAliases?["Render"] == "DrawRender" })
+        #if ENABLE_TARGET_BASED_DEPENDENCY_RESOLUTION
+        XCTAssertFalse(result.targetMap.values.contains { $0.target.name == "Game" })
+        #else
         XCTAssertTrue(result.targetMap.values.contains { $0.target.name == "Game" && $0.target.moduleAliases?["Utils"] == "LibUtils" })
+        #endif
         XCTAssertTrue(result.targetMap.values.contains { $0.target.name == "Render" && $0.target.moduleAliases == nil })
         XCTAssertTrue(result.targetMap.values.contains { $0.target.name == "Utils" && $0.target.moduleAliases == nil })
         XCTAssertTrue(result.targetMap.values.contains { $0.target.name == "App" && $0.target.moduleAliases == nil })
@@ -2280,12 +2288,20 @@ final class ModuleAliasingBuildTests: XCTestCase {
         ))
 
         result.checkProductsCount(1)
+        #if ENABLE_TARGET_BASED_DEPENDENCY_RESOLUTION
+        result.checkTargetsCount(8)
+        #else
         result.checkTargetsCount(9)
+        #endif
 
         XCTAssertTrue(result.targetMap.values.contains { $0.target.name == "Lib" && $0.target.moduleAliases?["Utils"] == "LibUtils" && $0.target.moduleAliases?["Render"] == "LibRender" })
         XCTAssertTrue(result.targetMap.values.contains { $0.target.name == "LibRender" && $0.target.moduleAliases?["Render"] == "LibRender" })
         XCTAssertTrue(result.targetMap.values.contains { $0.target.name == "LibUtils" && $0.target.moduleAliases?["Utils"] == "LibUtils" })
+        #if ENABLE_TARGET_BASED_DEPENDENCY_RESOLUTION
+        XCTAssertFalse(result.targetMap.values.contains { $0.target.name == "Game" })
+        #else
         XCTAssertTrue(result.targetMap.values.contains { $0.target.name == "Game" && $0.target.moduleAliases?["Utils"] == "LibUtils" })
+        #endif
         XCTAssertTrue(result.targetMap.values.contains { $0.target.name == "Scene" && $0.target.moduleAliases?["Render"] == "DrawRender" })
         XCTAssertTrue(result.targetMap.values.contains { $0.target.name == "DrawRender" && $0.target.moduleAliases?["Render"] == "DrawRender" })
         XCTAssertTrue(result.targetMap.values.contains { $0.target.name == "Render" && $0.target.moduleAliases == nil })

Tests/PackageGraphPerformanceTests/DependencyResolverPerfTests.swift

@@ -180,7 +180,7 @@ extension ProductFilter: JSONSerializable, JSONMappable {
         switch self {
         case .everything:
             return "all".toJSON()
-        case .specific(let products):
+        case .specific(let products, _):
             return products.sorted().toJSON()
         }
     }