`PackageGraph.computeTestTargetsForExecutableTargets() is incorrectly affected by plugin usage

Sources/PackageGraph/PackageGraph.swift

@@ -188,15 +188,15 @@ public struct PackageGraph {
         // Create map of test target to set of its direct dependencies.
         let testTargetDepMap: [ResolvedTarget: Set<ResolvedTarget>] = try {
             let testTargetDeps = rootTargets.filter({ $0.type == .test }).map({
-                ($0, Set($0.dependencies.compactMap({ $0.target })))
+                ($0, Set($0.dependencies.compactMap{ $0.target }.filter{ $0.type != .plugin }))
             })
             return try Dictionary(throwingUniqueKeysWithValues: testTargetDeps)
         }()
 
         for target in rootTargets where target.type == .executable {
-            // Find all dependencies of this target within its package.
+            // Find all dependencies of this target within its package. Note that we do not traverse plugin usages.
             let dependencies = try topologicalSort(target.dependencies, successors: {
-                $0.dependencies.compactMap { $0.target }.map { .target($0, conditions: []) }
+                $0.dependencies.compactMap{ $0.target }.filter{ $0.type != .plugin }.map{ .target($0, conditions: []) }
             }).compactMap({ $0.target })
 
             // Include the test targets whose dependencies intersect with the

Tests/FunctionalTests/PluginTests.swift

@@ -509,6 +509,42 @@ class PluginTests: XCTestCase {
         }
     }
 
+    func testPluginUsageDoesntAffectTestTargetMappings() throws {
+        try XCTSkipIf(!UserToolchain.default.supportsSwiftConcurrency(), "skipping because test environment doesn't support concurrency")
+
+        try fixture(name: "Miscellaneous/Plugins/MySourceGenPlugin") { packageDir in
+            // Load a workspace from the package.
+            let observability = ObservabilitySystem.makeForTesting()
+            let workspace = try Workspace(
+                fileSystem: localFileSystem,
+                forRootPackage: packageDir,
+                customManifestLoader: ManifestLoader(toolchain: UserToolchain.default),
+                delegate: MockWorkspaceDelegate()
+            )
+
+            // Load the root manifest.
+            let rootInput = PackageGraphRootInput(packages: [packageDir], dependencies: [])
+            let rootManifests = try tsc_await {
+                workspace.loadRootManifests(
+                    packages: rootInput.packages,
+                    observabilityScope: observability.topScope,
+                    completion: $0
+                )
+            }
+            XCTAssert(rootManifests.count == 1, "\(rootManifests)")
+
+            // Load the package graph.
+            let packageGraph = try workspace.loadPackageGraph(rootInput: rootInput, observabilityScope: observability.topScope)
+            XCTAssertNoDiagnostics(observability.diagnostics)
+
+            // Make sure that the use of plugins doesn't bleed into the use of plugins by tools.
+            let testTargetMappings = try packageGraph.computeTestTargetsForExecutableTargets()
+            for (target, testTargets) in testTargetMappings {
+                XCTAssertFalse(testTargets.contains{ $0.name == "MySourceGenPluginTests" }, "target: \(target), testTargets: \(testTargets)")
+            }
+        }
+    }
+
     func testCommandPluginCancellation() throws {
         // 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")