Simplify the check for prepareForIndexing, new swiftc flags.

Moves the prepareForIndexing checks to more common points
simplifing the checks. Also adds two more compile flags which
makes the preparation much faster.

Author: dschaefer2

Sources/Build/BuildDescription/SwiftTargetBuildDescription.swift

@@ -246,12 +246,6 @@ public final class SwiftTargetBuildDescription {
     /// Whether to disable sandboxing (e.g. for macros).
     private let shouldDisableSandbox: Bool
 
-    /// Whether to build preparing for indexing
-    public var prepareForIndexing: Bool {
-        // Do full build for tools
-        defaultBuildParameters.prepareForIndexing && target.buildTriple != .tools
-    }
-
     /// Create a new target description with target and build parameters.
     init(
         package: ResolvedPackage,
@@ -588,9 +582,12 @@ public final class SwiftTargetBuildDescription {
             args += ["-emit-module-interface-path", self.parseableModuleInterfaceOutputPath.pathString]
         }
 
-        if self.prepareForIndexing {
+        if self.defaultBuildParameters.prepareForIndexing {
             args += [
+                "-Xfrontend", "-enable-library-evolution",
                 "-Xfrontend", "-experimental-skip-all-function-bodies",
+                "-Xfrontend", "-experimental-lazy-typecheck",
+                "-Xfrontend", "-experimental-skip-non-exportable-decls",
                 "-Xfrontend", "-experimental-allow-module-with-compiler-errors",
                 "-Xfrontend", "-empty-abi-descriptor"
             ]

Sources/Build/BuildManifest/LLBuildManifestBuilder+Swift.swift

@@ -44,7 +44,7 @@ extension LLBuildManifestBuilder {
         let objectNodes = try target.objects.map(Node.file)
         let moduleNode = Node.file(target.moduleOutputPath)
         let cmdOutputs: [Node]
-        if target.prepareForIndexing {
+        if target.defaultBuildParameters.prepareForIndexing {
             // Don't include the object nodes on prepare builds
             cmdOutputs = [moduleNode]
         } else {
@@ -404,7 +404,7 @@ extension LLBuildManifestBuilder {
             isLibrary: isLibrary,
             wholeModuleOptimization: target.defaultBuildParameters.configuration == .release,
             outputFileMapPath: try target.writeOutputFileMap(), // FIXME: Eliminate side effect.
-            prepareForIndexing: target.prepareForIndexing
+            prepareForIndexing: target.defaultBuildParameters.prepareForIndexing
         )
     }
 
@@ -424,7 +424,7 @@ extension LLBuildManifestBuilder {
             inputs.append(resourcesNode)
         }
 
-        let prepareForIndexing = target.prepareForIndexing
+        let prepareForIndexing = target.defaultBuildParameters.prepareForIndexing
 
         func addStaticTargetInputs(_ target: ResolvedModule) throws {
             // Ignore C Modules.
@@ -456,9 +456,10 @@ extension LLBuildManifestBuilder {
                 inputs.append(file: target.moduleOutputPath)
             case .clang(let target)?:
                 if prepareForIndexing {
-                    // In preparation, we're only building swiftmodules, need to depend on sources
-                    for source in target.clangTarget.sources.paths {
-                        inputs.append(file: source)
+                    // In preparation, we're only building swiftmodules
+                    // propagate the dependency to the header files in this target
+                    for header in target.clangTarget.headers {
+                        inputs.append(file: header)
                     }
                 } else {
                     for object in try target.objects {
@@ -537,7 +538,7 @@ extension LLBuildManifestBuilder {
 
     private func addModuleWrapCmd(_ target: SwiftTargetBuildDescription) throws {
         // Add commands to perform the module wrapping Swift modules when debugging strategy is `modulewrap`.
-        guard target.defaultBuildParameters.debuggingStrategy == .modulewrap, !target.prepareForIndexing else { return }
+        guard target.defaultBuildParameters.debuggingStrategy == .modulewrap else { return }
         var moduleWrapArgs = [
             target.defaultBuildParameters.toolchain.swiftCompilerPath.pathString,
             "-modulewrap", target.moduleOutputPath.pathString,

Sources/Build/BuildManifest/LLBuildManifestBuilder.swift

@@ -150,8 +150,11 @@ public class LLBuildManifestBuilder {
 
         for (_, description) in self.plan.productMap {
             // Need to generate macro products
-            if description.product.type == .macro {
+            switch description.product.type {
+            case .macro, .plugin:
                 try self.createProductCommand(description)
+            default:
+                break
             }
         }
 

Sources/CoreCommands/SwiftCommandState.swift

@@ -725,7 +725,7 @@ public final class SwiftCommandState {
     when building on macOS.
     """
 
-    private func _buildParams(toolchain: UserToolchain) throws -> BuildParameters {
+    private func _buildParams(toolchain: UserToolchain, prepareForIndexing: Bool? = nil) throws -> BuildParameters {
         let triple = toolchain.targetTriple
 
         let dataPath = self.scratchDirectory.appending(
@@ -748,7 +748,7 @@ public final class SwiftCommandState {
             sanitizers: options.build.enabledSanitizers,
             indexStoreMode: options.build.indexStoreMode.buildParameter,
             isXcodeBuildSystemEnabled: options.build.buildSystem == .xcode,
-            prepareForIndexing: options.build.prepareForIndexing,
+            prepareForIndexing: prepareForIndexing ?? options.build.prepareForIndexing,
             debuggingParameters: .init(
                 debugInfoFormat: options.build.debugInfoFormat.buildParameter,
                 triple: triple,
@@ -797,7 +797,8 @@ public final class SwiftCommandState {
 
     private lazy var _toolsBuildParameters: Result<BuildParameters, Swift.Error> = {
         Result(catching: {
-            try _buildParams(toolchain: self.getHostToolchain())
+            // Ensure prepare for indexing is disable for tools
+            try _buildParams(toolchain: self.getHostToolchain(), prepareForIndexing: false)
         })
     }()
 

Sources/SPMBuildCore/BuildParameters/BuildParameters+Debugging.swift

@@ -63,7 +63,7 @@ extension BuildParameters {
 
     /// The debugging strategy according to the current build parameters.
     public var debuggingStrategy: DebuggingStrategy? {
-        guard configuration == .debug else {
+        guard configuration == .debug, !prepareForIndexing else {
             return nil
         }
 

Tests/BuildTests/PrepareForIndexTests.swift

@@ -21,7 +21,7 @@ class PrepareForIndexTests: XCTestCase {
 
         let plan = try BuildPlan(
             destinationBuildParameters: mockBuildParameters(prepareForIndexing: true),
-            toolsBuildParameters: mockBuildParameters(prepareForIndexing: true),
+            toolsBuildParameters: mockBuildParameters(prepareForIndexing: false),
             graph: graph,
             fileSystem: fs,
             observabilityScope: scope