Allow workspace options to affect build system search

There were a few places that options only took place *after* determining
a build system, even though we have multiple that impact the search (eg.
`defaultBuildSystem` and `searchPaths`).

Additionally track project root and configuration paths separately, so
that when searching for implicit workspaces we can make sure to skip
creating duplicates.

Author: bnbarham

Sources/BuildSystemIntegration/BuildSystemManager.swift

@@ -142,8 +142,7 @@ private enum BuildSystemAdapter {
 }
 
 private extension BuildSystemSpec {
-  private static func createBuiltInBuildSystemAdapter(
-    projectRoot: URL,
+  private func createBuiltInBuildSystemAdapter(
     messagesToSourceKitLSPHandler: any MessageHandler,
     buildSystemTestHooks: BuildSystemTestHooks,
     _ createBuildSystem: @Sendable (_ connectionToSourceKitLSP: any Connection) async throws -> BuiltInBuildSystem?
@@ -186,6 +185,7 @@ private extension BuildSystemSpec {
       let buildSystem = await orLog("Creating external build system") {
         try await ExternalBuildSystemAdapter(
           projectRoot: projectRoot,
+          configPath: configPath,
           messagesToSourceKitLSPHandler: messagesToSourceKitLSPHandler
         )
       }
@@ -196,23 +196,18 @@ private extension BuildSystemSpec {
       logger.log("Created external build server at \(projectRoot)")
       return .external(buildSystem)
     case .compilationDatabase:
-      return await Self.createBuiltInBuildSystemAdapter(
-        projectRoot: projectRoot,
+      return await createBuiltInBuildSystemAdapter(
         messagesToSourceKitLSPHandler: messagesToSourceKitLSPHandler,
         buildSystemTestHooks: testHooks
       ) { connectionToSourceKitLSP in
-        CompilationDatabaseBuildSystem(
-          projectRoot: projectRoot,
-          searchPaths: (options.compilationDatabaseOrDefault.searchPaths ?? []).compactMap {
-            try? RelativePath(validating: $0)
-          },
+        try CompilationDatabaseBuildSystem(
+          configPath: configPath,
           connectionToSourceKitLSP: connectionToSourceKitLSP
         )
       }
     case .swiftPM:
       #if canImport(PackageModel)
-      return await Self.createBuiltInBuildSystemAdapter(
-        projectRoot: projectRoot,
+      return await createBuiltInBuildSystemAdapter(
         messagesToSourceKitLSPHandler: messagesToSourceKitLSPHandler,
         buildSystemTestHooks: testHooks
       ) { connectionToSourceKitLSP in
@@ -228,12 +223,11 @@ private extension BuildSystemSpec {
       return nil
       #endif
     case .testBuildSystem:
-      return await Self.createBuiltInBuildSystemAdapter(
-        projectRoot: projectRoot,
+      return await createBuiltInBuildSystemAdapter(
         messagesToSourceKitLSPHandler: messagesToSourceKitLSPHandler,
         buildSystemTestHooks: testHooks
       ) { connectionToSourceKitLSP in
-        TestBuildSystem(projectRoot: projectRoot, connectionToSourceKitLSP: connectionToSourceKitLSP)
+        TestBuildSystem(configPath: configPath, connectionToSourceKitLSP: connectionToSourceKitLSP)
       }
     }
   }
@@ -248,13 +242,14 @@ package actor BuildSystemManager: QueueBasedMessageHandler {
 
   package let messageHandlingQueue = AsyncQueue<BuildSystemMessageDependencyTracker>()
 
-  /// The root of the project that this build system manages.
+  /// The path to the main configuration file (or directory) that this build system manages.
   ///
-  /// For example, in SwiftPM packages this is the folder containing Package.swift.
-  /// For compilation databases it is the root folder based on which the compilation database was found.
+  /// Some examples:
+  ///   - The path to `Package.swift` for SwiftPM packages
+  ///   - The path to `compile_commands.json` for a JSON compilation database
   ///
   /// `nil` if the `BuildSystemManager` does not have an underlying build system.
-  package let projectRoot: URL?
+  package let configPath: URL?
 
   /// The files for which the delegate has requested change notifications, ie. the files for which the delegate wants to
   /// get `fileBuildSettingsChanged` and `filesDependenciesUpdated` callbacks.
@@ -372,7 +367,7 @@ package actor BuildSystemManager: QueueBasedMessageHandler {
     self.toolchainRegistry = toolchainRegistry
     self.options = options
     self.connectionToClient = connectionToClient
-    self.projectRoot = buildSystemSpec?.projectRoot
+    self.configPath = buildSystemSpec?.configPath
     self.buildSystemAdapter = await buildSystemSpec?.createBuildSystemAdapter(
       toolchainRegistry: toolchainRegistry,
       options: options,
@@ -426,6 +421,7 @@ package actor BuildSystemManager: QueueBasedMessageHandler {
         logger.log("Launched a legacy BSP server. Using push-based build settings model.")
         let legacyBuildServer = await LegacyBuildServerBuildSystem(
           projectRoot: buildSystemSpec.projectRoot,
+          configPath: buildSystemSpec.configPath,
           initializationData: initializeResponse,
           externalBuildSystemAdapter
         )
@@ -693,7 +689,7 @@ package actor BuildSystemManager: QueueBasedMessageHandler {
       }
       if !filesAndDirectories.directories.isEmpty, let documentPathComponents = document.fileURL?.pathComponents {
         for (directory, (directoryPathComponents, info)) in filesAndDirectories.directories {
-          guard let directoryPathComponents, let directoryPath = directory.fileURL else {
+          guard let directoryPathComponents, directory.fileURL != nil else {
             continue
           }
           if isDescendant(documentPathComponents, of: directoryPathComponents) {

Sources/BuildSystemIntegration/BuiltInBuildSystem.swift

@@ -35,11 +35,6 @@ package struct PrepareNotSupportedError: Error, CustomStringConvertible {
 
 /// Provider of FileBuildSettings and other build-related information.
 package protocol BuiltInBuildSystem: AnyObject, Sendable {
-  /// The root of the project that this build system manages. For example, for SwiftPM packages, this is the folder
-  /// containing Package.swift. For compilation databases it is the root folder based on which the compilation database
-  /// was found.
-  var projectRoot: URL { get async }
-
   /// The files to watch for changes.
   var fileWatchers: [FileSystemWatcher] { get async }
 

Sources/BuildSystemIntegration/BuiltInBuildSystemAdapter.swift

@@ -35,11 +35,16 @@ package struct BuildSystemSpec {
 
   package var kind: Kind
 
+  /// The folder that best describes the root of the project that this build system handles.
   package var projectRoot: URL
 
-  package init(kind: BuildSystemSpec.Kind, projectRoot: URL) {
+  /// The main path that provides the build system configuration.
+  package var configPath: URL
+
+  package init(kind: BuildSystemSpec.Kind, projectRoot: URL, configPath: URL) {
     self.kind = kind
     self.projectRoot = projectRoot
+    self.configPath = configPath
   }
 }
 

Sources/BuildSystemIntegration/CompilationDatabase.swift

@@ -116,33 +116,20 @@ package protocol CompilationDatabase {
   var sourceItems: [SourceItem] { get }
 }
 
-/// Loads the compilation database located in `directory`, if one can be found in `additionalSearchPaths` or in the default search paths of "." and "build".
+/// Loads a compilation database from `file`.
 package func tryLoadCompilationDatabase(
-  directory: URL,
-  additionalSearchPaths: [RelativePath] = []
+  file: URL
 ) -> CompilationDatabase? {
-  let searchPaths =
-    additionalSearchPaths + [
-      // These default search paths match the behavior of `clangd`
-      try! RelativePath(validating: "."),
-      try! RelativePath(validating: "build"),
-    ]
-  return
-    searchPaths
-    .lazy
-    .map { directory.appending($0) }
-    .compactMap { searchPath in
-      orLog("Failed to load compilation database") { () -> CompilationDatabase? in
-        if let compDb = try JSONCompilationDatabase(directory: searchPath) {
-          return compDb
-        }
-        if let compDb = try FixedCompilationDatabase(directory: searchPath) {
-          return compDb
-        }
-        return nil
-      }
+  orLog("Failed to load compilation database") { () -> CompilationDatabase? in
+    switch file.lastPathComponent {
+    case JSONCompilationDatabase.dbName:
+      return try JSONCompilationDatabase(file: file)
+    case FixedCompilationDatabase.dbName:
+      return try FixedCompilationDatabase(file: file)
+    default:
+      return nil
     }
-    .first
+  }
 }
 
 /// Fixed clang-compatible compilation database (compile_flags.txt).
@@ -156,6 +143,8 @@ package func tryLoadCompilationDatabase(
 ///
 /// See https://clang.llvm.org/docs/JSONCompilationDatabase.html under Alternatives
 package struct FixedCompilationDatabase: CompilationDatabase, Equatable {
+  package static let dbName: String = "compile_flags.txt"
+
   private let fixedArgs: [String]
   private let directory: String
 
@@ -172,7 +161,7 @@ package struct FixedCompilationDatabase: CompilationDatabase, Equatable {
   /// Loads the compilation database located in `directory`, if any.
   /// - Returns: `nil` if `compile_flags.txt` was not found
   package init?(directory: URL) throws {
-    let path = directory.appendingPathComponent("compile_flags.txt")
+    let path = directory.appendingPathComponent(Self.dbName)
     try self.init(file: path)
   }
 
@@ -212,6 +201,8 @@ package struct FixedCompilationDatabase: CompilationDatabase, Equatable {
 ///
 /// See https://clang.llvm.org/docs/JSONCompilationDatabase.html
 package struct JSONCompilationDatabase: CompilationDatabase, Equatable, Codable {
+  package static let dbName: String = "compile_commands.json"
+
   private var pathToCommands: [DocumentURI: [Int]] = [:]
   private var commands: [CompilationDatabaseCompileCommand] = []
 
@@ -232,7 +223,7 @@ package struct JSONCompilationDatabase: CompilationDatabase, Equatable, Codable
   ///
   /// - Returns: `nil` if `compile_commands.json` was not found
   package init?(directory: URL) throws {
-    let path = directory.appendingPathComponent("compile_commands.json")
+    let path = directory.appendingPathComponent(Self.dbName)
     try self.init(file: path)
   }
 

Sources/BuildSystemIntegration/CompilationDatabaseBuildSystem.swift

@@ -18,6 +18,7 @@ package import LanguageServerProtocol
 import LanguageServerProtocolExtensions
 import SKLogging
 package import SKOptions
+import SwiftExtensions
 import ToolchainRegistry
 import TSCExtensions
 
@@ -30,6 +31,7 @@ import LanguageServerProtocol
 import LanguageServerProtocolExtensions
 import SKLogging
 import SKOptions
+import SwiftExtensions
 import ToolchainRegistry
 import TSCExtensions
 
@@ -59,13 +61,37 @@ fileprivate enum Cachable<Value> {
 /// A `BuildSystem` based on loading clang-compatible compilation database(s).
 ///
 /// Provides build settings from a `CompilationDatabase` found by searching a project. For now, only
-/// one compilation database, located at the project root.
+/// one compilation database located within the given seach paths (defaulting to the root or inside `build`).
 package actor CompilationDatabaseBuildSystem: BuiltInBuildSystem {
-  static package func projectRoot(for workspaceFolder: URL, options: SourceKitLSPOptions) -> URL? {
-    if tryLoadCompilationDatabase(directory: workspaceFolder) != nil {
-      return workspaceFolder
-    }
-    return nil
+  static package func searchForConfig(in workspaceFolder: URL, options: SourceKitLSPOptions) -> BuildSystemSpec? {
+    let searchPaths =
+      (options.compilationDatabaseOrDefault.searchPaths ?? []).compactMap {
+        try? RelativePath(validating: $0)
+      } + [
+        // These default search paths match the behavior of `clangd`
+        try! RelativePath(validating: "."),
+        try! RelativePath(validating: "build"),
+      ]
+
+    return
+      searchPaths
+      .lazy
+      .compactMap { searchPath in
+        let path = workspaceFolder.appending(searchPath)
+
+        let jsonPath = path.appendingPathComponent(JSONCompilationDatabase.dbName)
+        if FileManager.default.isFile(at: jsonPath) {
+          return BuildSystemSpec(kind: .compilationDatabase, projectRoot: workspaceFolder, configPath: jsonPath)
+        }
+
+        let fixedPath = path.appendingPathComponent(FixedCompilationDatabase.dbName)
+        if FileManager.default.isFile(at: fixedPath) {
+          return BuildSystemSpec(kind: .compilationDatabase, projectRoot: workspaceFolder, configPath: fixedPath)
+        }
+
+        return nil
+      }
+      .first
   }
 
   /// The compilation database.
@@ -78,14 +104,10 @@ package actor CompilationDatabaseBuildSystem: BuiltInBuildSystem {
   }
 
   private let connectionToSourceKitLSP: any Connection
-  private let searchPaths: [RelativePath]
 
-  package let projectRoot: URL
+  package let configPath: URL
 
-  package let fileWatchers: [FileSystemWatcher] = [
-    FileSystemWatcher(globPattern: "**/compile_commands.json", kind: [.create, .change, .delete]),
-    FileSystemWatcher(globPattern: "**/compile_flags.txt", kind: [.create, .change, .delete]),
-  ]
+  package let fileWatchers: [FileSystemWatcher]
 
   private var _indexStorePath: Cachable<URL?> = .noValue
   package var indexStorePath: URL? {
@@ -118,18 +140,20 @@ package actor CompilationDatabaseBuildSystem: BuiltInBuildSystem {
   package nonisolated var supportsPreparation: Bool { false }
 
   package init?(
-    projectRoot: URL,
-    searchPaths: [RelativePath],
+    configPath: URL,
     connectionToSourceKitLSP: any Connection
-  ) {
-    self.projectRoot = projectRoot
-    self.searchPaths = searchPaths
-    self.connectionToSourceKitLSP = connectionToSourceKitLSP
-    if let compdb = tryLoadCompilationDatabase(directory: projectRoot, additionalSearchPaths: searchPaths) {
+  ) throws {
+    if let compdb = tryLoadCompilationDatabase(file: configPath) {
       self.compdb = compdb
     } else {
       return nil
     }
+    self.connectionToSourceKitLSP = connectionToSourceKitLSP
+
+    self.configPath = configPath
+    self.fileWatchers = [
+      FileSystemWatcher(globPattern: try configPath.filePath, kind: [.change])
+    ]
   }
 
   package func buildTargets(request: WorkspaceBuildTargetsRequest) async throws -> WorkspaceBuildTargetsResponse {
@@ -182,7 +206,7 @@ package actor CompilationDatabaseBuildSystem: BuiltInBuildSystem {
 
   private func fileEventShouldTriggerCompilationDatabaseReload(event: FileEvent) -> Bool {
     switch event.uri.fileURL?.lastPathComponent {
-    case "compile_commands.json", "compile_flags.txt":
+    case JSONCompilationDatabase.dbName, FixedCompilationDatabase.dbName:
       return true
     default:
       return false
@@ -192,8 +216,7 @@ package actor CompilationDatabaseBuildSystem: BuiltInBuildSystem {
   /// The compilation database has been changed on disk.
   /// Reload it and notify the delegate about build setting changes.
   private func reloadCompilationDatabase() {
-    self.compdb = tryLoadCompilationDatabase(directory: projectRoot, additionalSearchPaths: searchPaths)
-
+    self.compdb = tryLoadCompilationDatabase(file: configPath)
     connectionToSourceKitLSP.send(OnBuildTargetDidChangeNotification(changes: nil))
   }
 }

Sources/BuildSystemIntegration/DetermineBuildSystem.swift

@@ -31,11 +31,13 @@ import struct TSCBasic.AbsolutePath
 #endif
 
 /// Determine which build system should be started to handle the given workspace folder and at which folder that build
-/// system's project root is (see `BuiltInBuildSystem.projectRoot(for:options:)`).
+/// system's project root is (see `BuiltInBuildSystem.projectRoot(for:options:)`). `onlyConsiderRoot` controls whether
+/// paths outside the root should be considered (eg. configuration files in the user's home directory).
 ///
 /// Returns `nil` if no build system can handle this workspace folder.
 package func determineBuildSystem(
   forWorkspaceFolder workspaceFolder: DocumentURI,
+  onlyConsiderRoot: Bool,
   options: SourceKitLSPOptions
 ) -> BuildSystemSpec? {
   var buildSystemPreference: [WorkspaceType] = [
@@ -49,24 +51,26 @@ package func determineBuildSystem(
     return nil
   }
   for buildSystemType in buildSystemPreference {
+    var spec: BuildSystemSpec? = nil
+
     switch buildSystemType {
     case .buildServer:
-      if let projectRoot = ExternalBuildSystemAdapter.projectRoot(for: workspaceFolderUrl, options: options) {
-        return BuildSystemSpec(kind: .buildServer, projectRoot: projectRoot)
-      }
+      spec = ExternalBuildSystemAdapter.searchForConfig(
+        in: workspaceFolderUrl,
+        onlyConsiderRoot: onlyConsiderRoot,
+        options: options
+      )
     case .compilationDatabase:
-      if let projectRoot = CompilationDatabaseBuildSystem.projectRoot(for: workspaceFolderUrl, options: options) {
-        return BuildSystemSpec(kind: .compilationDatabase, projectRoot: projectRoot)
-      }
+      spec = CompilationDatabaseBuildSystem.searchForConfig(in: workspaceFolderUrl, options: options)
     case .swiftPM:
       #if canImport(PackageModel)
-      if let projectRoot = SwiftPMBuildSystem.projectRoot(for: workspaceFolderUrl, options: options) {
-        return BuildSystemSpec(kind: .swiftPM, projectRoot: projectRoot)
-      }
-      #else
-      return nil
+      spec = SwiftPMBuildSystem.searchForConfig(in: workspaceFolderUrl, options: options)
       #endif
     }
+
+    if spec != nil {
+      return spec
+    }
   }
 
   return nil