Update index tests to use common build request

bnbarham · bnbarham · commit fbad6548d795 · 2025-02-11T21:08:25.000-08:00
Setting up the build request for the index arena description was spread
across three separate testing helpers and:
  1. Used macOS as the run destination
  2. Added all targets from the given workspace

Update these to use a common request that is more similar to the
workspace build description by default (ie. no run destination +
skipping package targets).

Resolves rdar://142699583.
diff --git a/Sources/SWBTestSupport/BuildOperationTester.swift b/Sources/SWBTestSupport/BuildOperationTester.swift
@@ -1541,29 +1541,78 @@ package final class BuildOperationTester {
         try await checkBuild(name, parameters: parameters, runDestination: runDestination, buildRequest: inputBuildRequest, buildCommand: buildCommand, schemeCommand: schemeCommand, persistent: persistent, serial: serial, buildOutputMap: buildOutputMap, signableTargets: signableTargets, signableTargetInputs: signableTargetInputs, clientDelegate: clientDelegate, sourceLocation: sourceLocation, body: body)
     }
 
+    package static func buildRequestForIndexOperation(
+        workspace: Workspace,
+        buildTargets: [any TestTarget]? = nil,
+        prepareTargets: [String]? = nil,
+        workspaceOperation: Bool? = nil,
+        runDestination: RunDestinationInfo? = nil,
+        sourceLocation: SourceLocation = #_sourceLocation
+    ) throws -> BuildRequest {
+        let workspaceOperation = workspaceOperation ?? (buildTargets == nil)
+
+        // If this is an operation on the entire workspace (rather than for a specific target/package), then
+        // we will end up configuring for all platforms - do not pass a run destination. Use the provided (or a
+        // reasonable default) otherwise.
+        let buildDestination: RunDestinationInfo?
+        if workspaceOperation {
+            buildDestination = nil
+        } else {
+            buildDestination = runDestination ?? RunDestinationInfo.macOS
+        }
+
+        let arena = ArenaInfo.indexBuildArena(derivedDataRoot: workspace.path.dirname)
+        let overrides: [String: String] = ["ONLY_ACTIVE_ARCH": "YES", "ALWAYS_SEARCH_USER_PATHS": "NO"]
+        let buildRequestParameters = BuildParameters(action: .indexBuild, configuration: "Debug", activeRunDestination: buildDestination, overrides: overrides, arena: arena)
+
+        let buildRequestTargets: [BuildRequest.BuildTargetInfo]
+        if let buildTargets {
+            buildRequestTargets = try buildTargets.map { BuildRequest.BuildTargetInfo(parameters: buildRequestParameters, target: try #require(workspace.target(for: $0.guid), sourceLocation: sourceLocation)) }
+        } else {
+            buildRequestTargets = workspace.projects.flatMap { project in
+                // The workspace description excludes packages so that we don't end up configuring every target for every
+                // platform.
+                if workspaceOperation && project.isPackage {
+                    return [BuildRequest.BuildTargetInfo]()
+                }
+                return project.targets.compactMap { target in
+                    if target.type == .aggregate {
+                        return nil
+                    }
+                    return BuildRequest.BuildTargetInfo(parameters: buildRequestParameters, target: target)
+                }
+            }
+        }
+
+        let targetsToPrepare = try prepareTargets?.map { try #require(workspace.target(for: $0)) }
+        return BuildRequest(parameters: buildRequestParameters, buildTargets: buildRequestTargets, dependencyScope: .workspace, continueBuildingAfterErrors: true, useParallelTargets: true, useImplicitDependencies: true, useDryRun: false, buildCommand: .prepareForIndexing(buildOnlyTheseTargets: targetsToPrepare, enableIndexBuildArena: true))
+
+    }
+
     /// Construct 'prepare' index build operation, and test the result.
-    package func checkIndexBuild(
+    package func checkIndexBuild<T>(
         prepareTargets: [String],
-        derivedDataRoot: Path? = nil,
+        workspaceOperation: Bool = true,
         runDestination: RunDestinationInfo? = nil,
         persistent: Bool = false,
         sourceLocation: SourceLocation = #_sourceLocation,
-        body: (BuildResults) throws -> Void
-    ) async throws {
-        let arena = ArenaInfo.indexBuildArena(derivedDataRoot: derivedDataRoot ?? workspace.path.dirname)
-        let overrides: [String: String] = ["ONLY_ACTIVE_ARCH": "YES", "ALWAYS_SEARCH_USER_PATHS": "NO"]
-        let targetsToPrepare = prepareTargets.map{ workspace.target(for: $0)! }
-        // Using 'macOS' as default run-destination; run-destination does not matter for an index build description since it configures targets for all supported platforms.
-        let parameters = BuildParameters(action: .indexBuild, configuration: "Debug", activeRunDestination: .macOS, overrides: overrides, arena: arena)
-        let buildTargets = workspace.allTargets.compactMap{ $0.type == .aggregate ? nil : BuildRequest.BuildTargetInfo(parameters: parameters, target: $0) }
-        let buildRequest = BuildRequest(parameters: parameters, buildTargets: buildTargets, dependencyScope: .workspace, continueBuildingAfterErrors: true, useParallelTargets: true, useImplicitDependencies: true, useDryRun: false, buildCommand: .prepareForIndexing(buildOnlyTheseTargets: targetsToPrepare, enableIndexBuildArena: true))
-
-        // Use the provided run-destination for the build operation.
+        body: (BuildResults) throws -> T
+    ) async throws -> T {
+        let buildRequest = try Self.buildRequestForIndexOperation(
+            workspace: workspace,
+            prepareTargets: prepareTargets,
+            workspaceOperation: workspaceOperation,
+            runDestination: runDestination,
+            sourceLocation: sourceLocation
+        )
+
+        // The build request may have no run destination (for a workspace description), but we always build for a
+        // specific target.
         let runDestination = runDestination ?? RunDestinationInfo.macOS
-        let operationParameters = parameters.replacing(activeRunDestination: runDestination, activeArchitecture: nil)
+        let operationParameters = buildRequest.parameters.replacing(activeRunDestination: runDestination, activeArchitecture: nil)
         let operationBuildRequest = buildRequest.with(parameters: operationParameters, buildTargets: [])
 
-        try await checkBuild(buildRequest: buildRequest, operationBuildRequest: operationBuildRequest, persistent: persistent, sourceLocation: sourceLocation, body: body, performBuild: { await $0.buildWithTimeout() })
+        return try await checkBuild(buildRequest: buildRequest, operationBuildRequest: operationBuildRequest, persistent: persistent, sourceLocation: sourceLocation, body: body, performBuild: { await $0.buildWithTimeout() })
     }
 
     package struct BuildGraphResult: Sendable {
@@ -1631,15 +1680,23 @@ package final class BuildOperationTester {
     }
 
     package func checkIndexBuildGraph(
-        targets: [any TestTarget], activeRunDestination: RunDestinationInfo = .macOS,
+        targets: [any TestTarget]? = nil,
+        workspaceOperation: Bool? = nil,
+        activeRunDestination: RunDestinationInfo? = nil,
         graphTypes: [TargetGraphFactory.GraphType] = [.dependency],
         sourceLocation: SourceLocation = #_sourceLocation,
         body: (BuildGraphResult) throws -> Void
     ) async throws {
-        // `activeRunDestination` only matters for packages, so a default of `.macOS` is fine everywhere else
-        let buildParameters = BuildParameters(action: .indexBuild, configuration: "Debug", activeRunDestination: activeRunDestination)
-        let buildTargets = try targets.map { BuildRequest.BuildTargetInfo(parameters: buildParameters, target: try #require(self.workspace.target(for: $0.guid), sourceLocation: sourceLocation)) }
-        let buildRequest = BuildRequest(parameters: buildParameters, buildTargets: buildTargets, dependencyScope: .workspace, continueBuildingAfterErrors: true, useParallelTargets: true, useImplicitDependencies: true, useDryRun: false, buildCommand: .prepareForIndexing(buildOnlyTheseTargets: nil, enableIndexBuildArena: true))
+        let workspaceOperation = workspaceOperation ?? (targets == nil)
+
+        let buildRequest = try Self.buildRequestForIndexOperation(
+            workspace: workspace,
+            buildTargets: targets,
+            workspaceOperation: workspaceOperation,
+            runDestination: activeRunDestination,
+            sourceLocation: sourceLocation
+        )
+
         let buildRequestContext = BuildRequestContext(workspaceContext: workspaceContext)
         let delegate = EmptyTargetDependencyResolverDelegate(workspace: workspaceContext.workspace)
 
diff --git a/Sources/SWBTestSupport/TaskConstructionTester.swift b/Sources/SWBTestSupport/TaskConstructionTester.swift
@@ -989,39 +989,23 @@ extension TaskConstructionTester: Sendable { }
 extension TaskConstructionTester.PlanningResults: Sendable { }
 
 extension TaskConstructionTester {
-    package func buildParametersForIndexOperation(
-        runDestination: RunDestinationInfo? = nil,
-        arena: ArenaInfo? = nil
-    ) -> BuildParameters {
-        let arena = arena ?? ArenaInfo.indexBuildArena(derivedDataRoot: workspace.path.dirname.join("DerivedData"))
-        let overrides: [String: String] = ["ONLY_ACTIVE_ARCH": "YES", "ALWAYS_SEARCH_USER_PATHS": "NO"]
-        let runDestination = runDestination ?? RunDestinationInfo.macOS
-        let buildParameters = BuildParameters(action: .indexBuild, configuration: "Debug", activeRunDestination: runDestination, overrides: overrides, arena: arena)
-        return buildParameters
-    }
-
     /// Construct the tasks for an index build operation, and test the result.
     package func checkIndexBuild(
         targets: [any TestTarget]? = nil,
+        workspaceOperation: Bool? = nil,
         runDestination: RunDestinationInfo? = nil,
-        arena: ArenaInfo? = nil,
         systemInfo: SystemInfo? = nil,
         sourceLocation: SourceLocation = #_sourceLocation,
         body: (PlanningResults) throws -> Void
     ) async throws {
-        let buildParameters = buildParametersForIndexOperation(
-            runDestination: runDestination
+        let workspaceOperation = workspaceOperation ?? (targets == nil)
+        let buildRequest = try BuildOperationTester.buildRequestForIndexOperation(
+            workspace: workspace,
+            buildTargets: targets,
+            workspaceOperation: workspaceOperation,
+            runDestination: runDestination,
+            sourceLocation: sourceLocation
         )
-
-        let buildTargets: [BuildRequest.BuildTargetInfo]
-        if let targets {
-            buildTargets = try targets.map { BuildRequest.BuildTargetInfo(parameters: buildParameters, target: try #require(self.workspace.target(for: $0.guid), sourceLocation: sourceLocation)) }
-        } else {
-            buildTargets = workspace.allTargets.compactMap{ $0.type == .aggregate ? nil : BuildRequest.BuildTargetInfo(parameters: buildParameters, target: $0) }
-        }
-
-        let buildRequest = BuildRequest(parameters: buildParameters, buildTargets: buildTargets, dependencyScope: .workspace, continueBuildingAfterErrors: true, useParallelTargets: true, useImplicitDependencies: true, useDryRun: false, buildCommand: .prepareForIndexing(buildOnlyTheseTargets: nil, enableIndexBuildArena: true))
-
         return try await checkBuild(buildRequest: buildRequest, systemInfo: systemInfo, sourceLocation: sourceLocation, body: body)
     }
 }
diff --git a/Tests/SWBBuildSystemTests/HostBuildToolBuildOperationTests.swift b/Tests/SWBBuildSystemTests/HostBuildToolBuildOperationTests.swift
@@ -726,12 +726,14 @@ fileprivate struct HostBuildToolBuildOperationTests: CoreBasedTests {
                 """
             }
 
-            try await tester.checkIndexBuild(prepareTargets: testProject.targets.map(\.guid), runDestination: .host, persistent: true) { results in
+            try await tester.checkIndexBuild(prepareTargets: tester.workspace.targets(named: "Framework").map(\.guid), runDestination: .host, persistent: true) { results in
                 results.checkNoDiagnostics()
 
                 // The tool itself should compile and link.
                 results.checkTaskExists(.matchTargetName("Tool"), .matchRuleType("SwiftDriver Compilation"))
-                results.checkTask(.matchTargetName("Tool"), .matchRuleType("Ld")) { _ in }
+                results.checkTask(.matchTargetName("Tool"), .matchRuleType("Ld")) { task in
+                    task.checkCommandLineMatches(["-target", .contains("-apple-macos")])
+                }
 
                 try results.checkTask(.matchTargetName("Framework"), .matchRuleType(ProductPlan.preparedForIndexPreCompilationRuleName)) { task in
                     try results.checkTaskFollows(task, .matchTargetName("Tool"), .matchRuleType("Ld"))
@@ -809,12 +811,14 @@ fileprivate struct HostBuildToolBuildOperationTests: CoreBasedTests {
                 """
             }
 
-            try await tester.checkIndexBuild(prepareTargets: testProject.targets.map(\.guid), runDestination: .host, persistent: true) { results in
+            try await tester.checkIndexBuild(prepareTargets: tester.workspace.targets(named: "Framework").map(\.guid), runDestination: .host, persistent: true) { results in
                 results.checkNoDiagnostics()
 
                 // The tool itself should compile and link.
                 results.checkTaskExists(.matchTargetName("Tool"), .matchRuleType("SwiftDriver Compilation"))
-                results.checkTask(.matchTargetName("Tool"), .matchRuleType("Ld")) { _ in }
+                results.checkTask(.matchTargetName("Tool"), .matchRuleType("Ld")) { task in
+                    task.checkCommandLineMatches(["-target", .contains("-apple-macos")])
+                }
 
                 try results.checkTask(.matchTargetName("Framework"), .matchRuleType(ProductPlan.preparedForIndexPreCompilationRuleName)) { task in
                     try results.checkTaskFollows(task, .matchTargetName("Tool"), .matchRuleType("Ld"))
diff --git a/Tests/SWBBuildSystemTests/IndexBuildOperationTests.swift b/Tests/SWBBuildSystemTests/IndexBuildOperationTests.swift
@@ -1678,10 +1678,10 @@ fileprivate struct IndexBuildOperationTests: CoreBasedTests {
 
             try await tester.fs.writeFileContents(SRCROOT.join("test.swift")) { $0 <<< "// test.swift" }
 
-            let arena = ArenaInfo.indexBuildArena(derivedDataRoot: tester.workspace.path.dirname)
-
-            try await tester.checkIndexBuild(prepareTargets: [app.guid], persistent: true) { results in
+            let arena = try await tester.checkIndexBuild(prepareTargets: [app.guid], persistent: true) { results in
+                let arena = try #require(results.buildRequest.parameters.arena)
                 #expect(tester.fs.exists(arena.buildProductsPath))
+                return arena
             }
 
             let buildRequest = BuildRequest(parameters: BuildParameters(action: .indexBuild, configuration: nil, arena: arena), buildTargets: [], continueBuildingAfterErrors: true, useParallelTargets: true, useImplicitDependencies: true, useDryRun: false, buildCommand: .cleanBuildFolder(style: .regular))
diff --git a/Tests/SWBTaskConstructionTests/IndexBuildTaskConstructionTests.swift b/Tests/SWBTaskConstructionTests/IndexBuildTaskConstructionTests.swift
@@ -145,7 +145,7 @@ fileprivate struct IndexBuildTaskConstructionTests: CoreBasedTests {
     }
 
     @Test(.requireSDKs(.macOS, .iOS))
-    func vFSAndHeaderMapContents() async throws {
+    func vfsAndHeaderMapContents() async throws {
 
         let fwkTarget1 = TestStandardTarget(
             "FrameworkTarget1",
@@ -1309,7 +1309,7 @@ fileprivate struct IndexBuildTaskConstructionTests: CoreBasedTests {
             ])
         let tester = try await TaskConstructionTester(getCore(), testProject)
 
-        try await tester.checkIndexBuild { results in
+        try await tester.checkIndexBuild(workspaceOperation: false) { results in
             results.checkNoDiagnostics()
             results.checkTarget("tool") { target in
                 results.checkWriteAuxiliaryFileTask(.matchTarget(target), .matchRuleType("WriteAuxiliaryFile"), .matchRuleItemBasename("resource_bundle_accessor.swift")) { task, contents in
