Use the InitializeRequest from BSP to communicate some static options between the build system and BuildSystemManager

Author: ahoppen

Sources/BuildServerProtocol/InitializeBuild.swift

@@ -9,8 +9,17 @@
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 //===----------------------------------------------------------------------===//
+
 import LanguageServerProtocol
 
+public struct InitializeBuildRequestDataKind: RawRepresentable, Hashable, Codable, Sendable {
+  public let rawValue: String
+
+  public init(rawValue: String) {
+    self.rawValue = rawValue
+  }
+}
+
 /// Like the language server protocol, the initialize request is sent
 /// as the first request from the client to the server. If the server
 /// receives a request or notification before the initialize request
@@ -25,9 +34,9 @@ import LanguageServerProtocol
 /// Until the server has responded to the initialize request with an
 /// InitializeBuildResult, the client must not send any additional
 /// requests or notifications to the server.
-public struct InitializeBuild: RequestType, Hashable {
+public struct InitializeBuildRequest: RequestType, Hashable {
   public static let method: String = "build/initialize"
-  public typealias Response = InitializeBuildResult
+  public typealias Response = InitializeBuildResponse
 
   /// Name of the client
   public var displayName: String
@@ -44,18 +53,28 @@ public struct InitializeBuild: RequestType, Hashable {
   /// The capabilities of the client
   public var capabilities: BuildClientCapabilities
 
+  /// Kind of data to expect in the `data` field. If this field is not set, the kind of data is not specified. */
+  public var dataKind: InitializeBuildRequestDataKind?
+
+  /// Additional metadata about the client
+  public var data: LSPAny?
+
   public init(
     displayName: String,
     version: String,
     bspVersion: String,
     rootUri: URI,
-    capabilities: BuildClientCapabilities
+    capabilities: BuildClientCapabilities,
+    dataKind: InitializeBuildRequestDataKind? = nil,
+    data: LSPAny? = nil
   ) {
     self.displayName = displayName
     self.version = version
     self.bspVersion = bspVersion
     self.rootUri = rootUri
     self.capabilities = capabilities
+    self.dataKind = dataKind
+    self.data = data
   }
 }
 
@@ -66,12 +85,67 @@ public struct BuildClientCapabilities: Codable, Hashable, Sendable {
   /// languages than those that appear in this list.
   public var languageIds: [Language]
 
-  public init(languageIds: [Language]) {
+  /// Mirror capability to BuildServerCapabilities.jvmCompileClasspathProvider
+  /// The client will request classpath via `buildTarget/jvmCompileClasspath` so
+  /// it's safe to return classpath in ScalacOptionsItem empty. */
+  public var jvmCompileClasspathReceiver: Bool?
+
+  public init(languageIds: [Language], jvmCompileClasspathReceiver: Bool? = nil) {
     self.languageIds = languageIds
+    self.jvmCompileClasspathReceiver = jvmCompileClasspathReceiver
   }
 }
 
-public struct InitializeBuildResult: ResponseType, Hashable {
+public struct InitializeBuildResponseDataKind: RawRepresentable, Hashable, Codable, Sendable {
+  public let rawValue: String
+
+  public init(rawValue: String) {
+    self.rawValue = rawValue
+  }
+
+  /// `data` field must contain a `SourceKitInitializeBuildResponseData` object.
+  public static let sourceKit = InitializeBuildResponseDataKind(rawValue: "sourcekit")
+}
+
+public struct SourceKitInitializeBuildResponseData: LSPAnyCodable, Codable, Sendable {
+  public var indexDatabasePath: String?
+  public var indexStorePath: String?
+  public var supportsPreparation: Bool?
+
+  public init(indexDatabasePath: String?, indexStorePath: String?, supportsPreparation: Bool?) {
+    self.indexDatabasePath = indexDatabasePath
+    self.indexStorePath = indexStorePath
+    self.supportsPreparation = supportsPreparation
+  }
+
+  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 case .bool(let supportsPreparation) = dictionary[CodingKeys.supportsPreparation.stringValue] {
+      self.supportsPreparation = supportsPreparation
+    }
+  }
+
+  public func encodeToLSPAny() -> LanguageServerProtocol.LSPAny {
+    var result: [String: LSPAny] = [:]
+    if let indexDatabasePath {
+      result[CodingKeys.indexDatabasePath.stringValue] = .string(indexDatabasePath)
+    }
+    if let indexStorePath {
+      result[CodingKeys.indexStorePath.stringValue] = .string(indexStorePath)
+    }
+    if let supportsPreparation {
+      result[CodingKeys.supportsPreparation.stringValue] = .bool(supportsPreparation)
+    }
+    return .dictionary(result)
+  }
+}
+
+public struct InitializeBuildResponse: ResponseType, Hashable {
   /// Name of the server
   public var displayName: String
 
@@ -84,6 +158,9 @@ public struct InitializeBuildResult: ResponseType, Hashable {
   /// The capabilities of the build server
   public var capabilities: BuildServerCapabilities
 
+  /// Kind of data to expect in the `data` field. If this field is not set, the kind of data is not specified.
+  public var dataKind: InitializeBuildResponseDataKind?
+
   /// Optional metadata about the server
   public var data: LSPAny?
 
@@ -92,41 +169,103 @@ public struct InitializeBuildResult: ResponseType, Hashable {
     version: String,
     bspVersion: String,
     capabilities: BuildServerCapabilities,
+    dataKind: InitializeBuildResponseDataKind? = nil,
     data: LSPAny? = nil
   ) {
     self.displayName = displayName
     self.version = version
     self.bspVersion = bspVersion
     self.capabilities = capabilities
+    self.dataKind = dataKind
     self.data = data
   }
 }
 
 public struct BuildServerCapabilities: Codable, Hashable, Sendable {
   /// The languages the server supports compilation via method buildTarget/compile.
-  public var compileProvider: CompileProvider? = nil
+  public var compileProvider: CompileProvider?
 
   /// The languages the server supports test execution via method buildTarget/test
-  public var testProvider: TestProvider? = nil
+  public var testProvider: TestProvider?
 
   /// The languages the server supports run via method buildTarget/run
-  public var runProvider: RunProvider? = nil
+  public var runProvider: RunProvider?
+
+  /// The languages the server supports debugging via method debugSession/start.
+  public var debugProvider: DebugProvider?
 
   /// The server can provide a list of targets that contain a
   /// single text document via the method buildTarget/inverseSources
-  public var inverseSourcesProvider: Bool? = nil
+  public var inverseSourcesProvider: Bool?
 
   /// The server provides sources for library dependencies
   /// via method buildTarget/dependencySources
-  public var dependencySourcesProvider: Bool? = nil
+  public var dependencySourcesProvider: Bool?
 
   /// The server provides all the resource dependencies
   /// via method buildTarget/resources
-  public var resourcesProvider: Bool? = nil
+  public var resourcesProvider: Bool?
+
+  /// The server provides all output paths
+  /// via method buildTarget/outputPaths
+  public var outputPathsProvider: Bool?
 
   /// The server sends notifications to the client on build
-  /// target change events via buildTarget/didChange
-  public var buildTargetChangedProvider: Bool? = nil
+  /// target change events via `buildTarget/didChange`
+  public var buildTargetChangedProvider: Bool?
+
+  /// The server can respond to `buildTarget/jvmRunEnvironment` requests with the
+  /// necessary information required to launch a Java process to run a main class.
+  public var jvmRunEnvironmentProvider: Bool?
+
+  /// The server can respond to `buildTarget/jvmTestEnvironment` requests with the
+  /// necessary information required to launch a Java process for testing or
+  /// debugging.
+  public var jvmTestEnvironmentProvider: Bool?
+
+  /// The server can respond to `workspace/cargoFeaturesState` and
+  /// `setCargoFeatures` requests. In other words, supports Cargo Features extension.
+  public var cargoFeaturesProvider: Bool?
+
+  /// Reloading the build state through workspace/reload is supported
+  public var canReload: Bool?
+
+  /// The server can respond to `buildTarget/jvmCompileClasspath` requests with the
+  /// necessary information about the target's classpath.
+  public var jvmCompileClasspathProvider: Bool?
+
+  public init(
+    compileProvider: CompileProvider? = nil,
+    testProvider: TestProvider? = nil,
+    runProvider: RunProvider? = nil,
+    debugProvider: DebugProvider? = nil,
+    inverseSourcesProvider: Bool? = nil,
+    dependencySourcesProvider: Bool? = nil,
+    resourcesProvider: Bool? = nil,
+    outputPathsProvider: Bool? = nil,
+    buildTargetChangedProvider: Bool? = nil,
+    jvmRunEnvironmentProvider: Bool? = nil,
+    jvmTestEnvironmentProvider: Bool? = nil,
+    cargoFeaturesProvider: Bool? = nil,
+    canReload: Bool? = nil,
+    jvmCompileClasspathProvider: Bool? = nil
+  ) {
+    self.compileProvider = compileProvider
+    self.testProvider = testProvider
+    self.runProvider = runProvider
+    self.debugProvider = debugProvider
+    self.inverseSourcesProvider = inverseSourcesProvider
+    self.dependencySourcesProvider = dependencySourcesProvider
+    self.resourcesProvider = resourcesProvider
+    self.outputPathsProvider = outputPathsProvider
+    self.buildTargetChangedProvider = buildTargetChangedProvider
+    self.jvmRunEnvironmentProvider = jvmRunEnvironmentProvider
+    self.jvmTestEnvironmentProvider = jvmTestEnvironmentProvider
+    self.cargoFeaturesProvider = cargoFeaturesProvider
+    self.canReload = canReload
+    self.jvmCompileClasspathProvider = jvmCompileClasspathProvider
+  }
+
 }
 
 public struct CompileProvider: Codable, Hashable, Sendable {
@@ -153,6 +292,14 @@ public struct TestProvider: Codable, Hashable, Sendable {
   }
 }
 
+public struct DebugProvider: Codable, Hashable, Sendable {
+  public var languageIds: [Language]
+
+  public init(languageIds: [Language]) {
+    self.languageIds = languageIds
+  }
+}
+
 public struct InitializedBuildNotification: NotificationType {
   public static let method: String = "build/initialized"
 

Sources/BuildServerProtocol/Messages.swift

@@ -15,7 +15,7 @@ fileprivate let requestTypes: [_RequestType.Type] = [
   BuildTargetOutputPaths.self,
   BuildTargetsRequest.self,
   BuildTargetSourcesRequest.self,
-  InitializeBuild.self,
+  InitializeBuildRequest.self,
   InverseSourcesRequest.self,
   RegisterForChanges.self,
   ShutdownBuild.self,

Sources/BuildSystemIntegration/BuildServerBuildSystem.swift

@@ -158,7 +158,7 @@ package actor BuildServerBuildSystem: MessageHandler {
       Language.swift,
     ]
 
-    let initializeRequest = InitializeBuild(
+    let initializeRequest = InitializeBuildRequest(
       displayName: "SourceKit-LSP",
       version: "1.0",
       bspVersion: "2.0",

Sources/BuildSystemIntegration/BuildSystemManager.swift

@@ -73,7 +73,7 @@ package actor BuildSystemManager: BuiltInBuildSystemAdapterDelegate {
   /// The files for which the delegate has requested change notifications, ie.
   /// the files for which the delegate wants to get `filesDependenciesUpdated`
   /// callbacks if the file's build settings.
-  var watchedFiles: [DocumentURI: (mainFile: DocumentURI, language: Language)] = [:]
+  private var watchedFiles: [DocumentURI: (mainFile: DocumentURI, language: Language)] = [:]
 
   /// The underlying primary build system.
   ///
@@ -82,10 +82,10 @@ package actor BuildSystemManager: BuiltInBuildSystemAdapterDelegate {
 
   /// The fallback build system. If present, used when the `buildSystem` is not
   /// set or cannot provide settings.
-  let fallbackBuildSystem: FallbackBuildSystem
+  private let fallbackBuildSystem: FallbackBuildSystem
 
   /// Provider of file to main file mappings.
-  var mainFilesProvider: MainFilesProvider?
+  private var mainFilesProvider: MainFilesProvider?
 
   /// Build system delegate that will receive notifications about setting changes, etc.
   private weak var delegate: BuildSystemManagerDelegate?
@@ -97,6 +97,9 @@ package actor BuildSystemManager: BuiltInBuildSystemAdapterDelegate {
 
   private let options: SourceKitLSPOptions
 
+  /// A task that stores the result of the `build/initialize` request once it is received.
+  private var initializeResult: Task<InitializeBuildResponse?, Never>!
+
   /// Debounces calls to `delegate.filesDependenciesUpdated`.
   ///
   /// This is to ensure we don't call `filesDependenciesUpdated` for the same file multiple time if the client does not
@@ -120,9 +123,19 @@ package actor BuildSystemManager: BuiltInBuildSystemAdapterDelegate {
   /// was found.
   package let projectRoot: AbsolutePath?
 
-  package var supportsPreparation: Bool {
+  /// The `SourceKitInitializeBuildResponseData` received from the `build/initialize` request, if any.
+  package var initializationData: SourceKitInitializeBuildResponseData? {
     get async {
-      return await buildSystem?.underlyingBuildSystem.supportsPreparation ?? false
+      guard let initializeResult = await initializeResult.value else {
+        return nil
+      }
+      guard initializeResult.dataKind == nil || initializeResult.dataKind == .sourceKit else {
+        return nil
+      }
+      guard case .dictionary(let data) = initializeResult.data else {
+        return nil
+      }
+      return SourceKitInitializeBuildResponseData(fromLSPDictionary: data)
     }
   }
 
@@ -161,6 +174,26 @@ package actor BuildSystemManager: BuiltInBuildSystemAdapterDelegate {
       }
       await delegate.filesDependenciesUpdated(changedWatchedFiles)
     }
+    initializeResult = Task { () -> InitializeBuildResponse? in
+      guard let buildSystem else {
+        return nil
+      }
+      guard let buildSystemKind else {
+        logger.fault("Created build system without a build system kind?")
+        return nil
+      }
+      return await orLog("Initializing build system") {
+        try await buildSystem.send(
+          InitializeBuildRequest(
+            displayName: "SourceKit-LSP",
+            version: "unknown",
+            bspVersion: "2.2.0",
+            rootUri: URI(buildSystemKind.projectRoot.asURL),
+            capabilities: BuildClientCapabilities(languageIds: [.c, .cpp, .objective_c, .objective_cpp, .swift])
+          )
+        )
+      }
+    }
   }
 
   package func filesDidChange(_ events: [FileEvent]) async {

Sources/BuildSystemIntegration/BuiltInBuildSystemAdapter.swift

@@ -121,6 +121,21 @@ package actor BuiltInBuildSystemAdapter: BuiltInBuildSystemMessageHandler {
     self.underlyingBuildSystem = buildSystem
   }
 
+  private func initialize(request: InitializeBuildRequest) async -> InitializeBuildResponse {
+    return InitializeBuildResponse(
+      displayName: "\(type(of: underlyingBuildSystem))",
+      version: "1.0.0",
+      bspVersion: "2.2.0",
+      capabilities: BuildServerCapabilities(),
+      dataKind: .sourceKit,
+      data: SourceKitInitializeBuildResponseData(
+        indexDatabasePath: await underlyingBuildSystem.indexDatabasePath?.pathString,
+        indexStorePath: await underlyingBuildSystem.indexStorePath?.pathString,
+        supportsPreparation: underlyingBuildSystem.supportsPreparation
+      ).encodeToLSPAny()
+    )
+  }
+
   package func send<R: RequestType>(_ request: R) async throws -> R.Response {
     logger.info(
       """
@@ -142,6 +157,8 @@ package actor BuiltInBuildSystemAdapter: BuiltInBuildSystemMessageHandler {
       return try await handle(request, underlyingBuildSystem.buildTargets)
     case let request as BuildTargetSourcesRequest:
       return try await handle(request, underlyingBuildSystem.buildTargetSources)
+    case let request as InitializeBuildRequest:
+      return try await handle(request, self.initialize)
     case let request as InverseSourcesRequest:
       return try await handle(request, underlyingBuildSystem.inverseSources)
     case let request as PrepareTargetsRequest: