Update BSP connection build server config lookup path

Resolves #1695

Adopt `<workspace_root>/.bsp` search locations in addition to
`<workspace_root>/`.

Author: Rajveer100

Sources/BuildSystemIntegration/ExternalBuildSystemAdapter.swift

@@ -52,6 +52,10 @@ struct ExecutableNotFoundError: Error {
   let executableName: String
 }
 
+enum BuildServerNotFoundError: Error {
+  case fileNotFound
+}
+
 private struct BuildServerConfig: Codable {
   /// The name of the build tool.
   let name: String
@@ -94,7 +98,7 @@ actor ExternalBuildSystemAdapter {
   private var lastRestart: Date?
 
   static package func projectRoot(for workspaceFolder: AbsolutePath, options: SourceKitLSPOptions) -> AbsolutePath? {
-    guard localFileSystem.isFile(workspaceFolder.appending(component: "buildServer.json")) else {
+    guard let _ = getConfigPath(for: workspaceFolder) else {
       return nil
     }
     return workspaceFolder
@@ -142,7 +146,10 @@ actor ExternalBuildSystemAdapter {
 
   /// Create a new JSONRPCConnection to the build server.
   private func createConnectionToBspServer() async throws -> JSONRPCConnection {
-    let configPath = projectRoot.appending(component: "buildServer.json")
+    guard let configPath = ExternalBuildSystemAdapter.getConfigPath(for: self.projectRoot) else {
+      throw BuildServerNotFoundError.fileNotFound
+    }
+
     let serverConfig = try BuildServerConfig.load(from: configPath)
     var serverPath = try AbsolutePath(validating: serverConfig.argv[0], relativeTo: projectRoot)
     var serverArgs = Array(serverConfig.argv[1...])
@@ -178,6 +185,48 @@ actor ExternalBuildSystemAdapter {
     ).connection
   }
 
+  private static func getConfigPath(for workspaceFolder: AbsolutePath? = nil) -> AbsolutePath? {
+    var buildServerConfigLocations: [AbsolutePath?] = []
+    if let workspaceFolder = workspaceFolder {
+      buildServerConfigLocations.append(workspaceFolder.appending(component: ".bsp"))
+    }
+
+    #if os(Windows)
+    let localAppDataPath = AbsolutePath(validatingOrNil: ProcessInfo.processInfo.environment["LOCALAPPDATA"])?.appending(component: "bsp")
+    let programDataPath = AbsolutePath(validatingOrNil: ProcessInfo.processInfo.environment["PROGRAMDATA"])?.appending(component: "bsp")
+
+    buildServerConfigLocations.append(contentsOf: [localAppDataPath, programDataPath])
+    #else
+    if let libraryUrl = FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask).first {
+      let libraryPath = AbsolutePath(validatingOrNil: libraryUrl.absoluteString)?.appending(component: "bsp")
+      buildServerConfigLocations.append(libraryPath)
+    }
+
+    let xdgDataHomePath = AbsolutePath(validatingOrNil: ProcessInfo.processInfo.environment["XDG_DATA_HOME"])?.appending(component: "bsp")
+    let xdgDataDirsPath = AbsolutePath(validatingOrNil: ProcessInfo.processInfo.environment["XDG_DATA_DIRS"])?.appending(component: "bsp")
+
+    buildServerConfigLocations.append(contentsOf: [xdgDataHomePath, xdgDataDirsPath])
+    #endif
+
+    for buildServerConfigLocation in buildServerConfigLocations {
+      guard let buildServerConfigLocation else {
+        continue
+      }
+      let fileManager = FileManager.default
+      do {
+        let items = try fileManager.contentsOfDirectory(atPath: buildServerConfigLocation.pathString)
+        let jsonFiles = items.filter { $0.hasSuffix(".json") }
+
+        if let configFilePath = jsonFiles.sorted().first {
+          return buildServerConfigLocation.appending(component: configFilePath)
+        }
+      } catch {
+        logger.error("Failed to read build server config file at \(buildServerConfigLocation): \(error)")
+      }
+    }
+    return nil
+  }
+
   /// Restart the BSP server after it has crashed.
   private func handleBspServerCrash() async throws {
     // Set `connectionToBuildServer` to `nil` to indicate that there is currently no BSP server running.

Sources/SKTestSupport/BuildServerTestProject.swift

@@ -59,7 +59,7 @@ package class BuildServerTestProject: MultiFileTestProject {
     testName: String = #function
   ) async throws {
     var files = files
-    files["buildServer.json"] = """
+    files[".bsp/buildServer.json"] = """
       {
         "name": "client name",
         "version": "10",

Tests/BuildSystemIntegrationTests/BuildServerBuildSystemTests.swift

@@ -303,4 +303,65 @@ final class BuildServerBuildSystemTests: XCTestCase {
     }
 
   }
+
+  func testBuildServerConfigPath() async throws {
+    let project = try await BuildServerTestProject(
+      // The file `test.json` is lexicographically greater than `buildServer.json`,
+      // so we should expect a valid response.
+      files: [
+        "Test.swift": """
+        #if DEBUG
+        #error("DEBUG SET")
+        #else
+        #error("DEBUG NOT SET")
+        #endif
+        """,
+        ".bsp/test.json": """
+          {
+          }
+        """
+      ],
+      buildServer: """
+        class BuildServer(AbstractBuildServer):
+          def workspace_build_targets(self, request: Dict[str, object]) -> Dict[str, object]:
+            return {
+              "targets": [
+                {
+                  "id": {"uri": "bsp://dummy"},
+                  "tags": [],
+                  "languageIds": [],
+                  "dependencies": [],
+                  "capabilities": {},
+                }
+              ]
+            }
+
+          def buildtarget_sources(self, request: Dict[str, object]) -> Dict[str, object]:
+            return {
+              "items": [
+                {
+                  "target": {"uri": "bsp://dummy"},
+                  "sources": [
+                    {"uri": "file://$TEST_DIR/Test.swift", "kind": 1, "generated": False}
+                  ],
+                }
+              ]
+            }
+
+          def textdocument_sourcekitoptions(self, request: Dict[str, object]) -> Dict[str, object]:
+            return {
+              "compilerArguments": ["$TEST_DIR/Test.swift", "-DDEBUG", $SDK_ARGS]
+            }
+        """
+    )
+
+    let (uri, _) = try project.openDocument("Test.swift")
+
+    try await repeatUntilExpectedResult {
+      let diags = try await project.testClient.send(
+        DocumentDiagnosticsRequest(textDocument: TextDocumentIdentifier(uri))
+      )
+      return diags.fullReport?.items.map(\.message) == ["DEBUG SET"]
+    }
+  }
 }