Un-Revert "[Build] Free BuildPlan from BuildTriple"

Sources/Basics/Collections/IdentifiableSet.swift

@@ -42,6 +42,10 @@ public struct IdentifiableSet<Element: Identifiable>: Collection {
         Index(storageIndex: self.storage.elements.endIndex)
     }
 
+    public var values: some Sequence<Element> {
+        self.storage.values
+    }
+
     public subscript(position: Index) -> Element {
         self.storage.elements[position.storageIndex].value
     }

Sources/Build/BuildDescription/ClangModuleBuildDescription.swift

@@ -42,6 +42,11 @@ public final class ClangModuleBuildDescription {
     /// The build parameters.
     let buildParameters: BuildParameters
 
+    /// The destination for while this module is built.
+    public var destination: BuildParameters.Destination {
+        self.buildParameters.destination
+    }
+
     /// The build environment.
     var buildEnvironment: BuildEnvironment {
         buildParameters.buildEnvironment
@@ -521,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
@@ -121,6 +122,15 @@ public enum ModuleBuildDescription: SPMBuildCore.ModuleBuildDescription {
         }
     }
 
+    var destination: BuildParameters.Destination {
+        switch self {
+        case .swift(let buildDescription):
+            buildDescription.destination
+        case .clang(let buildDescription):
+            buildDescription.destination
+        }
+    }
+
     var toolsVersion: ToolsVersion {
         switch self {
         case .swift(let buildDescription):
@@ -139,3 +149,47 @@ public enum ModuleBuildDescription: SPMBuildCore.ModuleBuildDescription {
         }
     }
 }
+
+extension ModuleBuildDescription: Identifiable {
+    public struct ID: Hashable {
+        let moduleID: ResolvedModule.ID
+        let destination: BuildParameters.Destination
+    }
+
+    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/ProductBuildDescription.swift

@@ -37,6 +37,11 @@ public final class ProductBuildDescription: SPMBuildCore.ProductBuildDescription
     /// The build parameters.
     public let buildParameters: BuildParameters
 
+    /// The destination for while this product is built.
+    public var destination: BuildParameters.Destination {
+        self.buildParameters.destination
+    }
+
     /// All object files to link into this product.
     ///
     // Computed during build planning.
@@ -397,6 +402,17 @@ public final class ProductBuildDescription: SPMBuildCore.ProductBuildDescription
     }
 }
 
+extension ProductBuildDescription: Identifiable {
+    public struct ID: Hashable {
+        let productID: ResolvedProduct.ID
+        let destination: BuildParameters.Destination
+    }
+
+    public var id: ID {
+        ID(productID: self.product.id, destination: self.destination)
+    }
+}
+
 extension SortedArray where Element == AbsolutePath {
     public static func +=<S: Sequence>(lhs: inout SortedArray, rhs: S) where S.Iterator.Element == AbsolutePath {
         lhs.insert(contentsOf: rhs)

Sources/Build/BuildDescription/SwiftModuleBuildDescription.swift

@@ -49,6 +49,11 @@ public final class SwiftModuleBuildDescription {
     /// The build parameters for this target.
     let buildParameters: BuildParameters
 
+    /// The destination for while this module is built.
+    public var destination: BuildParameters.Destination {
+        self.buildParameters.destination
+    }
+
     /// The build parameters for the macro dependencies of this target.
     let macroBuildParameters: BuildParameters
 
@@ -983,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/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