Re-index header files when they are modified

Author: ahoppen

Sources/BuildServerProtocol/SupportTypes/BuildTarget.swift

@@ -71,7 +71,7 @@ public struct BuildTarget: Codable, Hashable, Sendable {
     displayName: String? = nil,
     baseDirectory: URI? = nil,
     tags: [BuildTargetTag] = [],
-    capabilities: BuildTargetCapabilities,
+    capabilities: BuildTargetCapabilities = BuildTargetCapabilities(),
     languageIds: [Language],
     dependencies: [BuildTargetIdentifier],
     dataKind: BuildTargetDataKind? = nil,

Sources/BuildSystemIntegration/BuildSystemManager.swift

@@ -811,24 +811,6 @@ package actor BuildSystemManager: QueueBasedMessageHandler {
     return Array(targets)
   }
 
-  /// The `OutputPath` with which `uri` should be indexed in `target`. This may return:
-  ///  - `.path` if the build server supports output paths and produced a result
-  ///  - `.notSupported` if the build server does not support output paths. In this case we will assume that the index
-  ///    for `uri` is up-to-date if we have any up-to-date unit for it.
-  ///  - `nil` if the build server supports output paths but did not return an output path for `uri` in `target`.
-  package func outputPath(for document: DocumentURI, in target: BuildTargetIdentifier) async throws -> OutputPath? {
-    guard await initializationData?.outputPathsProvider ?? false else {
-      // Early exit if the build server doesn't support output paths.
-      return .notSupported
-    }
-    guard let sourceFileInfo = await sourceFileInfo(for: document),
-      let outputPath = sourceFileInfo.targetsToOutputPaths[target]
-    else {
-      return nil
-    }
-    return outputPath
-  }
-
   /// Returns the `BuildTargetIdentifier` that should be used for semantic functionality of the given document.
   package func canonicalTarget(for document: DocumentURI) async -> BuildTargetIdentifier? {
     // Sort the targets to deterministically pick the same `BuildTargetIdentifier` every time.

Sources/SKTestSupport/CustomBuildServerTestProject.swift

@@ -120,18 +120,31 @@ package extension CustomBuildServer {
     )
   }
 
-  func initializationResponseSupportingBackgroundIndexing(projectRoot: URL) throws -> InitializeBuildResponse {
+  func initializationResponseSupportingBackgroundIndexing(
+    projectRoot: URL,
+    outputPathsProvider: Bool
+  ) throws -> InitializeBuildResponse {
     return initializationResponse(
       initializeData: SourceKitInitializeBuildResponseData(
         indexDatabasePath: try projectRoot.appendingPathComponent("index-db").filePath,
         indexStorePath: try projectRoot.appendingPathComponent("index-store").filePath,
-        outputPathsProvider: true,
+        outputPathsProvider: outputPathsProvider,
         prepareProvider: true,
         sourceKitOptionsProvider: true
       )
     )
   }
 
+  func sourceItem(for url: URL, outputPath: String) -> SourceItem {
+    SourceItem(
+      uri: URI(url),
+      kind: .file,
+      generated: false,
+      dataKind: .sourceKit,
+      data: SourceKitSourceItemData(outputPath: outputPath).encodeToLSPAny()
+    )
+  }
+
   func dummyTargetSourcesResponse(_ files: some Sequence<DocumentURI>) -> BuildTargetSourcesResponse {
     return BuildTargetSourcesResponse(items: [
       SourcesItem(target: .dummy, sources: files.map { SourceItem(uri: $0, kind: .file, generated: false) })

Sources/SemanticIndex/SemanticIndexManager.swift

@@ -465,67 +465,78 @@ package final actor SemanticIndexManager {
     }
     let modifiedFilesIndex = index.checked(for: .modifiedFiles)
 
-    let filesWithTargetAndOutput: [(file: DocumentURI, target: BuildTargetIdentifier, outputPath: OutputPath?)] =
-      await files.asyncFlatMap { file in
-        await buildSystemManager.sourceFileInfo(for: file)?.targetsToOutputPaths.map { (file, $0, $1) } ?? []
-      }
-
-    let filesToReIndex =
-      await filesWithTargetAndOutput
-      .asyncCompactMap { (uri, target, outputPath) -> (FileIndexInfo, Date?)? in
+    var filesToReIndex: [(FileIndexInfo, Date?)] = []
+    for uri in files {
+      var didFindTargetToIndex = false
+      for (target, outputPath) in await buildSystemManager.sourceFileInfo(for: uri)?.targetsToOutputPaths ?? [:] {
         // First, check if we know that the file is up-to-date, in which case we don't need to hit the index or file
         // system at all
         if !indexFilesWithUpToDateUnits, await indexStoreUpToDateTracker.isUpToDate(uri, target) {
-          return nil
+          continue
         }
         if sourceFiles.contains(uri) {
           guard let outputPath else {
             logger.info("Not indexing \(uri.forLogging) because its output file could not be determined")
-            return nil
+            continue
           }
           if !indexFilesWithUpToDateUnits, modifiedFilesIndex.hasUpToDateUnit(for: uri, outputPath: outputPath) {
-            return nil
+            continue
           }
           // If this is a source file, just index it.
-          return (
-            FileIndexInfo(file: .indexableFile(uri), target: target, outputPath: outputPath),
-            modifiedFilesIndex.modificationDate(of: uri)
-          )
-        }
-        // Otherwise, see if it is a header file. If so, index a main file that that imports it to update header file's
-        // index.
-        // Deterministically pick a main file. This ensures that we always pick the same main file for a header. This way,
-        // if we request the same header to be indexed twice, we'll pick the same unit file the second time around,
-        // realize that its timestamp is later than the modification date of the header and we don't need to re-index.
-        let mainFile = await buildSystemManager.mainFiles(containing: uri)
-          .sorted(by: { $0.stringValue < $1.stringValue }).first
-        guard let mainFile else {
-          logger.info("Not indexing \(uri) because its main file could not be inferred")
-          return nil
-        }
-        let mainFileOutputPath = await orLog("Getting output path") {
-          try await buildSystemManager.outputPath(for: mainFile, in: target)
-        }
-        guard let mainFileOutputPath else {
-          logger.info(
-            "Not indexing \(uri.forLogging) because the output file of its main file \(mainFile.forLogging) could not be determined"
+          didFindTargetToIndex = true
+          filesToReIndex.append(
+            (
+              FileIndexInfo(file: .indexableFile(uri), target: target, outputPath: outputPath),
+              modifiedFilesIndex.modificationDate(of: uri)
+            )
           )
-          return nil
         }
-        if !indexFilesWithUpToDateUnits,
-          modifiedFilesIndex.hasUpToDateUnit(for: uri, mainFile: mainFile, outputPath: mainFileOutputPath)
-        {
-          return nil
-        }
-        return (
+      }
+
+      if didFindTargetToIndex {
+        continue
+      }
+      // If we haven't found any ways to index the file, see if it is a header file. If so, index a main file that
+      // that imports it to update header file's index.
+      // Deterministically pick a main file. This ensures that we always pick the same main file for a header. This way,
+      // if we request the same header to be indexed twice, we'll pick the same unit file the second time around,
+      // realize that its timestamp is later than the modification date of the header and we don't need to re-index.
+      let mainFile = await buildSystemManager.mainFiles(containing: uri)
+        .sorted(by: { $0.stringValue < $1.stringValue }).first
+      guard let mainFile else {
+        logger.info("Not indexing \(uri.forLogging) because its main file could not be inferred")
+        continue
+      }
+      let targetAndOutputPath = (await buildSystemManager.sourceFileInfo(for: mainFile)?.targetsToOutputPaths ?? [:])
+        .sorted(by: { $0.key.uri.stringValue < $1.key.uri.stringValue }).first
+      guard let targetAndOutputPath else {
+        logger.info(
+          "Not indexing \(uri.forLogging) because the target file of its main file \(mainFile.forLogging) could not be determined"
+        )
+        continue
+      }
+      guard let outputPath = targetAndOutputPath.value else {
+        logger.info(
+          "Not indexing \(uri.forLogging) because the output file of its main file \(mainFile.forLogging) could not be determined"
+        )
+        continue
+      }
+      if !indexFilesWithUpToDateUnits,
+        modifiedFilesIndex.hasUpToDateUnit(for: uri, mainFile: mainFile, outputPath: outputPath)
+      {
+        continue
+      }
+      filesToReIndex.append(
+        (
           FileIndexInfo(
             file: .headerFile(header: uri, mainFile: mainFile),
-            target: target,
-            outputPath: mainFileOutputPath
+            target: targetAndOutputPath.key,
+            outputPath: outputPath
           ),
           modifiedFilesIndex.modificationDate(of: uri)
         )
-      }
+      )
+    }
     return filesToReIndex
   }