[BuildDescription] Add a way to get (recursive) dependencies from a module build description

BuildPlan adjacent things should use this instead of reaching for
a module graph and lookup up descriptions.

Author: xedin

Sources/Build/BuildDescription/ClangModuleBuildDescription.swift

@@ -526,3 +526,17 @@ public final class ClangModuleBuildDescription {
         )
     }
 }
+
+extension ClangModuleBuildDescription {
+    package func dependencies(
+        using plan: BuildPlan
+    ) -> [ModuleBuildDescription.Dependency] {
+        ModuleBuildDescription.clang(self).dependencies(using: plan)
+    }
+
+    package func recursiveDependencies(
+        using plan: BuildPlan
+    ) -> [ModuleBuildDescription.Dependency] {
+        ModuleBuildDescription.clang(self).recursiveDependencies(using: plan)
+    }
+}

Sources/Build/BuildDescription/ModuleBuildDescription.swift

@@ -13,6 +13,7 @@
 import Basics
 import struct PackageGraph.ResolvedModule
 import struct PackageGraph.ResolvedPackage
+import struct PackageGraph.ResolvedProduct
 import struct PackageModel.Resource
 import struct PackageModel.ToolsVersion
 import struct SPMBuildCore.BuildToolPluginInvocationResult
@@ -158,4 +159,37 @@ extension ModuleBuildDescription: Identifiable {
     public var id: ID {
         ID(moduleID: self.module.id, destination: self.destination)
     }
-}
+}
+
+extension ModuleBuildDescription {
+    package enum Dependency {
+        /// Not all of the modules and products have build descriptions
+        case product(ResolvedProduct, ProductBuildDescription?)
+        case module(ResolvedModule, ModuleBuildDescription?)
+    }
+
+    package func dependencies(using plan: BuildPlan) -> [Dependency] {
+        self.module
+            .dependencies(satisfying: self.buildParameters.buildEnvironment)
+            .map {
+                switch $0 {
+                case .product(let product, _):
+                    let productDescription = plan.description(for: product, context: self.destination)
+                    return .product(product, productDescription)
+                case .module(let module, _):
+                    let moduleDescription = plan.description(for: module, context: self.destination)
+                    return .module(module, moduleDescription)
+                }
+            }
+    }
+
+    package func recursiveDependencies(using plan: BuildPlan) -> [Dependency] {
+        var dependencies: [Dependency] = []
+        plan.traverseDependencies(of: self) { product, _, description in
+            dependencies.append(.product(product, description))
+        } onModule: { module, _, description in
+            dependencies.append(.module(module, description))
+        }
+        return dependencies
+    }
+}

Sources/Build/BuildDescription/SwiftModuleBuildDescription.swift

@@ -988,3 +988,17 @@ public final class SwiftModuleBuildDescription {
         return arguments
     }
 }
+
+extension SwiftModuleBuildDescription {
+    package func dependencies(
+        using plan: BuildPlan
+    ) -> [ModuleBuildDescription.Dependency] {
+        ModuleBuildDescription.swift(self).dependencies(using: plan)
+    }
+
+    package func recursiveDependencies(
+        using plan: BuildPlan
+    ) -> [ModuleBuildDescription.Dependency] {
+        ModuleBuildDescription.swift(self).recursiveDependencies(using: plan)
+    }
+}

Sources/Build/BuildPlan/BuildPlan.swift

@@ -1137,12 +1137,15 @@ extension BuildPlan {
         onProduct: (ResolvedProduct, BuildParameters.Destination, ProductBuildDescription?) -> Void,
         onModule: (ResolvedModule, BuildParameters.Destination, ModuleBuildDescription?) -> Void
     ) {
+        var visited = Set<TraversalNode>()
         func successors(
             for product: ResolvedProduct,
             destination: Destination
         ) -> [TraversalNode] {
             product.modules.map { module in
                 TraversalNode(module: module, context: destination)
+            }.filter {
+                visited.insert($0).inserted
             }
         }
 
@@ -1159,6 +1162,8 @@ extension BuildPlan {
                     case .module(let module, _):
                         partial.append(.init(module: module, context: destination))
                     }
+                }.filter {
+                    visited.insert($0).inserted
                 }
         }
 

Sources/SPMBuildCore/BuildParameters/BuildParameters.swift

@@ -38,7 +38,7 @@ public struct BuildParameters: Encodable {
     }
 
     /// The destination for which code should be compiled for.
-    public enum Destination: Encodable {
+    public enum Destination: Hashable, Encodable {
         /// The destination for which build tools are compiled.
         case host
 

Tests/BuildTests/BuildPlanTraversalTests.swift

@@ -185,5 +185,86 @@ final class BuildPlanTraversalTests: XCTestCase {
             XCTAssertEqual(moduleDependencies[index].1, .host)
             XCTAssertNotNil(moduleDependencies[index].2)
         }
+
+        let directDependencies = mmioModule.dependencies(using: plan)
+
+        XCTAssertEqual(directDependencies.count, 1)
+
+        let dependency = try XCTUnwrap(directDependencies.first)
+        if case .module(let module, let description) = dependency {
+            XCTAssertEqual(module.name, "MMIOMacros")
+            try XCTAssertEqual(XCTUnwrap(description).destination, .host)
+        } else {
+            XCTFail("Expected MMIOMacros module")
+        }
+
+        let dependencies = mmioModule.recursiveDependencies(using: plan)
+
+        XCTAssertEqual(dependencies.count, 3)
+
+        // MMIOMacros (module) -> SwiftSyntax (product) -> SwiftSyntax (module)
+
+        if case .module(let module, let description) = dependencies[0] {
+            XCTAssertEqual(module.name, "MMIOMacros")
+            try XCTAssertEqual(XCTUnwrap(description).destination, .host)
+        } else {
+            XCTFail("Expected MMIOMacros module")
+        }
+
+        if case .product(let product, let description) = dependencies[1] {
+            XCTAssertEqual(product.name, "SwiftSyntax")
+            XCTAssertNil(description)
+        } else {
+            XCTFail("Expected SwiftSyntax product")
+        }
+
+        if case .module(let module, let description) = dependencies[2] {
+            XCTAssertEqual(module.name, "SwiftSyntax")
+            try XCTAssertEqual(XCTUnwrap(description).destination, .host)
+        } else {
+            XCTFail("Expected SwiftSyntax module")
+        }
+    }
+
+    func testRecursiveDependencyTraversalWithDuplicates() 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
+        )
+
+        let testModule = try XCTUnwrap(plan.description(for: graph.module(for: "MMIOMacrosTests")!, context: .host))
+
+        let dependencies = testModule.recursiveDependencies(using: plan)
+        XCTAssertEqual(dependencies.count, 9)
+
+        struct ModuleResult: Hashable {
+            let module: ResolvedModule
+            let destination: Dest
+        }
+
+        var uniqueModules = Set<ModuleResult>()
+        for dependency in dependencies {
+            if case .module(let module, let description) = dependency {
+                XCTAssertNotNil(description)
+                XCTAssertEqual(description!.destination, .host)
+                XCTAssertTrue(
+                    uniqueModules.insert(.init(module: module, destination: description!.destination))
+                        .inserted
+                )
+            }
+        }
     }
 }