[6.2][BuildPlan] Fix traverseModules to account for tests with direct ma… (swiftlang#8943)

…cro dependencies

- Explanation:

This change aligns `traverseModules` with `computeDestinations` in
regard to test targets that have direct macro dependencies: if at least
one test target directly depends on a macro, all of the tests are built
for the "host".

- Resolves: swiftlang/sourcekit-lsp#2205 
- Resolves: rdar://155814321 

- Main Branch PR:
swiftlang#8940

- Risk: Low. This functionality is only used by sourcekit-lsp at the
moment and shouldn't have any impact on swiftpm operation.
 
- Reviewed By: -

- Testing: Added new test-cases to the suite.

(cherry picked from commit a3e78e2)

Author: xedin

Sources/Build/BuildPlan/BuildPlan.swift

@@ -1120,13 +1120,40 @@ extension BuildPlan {
             guard visited.insert(.package(package)).inserted else {
                 return []
             }
-            return package.modules.compactMap {
-                if case .test = $0.underlying.type,
-                   !self.graph.rootPackages.contains(id: package.id)
+
+            var successors: [TraversalNode] = []
+            for product in package.products {
+                if case .test = product.underlying.type,
+                   !graph.rootPackages.contains(id: package.id)
                 {
-                    return nil
+                    continue
                 }
-                return .init(module: $0, context: .target)
+
+                successors.append(.init(product: product, context: .target))
+            }
+
+            for module in package.modules {
+                // Tests are discovered through an aggregate product which also
+                // informs their destination.
+                if case .test = module.type {
+                    continue
+                }
+                successors.append(.init(module: module, context: .target))
+            }
+
+            return successors
+        }
+
+        func successors(
+            for product: ResolvedProduct,
+            destination: Destination
+        ) -> [TraversalNode] {
+            guard destination == .host || product.underlying.type == .test else {
+                return []
+            }
+
+            return product.modules.map { module in
+                TraversalNode(module: module, context: destination)
             }
         }
 
@@ -1156,8 +1183,8 @@ extension BuildPlan {
                 successors(for: package)
             case .module(let module, let destination):
                 successors(for: module, destination: destination)
-            case .product:
-                []
+            case .product(let product, let destination):
+                successors(for: product, destination: destination)
             }
         } onNext: { current, parent in
             let parentModule: (ResolvedModule, BuildParameters.Destination)? = switch parent {

Tests/BuildTests/BuildPlanTraversalTests.swift

@@ -123,6 +123,43 @@ struct BuildPlanTraversalTests {
         #expect(self.getParents(in: results, for: "HAL", destination: .host) == [])
     }
 
+    @Test
+    func traversalWithTestThatDependsOnMacro() async throws {
+        let destinationTriple = Triple.arm64Linux
+        let toolsTriple = Triple.x86_64MacOS
+
+        let (graph, fs, scope) = try macrosTestsPackageGraph()
+        let plan = try await BuildPlan(
+            destinationBuildParameters: mockBuildParameters(
+                destination: .target,
+                triple: destinationTriple
+            ),
+            toolsBuildParameters: mockBuildParameters(
+                destination: .host,
+                triple: toolsTriple
+            ),
+            graph: graph,
+            fileSystem: fs,
+            observabilityScope: scope
+        )
+
+        // Tests that if one of the test targets directly depends
+        // on a macro - all tests are built for the "host".
+        var results: [Result] = []
+        plan.traverseModules {
+            results.append(Result(parent: $1, module: $0))
+        }
+
+        let package = try #require(graph.package(for: "swift-mmio"))
+
+        // Tests that if one of the test targets directly depends
+        // on a macro - all tests are built for the "host".
+        for module in package.modules where module.type == .test {
+            let results = getResults(for: module.name, in: results)
+            #expect(results.allSatisfy { $0.module.1 == .host })
+        }
+    }
+
     @Test
     func recursiveDependencyTraversal() async throws {
         let destinationTriple = Triple.arm64Linux