Move code for finding test targets into PackageGraph

Sources/PackageGraph/PackageGraph.swift

@@ -101,4 +101,36 @@ public struct PackageGraph {
         self.reachableTargets = reachableTargets
         self.reachableProducts = reachableProducts
     }
+
+    /// Computes a map from each executable target in any of the root packages to the corresponding test targets.
+    public func computeTestTargetsForExecutableTargets() -> [ResolvedTarget: [ResolvedTarget]] {
+        var result = [ResolvedTarget: [ResolvedTarget]]()
+
+        let rootTargets = rootPackages.map({ $0.targets }).flatMap({ $0 })
+
+        // Create map of test target to set of its direct dependencies.
+        let testTargetDepMap: [ResolvedTarget: Set<ResolvedTarget>] = {
+            let testTargetDeps = rootTargets.filter({ $0.type == .test }).map({
+                ($0, Set($0.dependencies.compactMap({ $0.target })))
+            })
+            return Dictionary(uniqueKeysWithValues: testTargetDeps)
+        }()
+
+        for target in rootTargets where target.type == .executable {
+            // Find all dependencies of this target within its package.
+            let dependencies = try! topologicalSort(target.dependencies, successors: {
+                $0.dependencies.compactMap({ $0.target }).map(ResolvedTarget.Dependency.target)
+            }).compactMap({ $0.target })
+
+            // Include the test targets whose dependencies intersect with the
+            // current target's (recursive) dependencies.
+            let testTargets = testTargetDepMap.filter({ (testTarget, deps) in
+                !deps.intersection(dependencies + [target]).isEmpty
+            }).map({ $0.key })
+
+            result[target] = testTargets
+        }
+
+        return result
+    }
 }

Sources/Xcodeproj/SchemesGenerator.swift

@@ -63,31 +63,16 @@ final class SchemesGenerator {
 
         var schemes: [Scheme] = []
 
-        // Create map of test target to set of its direct dependencies.
-        let testTargetDepMap: [ResolvedTarget: Set<ResolvedTarget>] = {
-            let testTargetDeps = rootPackage.targets.filter({ $0.type == .test }).map({
-                ($0, Set($0.dependencies.compactMap({ $0.target })))
-            })
-            return Dictionary(uniqueKeysWithValues: testTargetDeps)
-        }()
+        let testTargetsMap = graph.computeTestTargetsForExecutableTargets()
 
         // Create one scheme per executable target.
         for target in rootPackage.targets where target.type == .executable {
-            // Find all dependencies of this target within its package.
-            let dependencies = try! topologicalSort(target.dependencies, successors: { 
-                $0.dependencies.compactMap({ $0.target }).map(ResolvedTarget.Dependency.target)
-            }).compactMap({ $0.target })
-
-            // Include the test targets whose dependencies intersect with the
-            // current target's (recursive) dependencies.
-            let testTargets = testTargetDepMap.filter({ (testTarget, deps) in
-                !deps.intersection(dependencies + [target]).isEmpty
-            }).map({ $0.key })
+            let testTargets = testTargetsMap[target]
 
             schemes.append(Scheme(
                 name: target.name,
                 regularTargets: [target],
-                testTargets: testTargets
+                testTargets: testTargets ?? []
             ))
         }