Wait for target to be prepared before returning diagnostics

ahoppen · ahoppen · commit 05dd10257d2b · 2024-05-26T18:55:15.000-07:00
Diagnostics are usually not helpful if the file’s target hasn’t been prepared yet. We should await the target’s preparation before returning diagnostics.

rdar://128645617
diff --git a/Package.swift b/Package.swift
@@ -367,6 +367,7 @@ let package = Package(
       name: "SourceKitLSPTests",
       dependencies: [
         "BuildServerProtocol",
+        "CAtomics",
         "LSPLogging",
         "LSPTestSupport",
         "LanguageServerProtocol",
diff --git a/Sources/SKTestSupport/MultiFileTestProject.swift b/Sources/SKTestSupport/MultiFileTestProject.swift
@@ -82,6 +82,7 @@ public class MultiFileTestProject {
     workspaces: (URL) async throws -> [WorkspaceFolder] = { [WorkspaceFolder(uri: DocumentURI($0))] },
     capabilities: ClientCapabilities = ClientCapabilities(),
     serverOptions: SourceKitLSPServer.Options = .testDefault,
+    enableBackgroundIndexing: Bool = false,
     usePullDiagnostics: Bool = true,
     preInitialization: ((TestSourceKitLSPClient) -> Void)? = nil,
     cleanUp: (() -> Void)? = nil,
@@ -117,6 +118,7 @@ public class MultiFileTestProject {
       serverOptions: serverOptions,
       capabilities: capabilities,
       usePullDiagnostics: usePullDiagnostics,
+      enableBackgroundIndexing: enableBackgroundIndexing,
       workspaceFolders: workspaces(scratchDirectory),
       preInitialization: preInitialization,
       cleanUp: { [scratchDirectory] in
diff --git a/Sources/SKTestSupport/SwiftPMTestProject.swift b/Sources/SKTestSupport/SwiftPMTestProject.swift
@@ -44,9 +44,10 @@ public class SwiftPMTestProject: MultiFileTestProject {
     allowBuildFailure: Bool = false,
     capabilities: ClientCapabilities = ClientCapabilities(),
     serverOptions: SourceKitLSPServer.Options = .testDefault,
+    enableBackgroundIndexing: Bool = false,
+    usePullDiagnostics: Bool = true,
     pollIndex: Bool = true,
     preInitialization: ((TestSourceKitLSPClient) -> Void)? = nil,
-    usePullDiagnostics: Bool = true,
     cleanUp: (() -> Void)? = nil,
     testName: String = #function
   ) async throws {
@@ -71,6 +72,7 @@ public class SwiftPMTestProject: MultiFileTestProject {
       workspaces: workspaces,
       capabilities: capabilities,
       serverOptions: serverOptions,
+      enableBackgroundIndexing: enableBackgroundIndexing,
       usePullDiagnostics: usePullDiagnostics,
       preInitialization: preInitialization,
       cleanUp: cleanUp,
diff --git a/Sources/SKTestSupport/TestSourceKitLSPClient.swift b/Sources/SKTestSupport/TestSourceKitLSPClient.swift
@@ -88,7 +88,8 @@ public final class TestSourceKitLSPClient: MessageHandler {
   ///     `true` by default
   ///   - initializationOptions: Initialization options to pass to the SourceKit-LSP server.
   ///   - capabilities: The test client's capabilities.
-  ///   - usePullDiagnostics: Whether to use push diagnostics or use push-based diagnostics
+  ///   - usePullDiagnostics: Whether to use push diagnostics or use push-based diagnostics.
+  ///   - enableBackgroundIndexing: Whether background indexing should be enabled in the project.
   ///   - workspaceFolders: Workspace folders to open.
   ///   - preInitialization: A closure that is called after the test client is created but before SourceKit-LSP is
   ///     initialized. This can be used to eg. register request handlers.
@@ -102,6 +103,7 @@ public final class TestSourceKitLSPClient: MessageHandler {
     initializationOptions: LSPAny? = nil,
     capabilities: ClientCapabilities = ClientCapabilities(),
     usePullDiagnostics: Bool = true,
+    enableBackgroundIndexing: Bool = false,
     workspaceFolders: [WorkspaceFolder]? = nil,
     preInitialization: ((TestSourceKitLSPClient) -> Void)? = nil,
     cleanUp: @Sendable @escaping () -> Void = {}
@@ -115,6 +117,7 @@ public final class TestSourceKitLSPClient: MessageHandler {
     if let moduleCache {
       serverOptions.buildSetup.flags.swiftCompilerFlags += ["-module-cache-path", moduleCache.path]
     }
+    serverOptions.indexOptions.enableBackgroundIndexing = enableBackgroundIndexing
 
     var notificationYielder: AsyncStream<any NotificationType>.Continuation!
     self.notifications = AsyncStream { continuation in
@@ -155,8 +158,8 @@ public final class TestSourceKitLSPClient: MessageHandler {
         XCTAssertEqual(request.registrations.only?.method, DocumentDiagnosticsRequest.method)
         return VoidResponse()
       }
-      preInitialization?(self)
     }
+    preInitialization?(self)
     if initialize {
       _ = try await self.send(
         InitializeRequest(
@@ -193,12 +196,22 @@ public final class TestSourceKitLSPClient: MessageHandler {
   /// Send the request to `server` and return the request result.
   public func send<R: RequestType>(_ request: R) async throws -> R.Response {
     return try await withCheckedThrowingContinuation { continuation in
-      server.handle(request, id: .number(Int(nextRequestID.fetchAndIncrement()))) { result in
+      self.send(request) { result in
         continuation.resume(with: result)
       }
     }
   }
 
+  /// Send the request to `server` and return the result via a completion handler.
+  ///
+  /// This version of the `send` function should only be used if some action needs to be performed after the request is
+  /// sent but before it returns a result.
+  public func send<R: RequestType>(_ request: R, completionHandler: @escaping (LSPResult<R.Response>) -> Void) {
+    server.handle(request, id: .number(Int(nextRequestID.fetchAndIncrement()))) { result in
+      completionHandler(result)
+    }
+  }
+
   /// Send the notification to `server`.
   public func send(_ notification: some NotificationType) {
     server.handle(notification)
diff --git a/Sources/SemanticIndex/SemanticIndexManager.swift b/Sources/SemanticIndex/SemanticIndexManager.swift
@@ -327,10 +327,7 @@ public final actor SemanticIndexManager {
   /// Schedule preparation of the target that contains the given URI, building all modules that the file depends on.
   ///
   /// This is intended to be called when the user is interacting with the document at the given URI.
-  public func schedulePreparationForEditorFunctionality(
-    of uri: DocumentURI,
-    priority: TaskPriority? = nil
-  ) {
+  public func schedulePreparationForEditorFunctionality(of uri: DocumentURI, priority: TaskPriority? = nil) {
     if inProgressPrepareForEditorTask?.document == uri {
       // We are already preparing this document, so nothing to do. This is necessary to avoid the following scenario:
       // Determining the canonical configured target for a document takes 1s and we get a new document request for the
@@ -341,13 +338,7 @@ public final actor SemanticIndexManager {
     let id = UUID()
     let task = Task(priority: priority) {
       await withLoggingScope("preparation") {
-        guard let target = await buildSystemManager.canonicalConfiguredTarget(for: uri) else {
-          return
-        }
-        if Task.isCancelled {
-          return
-        }
-        await self.prepare(targets: [target], priority: priority)
+        await self.prepareFileForEditorFunctionality(uri)
         if inProgressPrepareForEditorTask?.id == id {
           inProgressPrepareForEditorTask = nil
         }
@@ -357,6 +348,20 @@ public final actor SemanticIndexManager {
     inProgressPrepareForEditorTask = (id, uri, task)
   }
 
+  /// Prepare the target that the given file is in, building all modules that the file depends on. Returns when
+  /// preparation has finished.
+  ///
+  /// If file's target is known to be up-to-date, this returns almost immediately.
+  public func prepareFileForEditorFunctionality(_ uri: DocumentURI) async {
+    guard let target = await buildSystemManager.canonicalConfiguredTarget(for: uri) else {
+      return
+    }
+    if Task.isCancelled {
+      return
+    }
+    await self.prepare(targets: [target], priority: nil)
+  }
+
   // MARK: - Helper functions
 
   /// Prepare the given targets for indexing.
diff --git a/Sources/SourceKitLSP/Swift/SwiftLanguageService.swift b/Sources/SourceKitLSP/Swift/SwiftLanguageService.swift
@@ -17,6 +17,7 @@ import LSPLogging
 import LanguageServerProtocol
 import SKCore
 import SKSupport
+import SemanticIndex
 import SourceKitD
 import SwiftParser
 import SwiftParserDiagnostics
@@ -123,6 +124,9 @@ public actor SwiftLanguageService: LanguageService, Sendable {
 
   let syntaxTreeManager = SyntaxTreeManager()
 
+  /// The `semanticIndexManager` of the workspace this language service was created for.
+  private let semanticIndexManager: SemanticIndexManager?
+
   nonisolated var keys: sourcekitd_api_keys { return sourcekitd.keys }
   nonisolated var requests: sourcekitd_api_requests { return sourcekitd.requests }
   nonisolated var values: sourcekitd_api_values { return sourcekitd.values }
@@ -192,6 +196,7 @@ public actor SwiftLanguageService: LanguageService, Sendable {
     self.swiftFormat = toolchain.swiftFormat
     self.sourcekitd = try await DynamicallyLoadedSourceKitD.getOrCreate(dylibPath: sourcekitd)
     self.capabilityRegistry = workspace.capabilityRegistry
+    self.semanticIndexManager = workspace.semanticIndexManager
     self.serverOptions = options
     self.documentManager = DocumentManager()
     self.state = .connected
@@ -875,6 +880,7 @@ extension SwiftLanguageService {
 
   public func documentDiagnostic(_ req: DocumentDiagnosticsRequest) async throws -> DocumentDiagnosticReport {
     do {
+      await semanticIndexManager?.prepareFileForEditorFunctionality(req.textDocument.uri)
       let snapshot = try documentManager.latestSnapshot(req.textDocument.uri)
       let buildSettings = await self.buildSettings(for: req.textDocument.uri)
       let diagnosticReport = try await self.diagnosticReportManager.diagnosticReport(
diff --git a/Tests/SourceKitLSPTests/BackgroundIndexingTests.swift b/Tests/SourceKitLSPTests/BackgroundIndexingTests.swift
@@ -18,10 +18,6 @@ import SemanticIndex
 import SourceKitLSP
 import XCTest
 
-fileprivate let backgroundIndexingOptions = SourceKitLSPServer.Options(
-  indexOptions: IndexOptions(enableBackgroundIndexing: true)
-)
-
 final class BackgroundIndexingTests: XCTestCase {
   func testBackgroundIndexingOfSingleFile() async throws {
     let project = try await SwiftPMTestProject(
@@ -33,7 +29,7 @@ final class BackgroundIndexingTests: XCTestCase {
         }
         """
       ],
-      serverOptions: backgroundIndexingOptions
+      enableBackgroundIndexing: true
     )
 
     let (uri, positions) = try project.openDocument("MyFile.swift")
@@ -76,7 +72,7 @@ final class BackgroundIndexingTests: XCTestCase {
         }
         """,
       ],
-      serverOptions: backgroundIndexingOptions
+      enableBackgroundIndexing: true
     )
 
     let (uri, positions) = try project.openDocument("MyFile.swift")
@@ -134,7 +130,7 @@ final class BackgroundIndexingTests: XCTestCase {
           ]
         )
         """,
-      serverOptions: backgroundIndexingOptions
+      enableBackgroundIndexing: true
     )
 
     let (uri, positions) = try project.openDocument("MyFile.swift")
@@ -166,7 +162,7 @@ final class BackgroundIndexingTests: XCTestCase {
   }
 
   func testBackgroundIndexingHappensWithLowPriority() async throws {
-    var serverOptions = backgroundIndexingOptions
+    var serverOptions = SourceKitLSPServer.Options.testDefault
     serverOptions.indexTestHooks.preparationTaskDidFinish = { taskDescription in
       XCTAssert(Task.currentPriority == .low, "\(taskDescription) ran with priority \(Task.currentPriority)")
     }
@@ -199,6 +195,7 @@ final class BackgroundIndexingTests: XCTestCase {
         )
         """,
       serverOptions: serverOptions,
+      enableBackgroundIndexing: true,
       pollIndex: false
     )
 
@@ -249,7 +246,7 @@ final class BackgroundIndexingTests: XCTestCase {
           ]
         )
         """,
-      serverOptions: backgroundIndexingOptions
+      enableBackgroundIndexing: true
     )
 
     let dependencyUrl = try XCTUnwrap(
@@ -300,7 +297,7 @@ final class BackgroundIndexingTests: XCTestCase {
         }
         """,
       ],
-      serverOptions: backgroundIndexingOptions
+      enableBackgroundIndexing: true
     )
 
     let (uri, positions) = try project.openDocument("MyFile.c")
@@ -339,7 +336,7 @@ final class BackgroundIndexingTests: XCTestCase {
     let receivedReportProgressNotification = self.expectation(
       description: "Received work done progress saying indexing"
     )
-    var serverOptions = backgroundIndexingOptions
+    var serverOptions = SourceKitLSPServer.Options.testDefault
     serverOptions.indexTestHooks = IndexTestHooks(
       buildGraphGenerationDidFinish: {
         await self.fulfillment(of: [receivedBeginProgressNotification], timeout: defaultTimeout)
@@ -359,6 +356,7 @@ final class BackgroundIndexingTests: XCTestCase {
       ],
       capabilities: ClientCapabilities(window: WindowClientCapabilities(workDoneProgress: true)),
       serverOptions: serverOptions,
+      enableBackgroundIndexing: true,
       pollIndex: false,
       preInitialization: { testClient in
         testClient.handleMultipleRequests { (request: CreateWorkDoneProgressRequest) in
@@ -419,7 +417,7 @@ final class BackgroundIndexingTests: XCTestCase {
         """,
         "MyOtherFile.swift": "",
       ],
-      serverOptions: backgroundIndexingOptions
+      enableBackgroundIndexing: true
     )
 
     let (uri, positions) = try project.openDocument("MyFile.swift")
@@ -486,7 +484,7 @@ final class BackgroundIndexingTests: XCTestCase {
         #include "Header.h"
         """,
       ],
-      serverOptions: backgroundIndexingOptions
+      enableBackgroundIndexing: true
     )
 
     let (uri, positions) = try project.openDocument("Header.h", language: .c)
@@ -544,7 +542,7 @@ final class BackgroundIndexingTests: XCTestCase {
 
   func testPrepareTargetAfterEditToDependency() async throws {
     try await SkipUnless.swiftpmStoresModulesInSubdirectory()
-    var serverOptions = backgroundIndexingOptions
+    var serverOptions = SourceKitLSPServer.Options.testDefault
     let expectedPreparationTracker = ExpectedIndexTaskTracker(expectedPreparations: [
       [
         ExpectedPreparation(targetID: "LibA", runDestinationID: "dummy"),
@@ -580,6 +578,7 @@ final class BackgroundIndexingTests: XCTestCase {
         )
         """,
       serverOptions: serverOptions,
+      enableBackgroundIndexing: true,
       cleanUp: { expectedPreparationTracker.keepAlive() }
     )
 
@@ -637,7 +636,7 @@ final class BackgroundIndexingTests: XCTestCase {
     let libDPreparedForEditing = self.expectation(description: "LibD prepared for editing")
 
     try await SkipUnless.swiftpmStoresModulesInSubdirectory()
-    var serverOptions = backgroundIndexingOptions
+    var serverOptions = SourceKitLSPServer.Options.testDefault
     let expectedPreparationTracker = ExpectedIndexTaskTracker(expectedPreparations: [
       // Preparation of targets during the initial of the target
       [
@@ -689,6 +688,7 @@ final class BackgroundIndexingTests: XCTestCase {
         )
         """,
       serverOptions: serverOptions,
+      enableBackgroundIndexing: true,
       cleanUp: { expectedPreparationTracker.keepAlive() }
     )
 
@@ -718,7 +718,7 @@ final class BackgroundIndexingTests: XCTestCase {
       files: [
         "MyFile.swift": ""
       ],
-      serverOptions: backgroundIndexingOptions
+      enableBackgroundIndexing: true
     )
     let targetPrepareNotification = try await project.testClient.nextNotification(ofType: LogMessageNotification.self)
     XCTAssert(
@@ -732,13 +732,13 @@ final class BackgroundIndexingTests: XCTestCase {
     )
   }
 
-  func testPreparationHappensInParallel() async throws {
+  func testIndexingHappensInParallel() async throws {
     try await SkipUnless.swiftpmStoresModulesInSubdirectory()
 
     let fileAIndexingStarted = self.expectation(description: "FileA indexing started")
     let fileBIndexingStarted = self.expectation(description: "FileB indexing started")
 
-    var serverOptions = backgroundIndexingOptions
+    var serverOptions = SourceKitLSPServer.Options.testDefault
     let expectedIndexTaskTracker = ExpectedIndexTaskTracker(
       expectedIndexStoreUpdates: [
         [
@@ -771,6 +771,7 @@ final class BackgroundIndexingTests: XCTestCase {
         "FileB.swift": "",
       ],
       serverOptions: serverOptions,
+      enableBackgroundIndexing: true,
       cleanUp: { expectedIndexTaskTracker.keepAlive() }
     )
   }
@@ -801,10 +802,10 @@ final class BackgroundIndexingTests: XCTestCase {
           ]
         )
         """,
-      serverOptions: backgroundIndexingOptions
+      enableBackgroundIndexing: true
     )
 
-    var otherClientOptions = backgroundIndexingOptions
+    var otherClientOptions = SourceKitLSPServer.Options.testDefault
     otherClientOptions.indexTestHooks = IndexTestHooks(
       preparationTaskDidStart: { taskDescription in
         XCTFail("Did not expect any target preparation, got \(taskDescription.targetsToPrepare)")
@@ -815,6 +816,7 @@ final class BackgroundIndexingTests: XCTestCase {
     )
     let otherClient = try await TestSourceKitLSPClient(
       serverOptions: otherClientOptions,
+      enableBackgroundIndexing: true,
       workspaceFolders: [
         WorkspaceFolder(uri: DocumentURI(project.scratchDirectory))
       ]
diff --git a/Tests/SourceKitLSPTests/PullDiagnosticsTests.swift b/Tests/SourceKitLSPTests/PullDiagnosticsTests.swift

Original file line number	Diff line number	Diff line change
`@@ -18,10 +18,6 @@ import SemanticIndex`
`18`	`18`	`import SourceKitLSP`
`19`	`19`	`import XCTest`
`20`	`20`
`21`		`-fileprivate let backgroundIndexingOptions = SourceKitLSPServer.Options(`
`22`		`- indexOptions: IndexOptions(enableBackgroundIndexing: true)`
`23`		`-)`
`24`		`-`
`25`	`21`	`final class BackgroundIndexingTests: XCTestCase {`
`26`	`22`	`func testBackgroundIndexingOfSingleFile() async throws {`
`27`	`23`	`let project = try await SwiftPMTestProject(`
`@@ -33,7 +29,7 @@ final class BackgroundIndexingTests: XCTestCase {`
`33`	`29`	`}`
`34`	`30`	`"""`
`35`	`31`	`],`
`36`		`- serverOptions: backgroundIndexingOptions`
	`32`	`+ enableBackgroundIndexing: true`
`37`	`33`	`)`
`38`	`34`
`39`	`35`	`let (uri, positions) = try project.openDocument("MyFile.swift")`
`@@ -76,7 +72,7 @@ final class BackgroundIndexingTests: XCTestCase {`
`76`	`72`	`}`
`77`	`73`	`""",`
`78`	`74`	`],`
`79`		`- serverOptions: backgroundIndexingOptions`
	`75`	`+ enableBackgroundIndexing: true`
`80`	`76`	`)`
`81`	`77`
`82`	`78`	`let (uri, positions) = try project.openDocument("MyFile.swift")`
`@@ -134,7 +130,7 @@ final class BackgroundIndexingTests: XCTestCase {`
`134`	`130`	`]`
`135`	`131`	`)`
`136`	`132`	`""",`
`137`		`- serverOptions: backgroundIndexingOptions`
	`133`	`+ enableBackgroundIndexing: true`
`138`	`134`	`)`
`139`	`135`
`140`	`136`	`let (uri, positions) = try project.openDocument("MyFile.swift")`
`@@ -166,7 +162,7 @@ final class BackgroundIndexingTests: XCTestCase {`
`166`	`162`	`}`
`167`	`163`
`168`	`164`	`func testBackgroundIndexingHappensWithLowPriority() async throws {`
`169`		`- var serverOptions = backgroundIndexingOptions`
	`165`	`+ var serverOptions = SourceKitLSPServer.Options.testDefault`
`170`	`166`	`serverOptions.indexTestHooks.preparationTaskDidFinish = { taskDescription in`
`171`	`167`	`XCTAssert(Task.currentPriority == .low, "\(taskDescription) ran with priority \(Task.currentPriority)")`
`172`	`168`	`}`
`@@ -199,6 +195,7 @@ final class BackgroundIndexingTests: XCTestCase {`
`199`	`195`	`)`
`200`	`196`	`""",`
`201`	`197`	`serverOptions: serverOptions,`
	`198`	`+ enableBackgroundIndexing: true,`
`202`	`199`	`pollIndex: false`
`203`	`200`	`)`
`204`	`201`
`@@ -249,7 +246,7 @@ final class BackgroundIndexingTests: XCTestCase {`
`249`	`246`	`]`
`250`	`247`	`)`
`251`	`248`	`""",`
`252`		`- serverOptions: backgroundIndexingOptions`
	`249`	`+ enableBackgroundIndexing: true`
`253`	`250`	`)`
`254`	`251`
`255`	`252`	`let dependencyUrl = try XCTUnwrap(`
`@@ -300,7 +297,7 @@ final class BackgroundIndexingTests: XCTestCase {`
`300`	`297`	`}`
`301`	`298`	`""",`
`302`	`299`	`],`
`303`		`- serverOptions: backgroundIndexingOptions`
	`300`	`+ enableBackgroundIndexing: true`
`304`	`301`	`)`
`305`	`302`
`306`	`303`	`let (uri, positions) = try project.openDocument("MyFile.c")`
`@@ -339,7 +336,7 @@ final class BackgroundIndexingTests: XCTestCase {`
`339`	`336`	`let receivedReportProgressNotification = self.expectation(`
`340`	`337`	`description: "Received work done progress saying indexing"`
`341`	`338`	`)`
`342`		`- var serverOptions = backgroundIndexingOptions`
	`339`	`+ var serverOptions = SourceKitLSPServer.Options.testDefault`
`343`	`340`	`serverOptions.indexTestHooks = IndexTestHooks(`
`344`	`341`	`buildGraphGenerationDidFinish: {`
`345`	`342`	`await self.fulfillment(of: [receivedBeginProgressNotification], timeout: defaultTimeout)`
`@@ -359,6 +356,7 @@ final class BackgroundIndexingTests: XCTestCase {`
`359`	`356`	`],`
`360`	`357`	`capabilities: ClientCapabilities(window: WindowClientCapabilities(workDoneProgress: true)),`
`361`	`358`	`serverOptions: serverOptions,`
	`359`	`+ enableBackgroundIndexing: true,`
`362`	`360`	`pollIndex: false,`
`363`	`361`	`preInitialization: { testClient in`
`364`	`362`	`testClient.handleMultipleRequests { (request: CreateWorkDoneProgressRequest) in`
`@@ -419,7 +417,7 @@ final class BackgroundIndexingTests: XCTestCase {`
`419`	`417`	`""",`
`420`	`418`	`"MyOtherFile.swift": "",`
`421`	`419`	`],`
`422`		`- serverOptions: backgroundIndexingOptions`
	`420`	`+ enableBackgroundIndexing: true`
`423`	`421`	`)`
`424`	`422`
`425`	`423`	`let (uri, positions) = try project.openDocument("MyFile.swift")`
`@@ -486,7 +484,7 @@ final class BackgroundIndexingTests: XCTestCase {`
`486`	`484`	`#include "Header.h"`
`487`	`485`	`""",`
`488`	`486`	`],`
`489`		`- serverOptions: backgroundIndexingOptions`
	`487`	`+ enableBackgroundIndexing: true`
`490`	`488`	`)`
`491`	`489`
`492`	`490`	`let (uri, positions) = try project.openDocument("Header.h", language: .c)`
`@@ -544,7 +542,7 @@ final class BackgroundIndexingTests: XCTestCase {`
`544`	`542`
`545`	`543`	`func testPrepareTargetAfterEditToDependency() async throws {`
`546`	`544`	`try await SkipUnless.swiftpmStoresModulesInSubdirectory()`
`547`		`- var serverOptions = backgroundIndexingOptions`
	`545`	`+ var serverOptions = SourceKitLSPServer.Options.testDefault`
`548`	`546`	`let expectedPreparationTracker = ExpectedIndexTaskTracker(expectedPreparations: [`
`549`	`547`	`[`
`550`	`548`	`ExpectedPreparation(targetID: "LibA", runDestinationID: "dummy"),`
`@@ -580,6 +578,7 @@ final class BackgroundIndexingTests: XCTestCase {`
`580`	`578`	`)`
`581`	`579`	`""",`
`582`	`580`	`serverOptions: serverOptions,`
	`581`	`+ enableBackgroundIndexing: true,`
`583`	`582`	`cleanUp: { expectedPreparationTracker.keepAlive() }`
`584`	`583`	`)`
`585`	`584`
`@@ -637,7 +636,7 @@ final class BackgroundIndexingTests: XCTestCase {`
`637`	`636`	`let libDPreparedForEditing = self.expectation(description: "LibD prepared for editing")`
`638`	`637`
`639`	`638`	`try await SkipUnless.swiftpmStoresModulesInSubdirectory()`
`640`		`- var serverOptions = backgroundIndexingOptions`
	`639`	`+ var serverOptions = SourceKitLSPServer.Options.testDefault`
`641`	`640`	`let expectedPreparationTracker = ExpectedIndexTaskTracker(expectedPreparations: [`
`642`	`641`	`// Preparation of targets during the initial of the target`
`643`	`642`	`[`
`@@ -689,6 +688,7 @@ final class BackgroundIndexingTests: XCTestCase {`
`689`	`688`	`)`
`690`	`689`	`""",`
`691`	`690`	`serverOptions: serverOptions,`
	`691`	`+ enableBackgroundIndexing: true,`
`692`	`692`	`cleanUp: { expectedPreparationTracker.keepAlive() }`
`693`	`693`	`)`
`694`	`694`
`@@ -718,7 +718,7 @@ final class BackgroundIndexingTests: XCTestCase {`
`718`	`718`	`files: [`
`719`	`719`	`"MyFile.swift": ""`
`720`	`720`	`],`
`721`		`- serverOptions: backgroundIndexingOptions`
	`721`	`+ enableBackgroundIndexing: true`
`722`	`722`	`)`
`723`	`723`	`let targetPrepareNotification = try await project.testClient.nextNotification(ofType: LogMessageNotification.self)`
`724`	`724`	`XCTAssert(`
`@@ -732,13 +732,13 @@ final class BackgroundIndexingTests: XCTestCase {`
`732`	`732`	`)`
`733`	`733`	`}`
`734`	`734`
`735`		`- func testPreparationHappensInParallel() async throws {`
	`735`	`+ func testIndexingHappensInParallel() async throws {`
`736`	`736`	`try await SkipUnless.swiftpmStoresModulesInSubdirectory()`
`737`	`737`
`738`	`738`	`let fileAIndexingStarted = self.expectation(description: "FileA indexing started")`
`739`	`739`	`let fileBIndexingStarted = self.expectation(description: "FileB indexing started")`
`740`	`740`
`741`		`- var serverOptions = backgroundIndexingOptions`
	`741`	`+ var serverOptions = SourceKitLSPServer.Options.testDefault`
`742`	`742`	`let expectedIndexTaskTracker = ExpectedIndexTaskTracker(`
`743`	`743`	`expectedIndexStoreUpdates: [`
`744`	`744`	`[`
`@@ -771,6 +771,7 @@ final class BackgroundIndexingTests: XCTestCase {`
`771`	`771`	`"FileB.swift": "",`
`772`	`772`	`],`
`773`	`773`	`serverOptions: serverOptions,`
	`774`	`+ enableBackgroundIndexing: true,`
`774`	`775`	`cleanUp: { expectedIndexTaskTracker.keepAlive() }`
`775`	`776`	`)`
`776`	`777`	`}`
`@@ -801,10 +802,10 @@ final class BackgroundIndexingTests: XCTestCase {`
`801`	`802`	`]`
`802`	`803`	`)`
`803`	`804`	`""",`
`804`		`- serverOptions: backgroundIndexingOptions`
	`805`	`+ enableBackgroundIndexing: true`
`805`	`806`	`)`
`806`	`807`
`807`		`- var otherClientOptions = backgroundIndexingOptions`
	`808`	`+ var otherClientOptions = SourceKitLSPServer.Options.testDefault`
`808`	`809`	`otherClientOptions.indexTestHooks = IndexTestHooks(`
`809`	`810`	`preparationTaskDidStart: { taskDescription in`
`810`	`811`	`XCTFail("Did not expect any target preparation, got \(taskDescription.targetsToPrepare)")`
`@@ -815,6 +816,7 @@ final class BackgroundIndexingTests: XCTestCase {`
`815`	`816`	`)`
`816`	`817`	`let otherClient = try await TestSourceKitLSPClient(`
`817`	`818`	`serverOptions: otherClientOptions,`
	`819`	`+ enableBackgroundIndexing: true,`
`818`	`820`	`workspaceFolders: [`
`819`	`821`	`WorkspaceFolder(uri: DocumentURI(project.scratchDirectory))`
`820`	`822`	`]`