[Build] NFC: Start using ModuleBuildDescription.{recursive}Dependencies

Author: xedin

Sources/Build/BuildManifest/LLBuildManifestBuilder+Clang.swift

@@ -32,30 +32,36 @@ extension LLBuildManifestBuilder {
             inputs.append(resourcesNode)
         }
 
-        func addStaticTargetInputs(_ target: ResolvedModule) {
-            if case .swift(let desc)? = self.plan.targetMap[target.id], target.type == .library {
+        func addStaticTargetInputs(_ description: ModuleBuildDescription?) {
+            if case .swift(let desc) = description, desc.target.type == .library {
                 inputs.append(file: desc.moduleOutputPath)
             }
         }
 
-        for dependency in target.target.dependencies(satisfying: target.buildEnvironment) {
+        for dependency in target.dependencies(using: self.plan) {
             switch dependency {
-            case .module(let target, _):
-                addStaticTargetInputs(target)
+            case .module(_, let description):
+                addStaticTargetInputs(description)
 
-            case .product(let product, _):
+            case .product(let product, let productDescription):
                 switch product.type {
                 case .executable, .snippet, .library(.dynamic), .macro:
-                    guard let planProduct = plan.productMap[product.id] else {
-                        throw InternalError("unknown product \(product)")
+                    guard let productDescription else {
+                        throw InternalError("No build description for product: \(product)")
                     }
                     // Establish a dependency on binary of the product.
-                    let binary = try planProduct.binaryPath
-                    inputs.append(file: binary)
+                    try inputs.append(file: productDescription.binaryPath)
 
                 case .library(.automatic), .library(.static), .plugin:
-                    for target in product.modules {
-                        addStaticTargetInputs(target)
+                    for module in product.modules {
+                        guard let dependencyDescription = self.plan.description(
+                            for: module,
+                            context: product.type == .plugin ? .host : target.destination
+                        ) else
+                        {
+                            throw InternalError("unknown module: \(module)")
+                        }
+                        addStaticTargetInputs(dependencyDescription)
                     }
                 case .test:
                     break

Sources/Build/BuildManifest/LLBuildManifestBuilder+Swift.swift

@@ -191,10 +191,8 @@ extension LLBuildManifestBuilder {
     public func addTargetsToExplicitBuildManifest() throws {
         // Sort the product targets in topological order in order to collect and "bubble up"
         // their respective dependency graphs to the depending targets.
-        let nodes = self.plan.targets.compactMap {
-            ResolvedModule.Dependency.module($0.module, conditions: [])
-        }
-        let allPackageDependencies = try topologicalSort(nodes, successors: { $0.dependencies })
+        let allPackageDependencies = self.plan.targets.flatMap { $0.recursiveDependencies(using: self.plan) }
+
         // Instantiate the inter-module dependency oracle which will cache commonly-scanned
         // modules across targets' Driver instances.
         let dependencyOracle = InterModuleDependencyOracle()
@@ -206,14 +204,15 @@ extension LLBuildManifestBuilder {
 
         // Create commands for all module descriptions in the plan.
         for dependency in allPackageDependencies.reversed() {
-            guard case .module(let target, _) = dependency else {
+            guard case .module(let module, let description) = dependency else {
                 // Product dependency build jobs are added after the fact.
                 // Targets that depend on product dependencies will expand the corresponding
                 // product into its constituent targets.
                 continue
             }
-            guard target.underlying.type != .systemModule,
-                  target.underlying.type != .binary
+
+            guard module.underlying.type != .systemModule,
+                  module.underlying.type != .binary
             else {
                 // Much like non-Swift targets, system modules will consist of a modulemap
                 // somewhere in the filesystem, with the path to that module being either
@@ -225,9 +224,11 @@ extension LLBuildManifestBuilder {
                 // be able to detect such targets' modules.
                 continue
             }
-            guard let description = plan.targetMap[target.id] else {
-                throw InternalError("Expected description for target \(target)")
+
+            guard let description else {
+                throw InternalError("Expected description for module \(module)")
             }
+
             switch description {
             case .swift(let desc):
                 try self.createExplicitSwiftTargetCompileCommand(
@@ -319,32 +320,29 @@ extension LLBuildManifestBuilder {
         for targetDescription: ModuleBuildDescription,
         dependencyModuleDetailsMap: inout SwiftDriver.ExternalTargetModuleDetailsMap
     ) throws {
-        for dependency in targetDescription.module.dependencies(satisfying: targetDescription.buildParameters.buildEnvironment) {
+        for dependency in targetDescription.dependencies(using: self.plan) {
             switch dependency {
-            case .product:
-                // Product dependencies are broken down into the targets that make them up.
-                guard let dependencyProduct = dependency.product else {
-                    throw InternalError("unknown dependency product for \(dependency)")
-                }
-                for dependencyProductTarget in dependencyProduct.modules {
-                    guard let dependencyTargetDescription = self.plan.targetMap[dependencyProductTarget.id] else {
-                        throw InternalError("unknown dependency target for \(dependencyProductTarget)")
+            case .product(let product, let productDescription):
+                for productDependency in product.modules {
+                    guard let dependencyModuleDescription = self.plan.description(
+                        for: productDependency,
+                        context: productDescription?.destination ?? targetDescription.destination
+                    ) else
+                    {
+                        throw InternalError("unknown dependency target for \(productDependency)")
                     }
                     try self.addTargetDependencyInfo(
-                        for: dependencyTargetDescription,
+                        for: dependencyModuleDescription,
                         dependencyModuleDetailsMap: &dependencyModuleDetailsMap
                     )
                 }
-            case .module:
-                // Product dependencies are broken down into the targets that make them up.
-                guard
-                    let dependencyTarget = dependency.module,
-                    let dependencyTargetDescription = self.plan.targetMap[dependencyTarget.id]
-                else {
-                    throw InternalError("unknown dependency target for \(dependency)")
+            case .module(let dependencyModule, let dependencyDescription):
+                guard let dependencyDescription else {
+                    throw InternalError("No build description for module: \(dependencyModule)")
                 }
+                // Product dependencies are broken down into the targets that make them up.
                 try self.addTargetDependencyInfo(
-                    for: dependencyTargetDescription,
+                    for: dependencyDescription,
                     dependencyModuleDetailsMap: &dependencyModuleDetailsMap
                 )
             }
@@ -422,63 +420,73 @@ extension LLBuildManifestBuilder {
 
         let prepareForIndexing = target.buildParameters.prepareForIndexing
 
-        func addStaticTargetInputs(_ target: ResolvedModule) throws {
+        func addStaticTargetInputs(_ module: ResolvedModule, _ description: ModuleBuildDescription?) throws {
             // Ignore C Modules.
-            if target.underlying is SystemLibraryModule { return }
+            if module.underlying is SystemLibraryModule { return }
             // Ignore Binary Modules.
-            if target.underlying is BinaryModule { return }
+            if module.underlying is BinaryModule { return }
             // Ignore Plugin Modules.
-            if target.underlying is PluginModule { return }
+            if module.underlying is PluginModule { return }
+
+            guard let description else {
+                throw InternalError("No build description for module: \(module)")
+            }
 
             // Depend on the binary for executable targets.
-            if target.type == .executable && prepareForIndexing == .off {
-                // FIXME: Optimize.
+            if module.type == .executable && prepareForIndexing == .off {
+                // FIXME: Optimize. Build plan could build a mapping between executable modules
+                // and their products to speed up search here, which is inefficient if the plan
+                // contains a lot of products.
                 if let productDescription = try plan.productMap.values.first(where: {
-                    try $0.product.type == .executable && $0.product.executableModule.id == target.id
+                    try $0.product.type == .executable &&
+                        $0.product.executableModule.id == module.id &&
+                        $0.destination == description.destination
                 }) {
                     try inputs.append(file: productDescription.binaryPath)
                 }
                 return
             }
 
-            switch self.plan.targetMap[target.id] {
-            case .swift(let target)?:
-                inputs.append(file: target.moduleOutputPath)
-            case .clang(let target)?:
+            switch description {
+            case .swift(let swiftDescription):
+                inputs.append(file: swiftDescription.moduleOutputPath)
+            case .clang(let clangDescription):
                 if prepareForIndexing != .off {
                     // In preparation, we're only building swiftmodules
                     // propagate the dependency to the header files in this target
-                    for header in target.clangTarget.headers {
+                    for header in clangDescription.clangTarget.headers {
                         inputs.append(file: header)
                     }
                 } else {
-                    for object in try target.objects {
+                    for object in try clangDescription.objects {
                         inputs.append(file: object)
                     }
                 }
-            case nil:
-                throw InternalError("unexpected: target \(target) not in target map \(self.plan.targetMap)")
             }
         }
 
-        for dependency in target.target.dependencies(satisfying: target.buildParameters.buildEnvironment) {
+        for dependency in target.dependencies(using: self.plan) {
             switch dependency {
-            case .module(let target, _):
-                try addStaticTargetInputs(target)
+            case .module(let module, let description):
+                try addStaticTargetInputs(module, description)
 
-            case .product(let product, _):
+            case .product(let product, let productDescription):
                 switch product.type {
                 case .executable, .snippet, .library(.dynamic), .macro:
-                    guard let planProduct = plan.productMap[product.id] else {
-                        throw InternalError("unknown product \(product)")
+                    guard let productDescription else {
+                        throw InternalError("No description for product: \(product)")
                     }
                     // Establish a dependency on binary of the product.
-                    try inputs.append(file: planProduct.binaryPath)
+                    try inputs.append(file: productDescription.binaryPath)
 
                 // For automatic and static libraries, and plugins, add their targets as static input.
                 case .library(.automatic), .library(.static), .plugin:
-                    for target in product.modules {
-                        try addStaticTargetInputs(target)
+                    for module in product.modules {
+                        let description = self.plan.description(
+                            for: module,
+                            context: product.type == .plugin ? .host : target.destination
+                        )
+                        try addStaticTargetInputs(module, description)
                     }
 
                 case .test:

Sources/Build/BuildPlan/BuildPlan+Clang.swift

@@ -18,12 +18,12 @@ import class PackageModel.SystemLibraryModule
 extension BuildPlan {
     /// Plan a Clang target.
     func plan(clangTarget: ClangModuleBuildDescription) throws {
-        let dependencies = try clangTarget.target.recursiveDependencies(satisfying: clangTarget.buildEnvironment)
+        let dependencies = clangTarget.recursiveDependencies(using: self)
 
-        for case .module(let dependency, _) in dependencies {
+        for case .module(let dependency, let description) in dependencies {
             switch dependency.underlying {
             case is SwiftModule:
-                if case let .swift(dependencyTargetDescription)? = targetMap[dependency.id] {
+                if case let .swift(dependencyTargetDescription)? = description {
                     if let moduleMap = dependencyTargetDescription.moduleMap {
                         clangTarget.additionalFlags += ["-fmodule-map-file=\(moduleMap.pathString)"]
                     }
@@ -34,7 +34,7 @@ extension BuildPlan {
                 clangTarget.additionalFlags += ["-I", target.includeDir.pathString]
 
                 // Add the modulemap of the dependency if it has one.
-                if case let .clang(dependencyTargetDescription)? = targetMap[dependency.id] {
+                if case let .clang(dependencyTargetDescription)? = description {
                     if let moduleMap = dependencyTargetDescription.moduleMap {
                         clangTarget.additionalFlags += ["-fmodule-map-file=\(moduleMap.pathString)"]
                     }

Sources/Build/BuildPlan/BuildPlan+Swift.swift

@@ -20,11 +20,10 @@ extension BuildPlan {
     func plan(swiftTarget: SwiftModuleBuildDescription) throws {
         // We need to iterate recursive dependencies because Swift compiler needs to see all the targets a target
         // depends on.
-        let environment = swiftTarget.buildParameters.buildEnvironment
-        for case .module(let dependency, _) in try swiftTarget.target.recursiveDependencies(satisfying: environment) {
+        for case .module(let dependency, let description) in swiftTarget.recursiveDependencies(using: self) {
             switch dependency.underlying {
             case let underlyingTarget as ClangModule where underlyingTarget.type == .library:
-                guard case let .clang(target)? = targetMap[dependency.id] else {
+                guard case let .clang(target)? = description else {
                     throw InternalError("unexpected clang target \(underlyingTarget)")
                 }
                 // Add the path to modulemap of the dependency. Currently we require that all Clang targets have a