Fix prepare for indexing so plugin tools are properly built. (#8230)

Eliminate the special generatePrepareManifest and just reuse the real
one and add a couple of checks for the target/product prepareForIndexing
buildParameter instead. This then enables us to make sure we're doing a
full build of the plugin tools so they can generate code to be properly
indexed.

Addresses #8216 for openapi generator.

Sources/Build/BuildManifest/LLBuildManifestBuilder.swift

@@ -107,54 +107,26 @@ public class LLBuildManifestBuilder {
                 case .swift(let desc):
                     try self.createSwiftCompileCommand(desc)
                 case .clang(let desc):
-                    try self.createClangCompileCommand(desc)
+                    if desc.buildParameters.prepareForIndexing == .off {
+                        try self.createClangCompileCommand(desc)
+                    } else {
+                        // Hook up the clang module target when preparing
+                        try self.createClangPrepareCommand(desc)
+                    }
                 }
             }
         }
 
-        try self.addTestDiscoveryGenerationCommand()
-        try self.addTestEntryPointGenerationCommand()
-
-        // Create command for all products in the plan.
-        for description in self.plan.productMap {
-            try self.createProductCommand(description)
-        }
-
-        try LLBuildManifestWriter.write(self.manifest, at: path, fileSystem: self.fileSystem)
-        return self.manifest
-    }
-
-    package func generatePrepareManifest(at path: AbsolutePath) throws -> LLBuildManifest {
-        self.swiftGetVersionFiles.removeAll()
-
-        self.manifest.createTarget(TargetKind.main.targetName)
-        self.manifest.createTarget(TargetKind.test.targetName)
-        self.manifest.defaultTarget = TargetKind.main.targetName
-
-        addPackageStructureCommand()
-
-        for description in self.plan.targetMap {
-            switch description {
-            case .swift(let desc):
-                try self.createSwiftCompileCommand(desc)
-            case .clang(let desc):
-                if desc.destination == .host {
-                    // Need the clang modules for tools
-                    try self.createClangCompileCommand(desc)
-                } else {
-                    // Hook up the clang module target
-                    try self.createClangPrepareCommand(desc)
-                }
-            }
+        // Skip test discovery if preparing for indexing
+        if self.plan.destinationBuildParameters.prepareForIndexing == .off {
+            try self.addTestDiscoveryGenerationCommand()
+            try self.addTestEntryPointGenerationCommand()
         }
 
+        // Create command for all products in the plan.
         for description in self.plan.productMap {
-            // Need to generate macro products
-            switch description.product.type {
-            case .macro, .plugin:
+            if description.buildParameters.prepareForIndexing == .off {
                 try self.createProductCommand(description)
-            default:
-                break
             }
         }
 
@@ -199,6 +171,9 @@ extension LLBuildManifestBuilder {
         // its source binary.
         var destinations = [AbsolutePath: AbsolutePath]()
         for target in self.plan.targetMap.values {
+            // skip if target is preparing for indexing
+            guard target.buildParameters.prepareForIndexing == .off else { continue }
+
             for binaryPath in target.libraryBinaryPaths {
                 destinations[target.buildParameters.destinationPath(forBinaryAt: binaryPath)] = binaryPath
             }

Sources/Build/BuildOperation.swift

@@ -981,9 +981,7 @@ extension BuildDescription {
             fileSystem: fileSystem,
             observabilityScope: config.observabilityScope
         )
-        let buildManifest = plan.destinationBuildParameters.prepareForIndexing == .off
-            ? try llbuild.generateManifest(at: config.manifestPath)
-            : try llbuild.generatePrepareManifest(at: config.manifestPath)
+        let buildManifest = try llbuild.generateManifest(at: config.manifestPath)
 
         let swiftCommands = llbuild.manifest.getCmdToolMap(kind: SwiftCompilerTool.self)
         let swiftFrontendCommands = llbuild.manifest.getCmdToolMap(kind: SwiftFrontendTool.self)

Tests/BuildTests/PrepareForIndexTests.swift

@@ -37,7 +37,7 @@ class PrepareForIndexTests: XCTestCase {
         )
 
         let builder = LLBuildManifestBuilder(plan, fileSystem: fs, observabilityScope: scope)
-        let manifest = try builder.generatePrepareManifest(at: "/manifest")
+        let manifest = try builder.generateManifest(at: "/manifest")
 
         // Make sure we're building the swift modules
         let outputs = manifest.commands.flatMap(\.value.tool.outputs).map(\.name)
@@ -84,7 +84,7 @@ class PrepareForIndexTests: XCTestCase {
             observabilityScope: scope
         )
         let builder = LLBuildManifestBuilder(plan, fileSystem: fs, observabilityScope: scope)
-        let manifest = try builder.generatePrepareManifest(at: "/manifest")
+        let manifest = try builder.generateManifest(at: "/manifest")
 
         // Ensure our C module is here.
         let lib = try XCTUnwrap(graph.module(for: "lib"))
@@ -128,7 +128,7 @@ class PrepareForIndexTests: XCTestCase {
             observabilityScope: observability.topScope
         )
         let debugBuilder = LLBuildManifestBuilder(debugPlan, fileSystem: fs, observabilityScope: scope)
-        let debugManifest = try debugBuilder.generatePrepareManifest(at: "/manifest")
+        let debugManifest = try debugBuilder.generateManifest(at: "/manifest")
 
         XCTAssertNil(debugManifest.commands.values.first(where: {
             guard let swiftCommand = $0.tool as? SwiftCompilerTool,
@@ -149,7 +149,7 @@ class PrepareForIndexTests: XCTestCase {
             observabilityScope: observability.topScope
         )
         let releaseBuilder = LLBuildManifestBuilder(releasePlan, fileSystem: fs, observabilityScope: scope)
-        let releaseManifest = try releaseBuilder.generatePrepareManifest(at: "/manifest")
+        let releaseManifest = try releaseBuilder.generateManifest(at: "/manifest")
 
         XCTAssertEqual(releaseManifest.commands.values.filter({
             guard let swiftCommand = $0.tool as? SwiftCompilerTool,
@@ -174,7 +174,7 @@ class PrepareForIndexTests: XCTestCase {
         )
 
         let builder = LLBuildManifestBuilder(plan, fileSystem: fs, observabilityScope: scope)
-        let manifest = try builder.generatePrepareManifest(at: "/manifest")
+        let manifest = try builder.generateManifest(at: "/manifest")
 
         // Ensure swiftmodules built with correct arguments
         let coreCommands = manifest.commands.values.filter {