Merge pull request #2017 from ahoppen/output-file-paths

Add BSP request to get the output file paths of a target

Author: ahoppen

Contributor Documentation/BSP Extensions.md

@@ -14,13 +14,16 @@ Definition is the same as in LSP.
 
 ```ts
 export interface SourceKitInitializeBuildResponseData {
+  /** The path at which SourceKit-LSP can store its index database, aggregating data from `indexStorePath`.
+   * This should point to a directory that can be exclusively managed by SourceKit-LSP. Its exact location can be arbitrary. */
+  indexDatabasePath?: string;
+
   /** The directory to which the index store is written during compilation, ie. the path passed to `-index-store-path`
    * for `swiftc` or `clang` invocations **/
   indexStorePath?: string;
 
-  /** The path at which SourceKit-LSP can store its index database, aggregating data from `indexStorePath`.
-   * This should point to a directory that can be exclusively managed by SourceKit-LSP. Its exact location can be arbitrary. */
-  indexDatabasePath?: string;
+  /** Whether the server implements the `buildTarget/outputPaths` request. */
+  outputPathsProvider?: bool;
 
   /** Whether the build server supports the `buildTarget/prepare` request */
   prepareProvider?: bool;
@@ -43,6 +46,37 @@ If `data` contains a string value for the `workDoneProgressTitle` key, then the
 
 `changes` can be `null` to indicate that all targets have changed.
 
+## `buildTarget/outputPaths`
+
+For all the source files in this target, the output paths that are used during indexing, ie. the `-index-unit-output-path` for the file, if it is specified in the compiler arguments or the file that is passed as `-o`, if `-index-unit-output-path` is not specified.
+
+This allows SourceKit-LSP to remove index entries for source files that are removed from a target but remain present on disk.
+
+The server communicates during the initialize handshake whether this method is supported or not by setting `outputPathsProvider: true` in `SourceKitInitializeBuildResponseData`.
+
+- method: `buildTarget/outputPaths`
+- params: `OutputPathsParams`
+- result: `OutputPathsResult`
+
+```ts
+export interface BuildTargetOutputPathsParams {
+  /** A list of build targets to get the output paths for. */
+  targets: BuildTargetIdentifier[];
+}
+
+export interface BuildTargetOutputPathsItem {
+  /** The target these output file paths are for. */
+  target: BuildTargetIdentifier;
+
+  /** The output paths for all source files in this target. */
+  outputPaths: string[];
+}
+
+export interface BuildTargetOutputPathsResult {
+  items: BuildTargetOutputPathsItem[];
+}
+```
+
 ## `buildTarget/prepare`
 
 The prepare build target request is sent from the client to the server to prepare the given list of build targets for editor functionality.
@@ -53,6 +87,7 @@ The server communicates during the initialize handshake whether this method is s
 
 - method: `buildTarget/prepare`
 - params: `PrepareParams`
+- result: `void`
 
 ```ts
 export interface PrepareParams {

Sources/BuildServerProtocol/CMakeLists.txt

@@ -2,6 +2,7 @@ add_library(BuildServerProtocol STATIC
   Messages.swift
 
   Messages/BuildShutdownRequest.swift
+  Messages/BuildTargetOutputPathsRequest.swift
   Messages/BuildTargetPrepareRequest.swift
   Messages/BuildTargetSourcesRequest.swift
   Messages/InitializeBuildRequest.swift

Sources/BuildServerProtocol/Messages.swift

@@ -18,6 +18,7 @@ import LanguageServerProtocol
 
 fileprivate let requestTypes: [_RequestType.Type] = [
   BuildShutdownRequest.self,
+  BuildTargetOutputPathsRequest.self,
   BuildTargetPrepareRequest.self,
   BuildTargetSourcesRequest.self,
   CreateWorkDoneProgressRequest.self,

Sources/BuildServerProtocol/Messages/BuildTargetOutputPathsRequest.swift

@@ -0,0 +1,54 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2024 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#if compiler(>=6)
+public import LanguageServerProtocol
+#else
+import LanguageServerProtocol
+#endif
+
+/// For all the source files in this target, the output paths that are used during indexing, ie. the
+/// `-index-unit-output-path` for the file, if it is specified in the compiler arguments or the file that is passed as
+/// `-o`, if `-index-unit-output-path` is not specified.
+public struct BuildTargetOutputPathsRequest: RequestType, Equatable, Hashable {
+  public static let method: String = "buildTarget/outputPaths"
+
+  public typealias Response = BuildTargetOutputPathsResponse
+
+  /// A list of build targets to get the output paths for.
+  public var targets: [BuildTargetIdentifier]
+
+  public init(targets: [BuildTargetIdentifier]) {
+    self.targets = targets
+  }
+}
+
+public struct BuildTargetOutputPathsItem: Codable, Sendable {
+  /// The target these output file paths are for.
+  public var target: BuildTargetIdentifier
+
+  /// The output paths for all source files in this target.
+  public var outputPaths: [String]
+
+  public init(target: BuildTargetIdentifier, outputPaths: [String]) {
+    self.target = target
+    self.outputPaths = outputPaths
+  }
+}
+
+public struct BuildTargetOutputPathsResponse: ResponseType {
+  public var items: [BuildTargetOutputPathsItem]
+
+  public init(items: [BuildTargetOutputPathsItem]) {
+    self.items = items
+  }
+}

Sources/BuildServerProtocol/Messages/InitializeBuildRequest.swift

@@ -273,15 +273,19 @@ public struct SourceKitInitializeBuildResponseData: LSPAnyCodable, Codable, Send
   /// The path at which SourceKit-LSP can store its index database, aggregating data from `indexStorePath`
   public var indexStorePath: String?
 
-  /// The files to watch for changes.
-  public var watchers: [FileSystemWatcher]?
+  /// Whether the server implements the `buildTarget/outputPaths` request.
+  public var outputPathsProvider: Bool?
 
   /// Whether the build server supports the `buildTarget/prepare` request.
   public var prepareProvider: Bool?
 
   /// Whether the server implements the `textDocument/sourceKitOptions` request.
   public var sourceKitOptionsProvider: Bool?
 
+  /// The files to watch for changes.
+  public var watchers: [FileSystemWatcher]?
+
+  @available(*, deprecated, message: "Use initializer with alphabetical order of parameters")
   public init(
     indexDatabasePath: String? = nil,
     indexStorePath: String? = nil,
@@ -296,22 +300,41 @@ public struct SourceKitInitializeBuildResponseData: LSPAnyCodable, Codable, Send
     self.sourceKitOptionsProvider = sourceKitOptionsProvider
   }
 
+  public init(
+    indexDatabasePath: String? = nil,
+    indexStorePath: String? = nil,
+    outputPathsProvider: Bool? = nil,
+    prepareProvider: Bool? = nil,
+    sourceKitOptionsProvider: Bool? = nil,
+    watchers: [FileSystemWatcher]? = nil
+  ) {
+    self.indexDatabasePath = indexDatabasePath
+    self.indexStorePath = indexStorePath
+    self.outputPathsProvider = outputPathsProvider
+    self.prepareProvider = prepareProvider
+    self.sourceKitOptionsProvider = sourceKitOptionsProvider
+    self.watchers = watchers
+  }
+
   public init?(fromLSPDictionary dictionary: [String: LanguageServerProtocol.LSPAny]) {
     if case .string(let indexDatabasePath) = dictionary[CodingKeys.indexDatabasePath.stringValue] {
       self.indexDatabasePath = indexDatabasePath
     }
     if case .string(let indexStorePath) = dictionary[CodingKeys.indexStorePath.stringValue] {
       self.indexStorePath = indexStorePath
     }
-    if let watchers = dictionary[CodingKeys.watchers.stringValue] {
-      self.watchers = [FileSystemWatcher](fromLSPArray: watchers)
+    if case .bool(let outputPathsProvider) = dictionary[CodingKeys.outputPathsProvider.stringValue] {
+      self.outputPathsProvider = outputPathsProvider
     }
     if case .bool(let prepareProvider) = dictionary[CodingKeys.prepareProvider.stringValue] {
       self.prepareProvider = prepareProvider
     }
     if case .bool(let sourceKitOptionsProvider) = dictionary[CodingKeys.sourceKitOptionsProvider.stringValue] {
       self.sourceKitOptionsProvider = sourceKitOptionsProvider
     }
+    if let watchers = dictionary[CodingKeys.watchers.stringValue] {
+      self.watchers = [FileSystemWatcher](fromLSPArray: watchers)
+    }
   }
 
   public func encodeToLSPAny() -> LanguageServerProtocol.LSPAny {
@@ -322,15 +345,18 @@ public struct SourceKitInitializeBuildResponseData: LSPAnyCodable, Codable, Send
     if let indexStorePath {
       result[CodingKeys.indexStorePath.stringValue] = .string(indexStorePath)
     }
-    if let watchers {
-      result[CodingKeys.watchers.stringValue] = watchers.encodeToLSPAny()
+    if let outputPathsProvider {
+      result[CodingKeys.outputPathsProvider.stringValue] = .bool(outputPathsProvider)
     }
     if let prepareProvider {
       result[CodingKeys.prepareProvider.stringValue] = .bool(prepareProvider)
     }
     if let sourceKitOptionsProvider {
       result[CodingKeys.sourceKitOptionsProvider.stringValue] = .bool(sourceKitOptionsProvider)
     }
+    if let watchers {
+      result[CodingKeys.watchers.stringValue] = watchers.encodeToLSPAny()
+    }
     return .dictionary(result)
   }
 }

Sources/BuildSystemIntegration/BuildSystemManager.swift

@@ -379,6 +379,8 @@ package actor BuildSystemManager: QueueBasedMessageHandler {
 
   private var cachedTargetSources = RequestCache<BuildTargetSourcesRequest>()
 
+  private var cachedTargetOutputPaths = RequestCache<BuildTargetOutputPathsRequest>()
+
   /// `SourceFilesAndDirectories` is a global property that only gets reset when the build targets change and thus
   /// has no real key.
   private struct SourceFilesAndDirectoriesKey: Hashable {}
@@ -624,6 +626,13 @@ package actor BuildSystemManager: QueueBasedMessageHandler {
       }
       return !updatedTargets.intersection(cacheKey.targets).isEmpty
     }
+    self.cachedTargetOutputPaths.clear(isolation: self) { cacheKey in
+      guard let updatedTargets else {
+        // All targets might have changed
+        return true
+      }
+      return !updatedTargets.isDisjoint(with: cacheKey.targets)
+    }
     self.cachedSourceFilesAndDirectories.clearAll(isolation: self)
 
     await delegate?.buildTargetsChanged(notification.changes)
@@ -1158,6 +1167,42 @@ package actor BuildSystemManager: QueueBasedMessageHandler {
     return response.items
   }
 
+  /// Return the output paths for all source files known to the build server.
+  ///
+  /// See `BuildTargetOutputPathsRequest` for details.
+  package func outputPathInAllTargets() async throws -> [String] {
+    return try await outputPaths(in: Set(buildTargets().map(\.key)))
+  }
+
+  /// For all source files in the given targets, return their output file paths.
+  ///
+  /// See `BuildTargetOutputPathsRequest` for details.
+  package func outputPaths(in targets: Set<BuildTargetIdentifier>) async throws -> [String] {
+    guard let buildSystemAdapter = await buildSystemAdapterAfterInitialized, !targets.isEmpty else {
+      return []
+    }
+
+    let request = BuildTargetOutputPathsRequest(targets: targets.sorted { $0.uri.stringValue < $1.uri.stringValue })
+
+    // If we have a cached request for a superset of the targets, serve the result from that cache entry.
+    let fromSuperset = await orLog("Getting output paths from superset request") {
+      try await cachedTargetOutputPaths.getDerived(
+        isolation: self,
+        request,
+        canReuseKey: { targets.isSubset(of: $0.targets) },
+        transform: { BuildTargetOutputPathsResponse(items: $0.items.filter { targets.contains($0.target) }) }
+      )
+    }
+    if let fromSuperset {
+      return fromSuperset.items.flatMap(\.outputPaths)
+    }
+
+    let response = try await cachedTargetOutputPaths.get(request, isolation: self) { request in
+      try await buildSystemAdapter.send(request)
+    }
+    return response.items.flatMap(\.outputPaths)
+  }
+
   /// Returns all source files in the project.
   ///
   /// - SeeAlso: Comment in `sourceFilesAndDirectories` for a definition of what `buildable` means.

Sources/BuildSystemIntegration/BuildSystemMessageDependencyTracker.swift

@@ -90,6 +90,8 @@ package enum BuildSystemMessageDependencyTracker: QueueBasedMessageHandlerDepend
     switch request {
     case is BuildShutdownRequest:
       self = .stateChange
+    case is BuildTargetOutputPathsRequest:
+      self = .stateRead
     case is BuildTargetPrepareRequest:
       self = .stateRead
     case is BuildTargetSourcesRequest:

Sources/BuildSystemIntegration/BuiltInBuildSystem.swift

@@ -44,16 +44,19 @@ package protocol BuiltInBuildSystem: AnyObject, Sendable {
   /// The path to put the index database, if any.
   var indexDatabasePath: URL? { get async }
 
-  /// Whether the build system is capable of preparing a target for indexing, ie. if the `prepare` methods has been
-  /// implemented.
-  var supportsPreparation: Bool { get }
+  /// Whether the build system is capable of preparing a target for indexing and determining the output paths for the
+  /// target, ie. whether the `prepare` and `buildTargetOutputPaths` methods have been implemented.
+  var supportsPreparationAndOutputPaths: Bool { get }
 
   /// Returns all targets in the build system
   func buildTargets(request: WorkspaceBuildTargetsRequest) async throws -> WorkspaceBuildTargetsResponse
 
   /// Returns all the source files in the given targets
   func buildTargetSources(request: BuildTargetSourcesRequest) async throws -> BuildTargetSourcesResponse
 
+  /// Returns all the output paths for the source files in the given targets.
+  func buildTargetOutputPaths(request: BuildTargetOutputPathsRequest) async throws -> BuildTargetOutputPathsResponse
+
   /// Called when files in the project change.
   func didChangeWatchedFiles(notification: OnWatchedFilesDidChangeNotification) async
 

Sources/BuildSystemIntegration/BuiltInBuildSystemAdapter.swift

@@ -100,9 +100,10 @@ actor BuiltInBuildSystemAdapter: QueueBasedMessageHandler {
         indexStorePath: await orLog("getting index store file path") {
           try await underlyingBuildSystem.indexStorePath?.filePath
         },
-        watchers: await underlyingBuildSystem.fileWatchers,
-        prepareProvider: underlyingBuildSystem.supportsPreparation,
-        sourceKitOptionsProvider: true
+        outputPathsProvider: underlyingBuildSystem.supportsPreparationAndOutputPaths,
+        prepareProvider: underlyingBuildSystem.supportsPreparationAndOutputPaths,
+        sourceKitOptionsProvider: true,
+        watchers: await underlyingBuildSystem.fileWatchers
       ).encodeToLSPAny()
     )
   }
@@ -130,6 +131,8 @@ actor BuiltInBuildSystemAdapter: QueueBasedMessageHandler {
     switch request {
     case let request as RequestAndReply<BuildShutdownRequest>:
       await request.reply { VoidResponse() }
+    case let request as RequestAndReply<BuildTargetOutputPathsRequest>:
+      await request.reply { try await underlyingBuildSystem.buildTargetOutputPaths(request: request.params) }
     case let request as RequestAndReply<BuildTargetPrepareRequest>:
       await request.reply { try await underlyingBuildSystem.prepare(request: request.params) }
     case let request as RequestAndReply<BuildTargetSourcesRequest>:

Sources/BuildSystemIntegration/FixedCompilationDatabaseBuildSystem.swift

@@ -66,7 +66,7 @@ package actor FixedCompilationDatabaseBuildSystem: BuiltInBuildSystem {
     indexStorePath?.deletingLastPathComponent().appendingPathComponent("IndexDatabase")
   }
 
-  package nonisolated var supportsPreparation: Bool { false }
+  package nonisolated var supportsPreparationAndOutputPaths: Bool { false }
 
   private static func parseCompileFlags(at configPath: URL) throws -> [String] {
     let fileContents: String = try String(contentsOf: configPath, encoding: .utf8)
@@ -121,7 +121,13 @@ package actor FixedCompilationDatabaseBuildSystem: BuiltInBuildSystem {
   }
 
   package func prepare(request: BuildTargetPrepareRequest) async throws -> VoidResponse {
-    throw PrepareNotSupportedError()
+    throw ResponseError.methodNotFound(BuildTargetPrepareRequest.method)
+  }
+
+  package func buildTargetOutputPaths(
+    request: BuildTargetOutputPathsRequest
+  ) async throws -> BuildTargetOutputPathsResponse {
+    throw ResponseError.methodNotFound(BuildTargetOutputPathsRequest.method)
   }
 
   package func sourceKitOptions(