[Tests] NFC: Add a way to mock BuildPlan construction

Instead of using unified `buildParameters:` let's switch
over to a more fine-grained control over build plan construction
and allow setting common driver, linker and other flags
but handle destinations internally.

Author: xedin

Sources/Build/BuildPlan/BuildPlan.swift

@@ -237,28 +237,6 @@ public class BuildPlan: SPMBuildCore.BuildPlan {
     /// ObservabilityScope with which to emit diagnostics
     let observabilityScope: ObservabilityScope
 
-    @available(*, deprecated, renamed: "init(destinationBuildParameters:toolsBuildParameters:graph:)")
-    public convenience init(
-        buildParameters: BuildParameters,
-        graph: ModulesGraph,
-        additionalFileRules: [FileRuleDescription] = [],
-        buildToolPluginInvocationResults: [ResolvedModule.ID: [BuildToolPluginInvocationResult]] = [:],
-        prebuildCommandResults: [ResolvedModule.ID: [PrebuildCommandResult]] = [:],
-        fileSystem: any FileSystem,
-        observabilityScope: ObservabilityScope
-    ) throws {
-        try self.init(
-            destinationBuildParameters: buildParameters,
-            toolsBuildParameters: buildParameters,
-            graph: graph,
-            additionalFileRules: additionalFileRules,
-            buildToolPluginInvocationResults: buildToolPluginInvocationResults,
-            prebuildCommandResults: prebuildCommandResults,
-            fileSystem: fileSystem,
-            observabilityScope: observabilityScope
-        )
-    }
-
     @available(*, deprecated, renamed: "init(destinationBuildParameters:toolsBuildParameters:graph:fileSystem:observabilityScope:)")
     public convenience init(
         productsBuildParameters: BuildParameters,

Sources/SPMTestSupport/MockBuildTestHelper.swift

@@ -15,6 +15,7 @@ import Basics
 @_spi(SwiftPMInternal)
 import Build
 
+import struct PackageGraph.ModulesGraph
 import struct PackageGraph.ResolvedModule
 import struct PackageGraph.ResolvedProduct
 import PackageModel
@@ -75,6 +76,7 @@ public let defaultTargetTriple: String = hostTriple.tripleString
 #endif
 
 public func mockBuildParameters(
+    destination: BuildParameters.Destination,
     buildPath: AbsolutePath? = nil,
     config: BuildConfiguration = .debug,
     toolchain: PackageModel.Toolchain = MockToolchain(),
@@ -90,6 +92,7 @@ public func mockBuildParameters(
     omitFramePointers: Bool? = nil
 ) -> BuildParameters {
     try! BuildParameters(
+        destination: destination,
         dataPath: buildPath ?? AbsolutePath("/path/to/build").appending(triple.tripleString),
         configuration: config,
         toolchain: toolchain,
@@ -116,7 +119,10 @@ public func mockBuildParameters(
     )
 }
 
-public func mockBuildParameters(environment: BuildEnvironment) -> BuildParameters {
+public func mockBuildParameters(
+    destination: BuildParameters.Destination,
+    environment: BuildEnvironment
+) -> BuildParameters {
     let triple: Basics.Triple
     switch environment.platform {
     case .macOS:
@@ -131,9 +137,121 @@ public func mockBuildParameters(environment: BuildEnvironment) -> BuildParameter
         fatalError("unsupported platform in tests")
     }
 
-    return mockBuildParameters(config: environment.configuration ?? .debug, triple: triple)
+    return mockBuildParameters(
+        destination: destination,
+        config: environment.configuration ?? .debug,
+        triple: triple
+    )
 }
 
+public func mockBuildPlan(
+    buildPath: AbsolutePath? = nil,
+    environment: BuildEnvironment,
+    toolchain: PackageModel.Toolchain = MockToolchain(),
+    graph: ModulesGraph,
+    commonFlags: PackageModel.BuildFlags = .init(),
+    indexStoreMode: BuildParameters.IndexStoreMode = .off,
+    omitFramePointers: Bool? = nil,
+    driverParameters: BuildParameters.Driver = .init(),
+    linkingParameters: BuildParameters.Linking = .init(),
+    targetSanitizers: EnabledSanitizers = .init(),
+    fileSystem fs: any FileSystem,
+    observabilityScope: ObservabilityScope
+) throws -> Build.BuildPlan {
+    try mockBuildPlan(
+        buildPath: buildPath,
+        config: environment.configuration ?? .debug,
+        platform: environment.platform,
+        toolchain: toolchain,
+        graph: graph,
+        commonFlags: commonFlags,
+        indexStoreMode: indexStoreMode,
+        omitFramePointers: omitFramePointers,
+        driverParameters: driverParameters,
+        linkingParameters: linkingParameters,
+        targetSanitizers: targetSanitizers,
+        fileSystem: fs,
+        observabilityScope: observabilityScope
+    )
+}
+
+public func mockBuildPlan(
+    buildPath: AbsolutePath? = nil,
+    config: BuildConfiguration = .debug,
+    triple: Basics.Triple? = nil,
+    platform: PackageModel.Platform? = nil,
+    toolchain: PackageModel.Toolchain = MockToolchain(),
+    graph: ModulesGraph,
+    commonFlags: PackageModel.BuildFlags = .init(),
+    indexStoreMode: BuildParameters.IndexStoreMode = .off,
+    omitFramePointers: Bool? = nil,
+    driverParameters: BuildParameters.Driver = .init(),
+    linkingParameters: BuildParameters.Linking = .init(),
+    targetSanitizers: EnabledSanitizers = .init(),
+    fileSystem fs: any FileSystem,
+    observabilityScope: ObservabilityScope
+) throws -> Build.BuildPlan {
+    let inferredTriple: Basics.Triple
+    if let platform {
+        precondition(triple == nil)
+
+        inferredTriple = switch platform {
+        case .macOS:
+            Triple.x86_64MacOS
+        case .linux:
+            Triple.arm64Linux
+        case .android:
+            Triple.arm64Android
+        case .windows:
+            Triple.windows
+        default:
+            fatalError("unsupported platform in tests")
+        }
+    } else {
+        inferredTriple = triple ?? hostTriple
+    }
+
+    let commonDebuggingParameters = BuildParameters.Debugging(
+        triple: inferredTriple,
+        shouldEnableDebuggingEntitlement: config == .debug,
+        omitFramePointers: omitFramePointers
+    )
+
+    var destinationParameters = mockBuildParameters(
+        destination: .target,
+        buildPath: buildPath,
+        config: config,
+        toolchain: toolchain,
+        flags: commonFlags,
+        triple: inferredTriple,
+        indexStoreMode: indexStoreMode
+    )
+    destinationParameters.debuggingParameters = commonDebuggingParameters
+    destinationParameters.driverParameters = driverParameters
+    destinationParameters.linkingParameters = linkingParameters
+    destinationParameters.sanitizers = targetSanitizers
+
+    var hostParameters = mockBuildParameters(
+        destination: .host,
+        buildPath: buildPath,
+        config: config,
+        toolchain: toolchain,
+        flags: commonFlags,
+        triple: inferredTriple,
+        indexStoreMode: indexStoreMode
+    )
+    hostParameters.debuggingParameters = commonDebuggingParameters
+    hostParameters.driverParameters = driverParameters
+    hostParameters.linkingParameters = linkingParameters
+
+    return try BuildPlan(
+        destinationBuildParameters: destinationParameters,
+        toolsBuildParameters: hostParameters,
+        graph: graph,
+        fileSystem: fs,
+        observabilityScope: observabilityScope
+    )
+}
 enum BuildError: Swift.Error {
     case error(String)
 }

Tests/BuildTests/BuildOperationTests.swift

@@ -54,20 +54,21 @@ final class BuildOperationTests: XCTestCase {
     func testDetectUnexpressedDependencies() throws {
         let scratchDirectory = AbsolutePath("/path/to/build")
         let triple = hostTriple
-        let buildParameters = mockBuildParameters(
+        let targetBuildParameters = mockBuildParameters(
+            destination: .target,
             buildPath: scratchDirectory.appending(triple.tripleString),
             shouldDisableLocalRpath: false,
             triple: triple
         )
 
         let fs = InMemoryFileSystem(files: [
-            "\(buildParameters.dataPath)/debug/Lunch.build/Lunch.d" : "/Best.framework"
+            "\(targetBuildParameters.dataPath)/debug/Lunch.build/Lunch.d" : "/Best.framework"
         ])
 
         let observability = ObservabilitySystem.makeForTesting()
         let buildOp = mockBuildOperation(
-            productsBuildParameters: buildParameters,
-            toolsBuildParameters: buildParameters,
+            productsBuildParameters: targetBuildParameters,
+            toolsBuildParameters: mockBuildParameters(destination: .host, shouldDisableLocalRpath: false),
             scratchDirectory: scratchDirectory,
             fs: fs, observabilityScope: observability.topScope
         )
@@ -120,14 +121,15 @@ final class BuildOperationTests: XCTestCase {
 
             // Perform initial builds for each triple
             for triple in triples {
-                let buildParameters = mockBuildParameters(
+                let targetBuildParameters = mockBuildParameters(
+                    destination: .target,
                     buildPath: scratchDirectory.appending(triple.tripleString),
                     config: .debug,
                     triple: triple
                 )
                 let buildOp = mockBuildOperation(
-                    productsBuildParameters: buildParameters,
-                    toolsBuildParameters: buildParameters,
+                    productsBuildParameters: targetBuildParameters,
+                    toolsBuildParameters: mockBuildParameters(destination: .host),
                     cacheBuildManifest: false,
                     packageGraphLoader: { packageGraph },
                     scratchDirectory: scratchDirectory,
@@ -136,7 +138,7 @@ final class BuildOperationTests: XCTestCase {
                 // Generate initial llbuild manifest
                 let _ = try buildOp.getBuildDescription()
                 // Record the initial llbuild manifest as expected one
-                llbuildManifestByTriple[triple.tripleString] = try fs.readFileContents(buildParameters.llbuildManifest)
+                llbuildManifestByTriple[triple.tripleString] = try fs.readFileContents(targetBuildParameters.llbuildManifest)
             }
 
             XCTAssertTrue(fs.exists(scratchDirectory.appending("debug.yaml")))
@@ -152,14 +154,15 @@ final class BuildOperationTests: XCTestCase {
             // Perform incremental build several times and switch triple for each time
             for _ in 0..<4 {
                 for triple in triples {
-                    let buildParameters = mockBuildParameters(
+                    let targetBuildParameters = mockBuildParameters(
+                        destination: .target,
                         buildPath: scratchDirectory.appending(triple.tripleString),
                         config: .debug,
                         triple: triple
                     )
                     let buildOp = mockBuildOperation(
-                        productsBuildParameters: buildParameters,
-                        toolsBuildParameters: buildParameters,
+                        productsBuildParameters: targetBuildParameters,
+                        toolsBuildParameters: mockBuildParameters(destination: .host),
                         cacheBuildManifest: true,
                         packageGraphLoader: { packageGraph },
                         scratchDirectory: scratchDirectory,
@@ -169,7 +172,7 @@ final class BuildOperationTests: XCTestCase {
                     let _ = try buildOp.getBuildDescription()
 
                     // Ensure that llbuild manifest is updated to the expected one
-                    let actualManifest: String = try fs.readFileContents(buildParameters.llbuildManifest)
+                    let actualManifest: String = try fs.readFileContents(targetBuildParameters.llbuildManifest)
                     let expectedManifest = try XCTUnwrap(llbuildManifestByTriple[triple.tripleString])
                     XCTAssertEqual(actualManifest, expectedManifest)
                 }