Split build systems for JSON compilation database and fixed compilation database

I feel like the implementations are actually simpler if we split them. This will also allow us to add more advanced logic to the JSON compilation database build system in the future, such as inferring the toolchain from the compile command.

Author: ahoppen

Sources/BuildSystemIntegration/BuildSystemManager.swift

@@ -195,12 +195,22 @@ private extension BuildSystemSpec {
       }
       logger.log("Created external build server at \(projectRoot)")
       return .external(buildSystem)
-    case .compilationDatabase:
+    case .jsonCompilationDatabase:
       return await createBuiltInBuildSystemAdapter(
         messagesToSourceKitLSPHandler: messagesToSourceKitLSPHandler,
         buildSystemHooks: buildSystemHooks
       ) { connectionToSourceKitLSP in
-        try CompilationDatabaseBuildSystem(
+        try JSONCompilationDatabaseBuildSystem(
+          configPath: configPath,
+          connectionToSourceKitLSP: connectionToSourceKitLSP
+        )
+      }
+    case .fixedCompilationDatabase:
+      return await createBuiltInBuildSystemAdapter(
+        messagesToSourceKitLSPHandler: messagesToSourceKitLSPHandler,
+        buildSystemHooks: buildSystemHooks
+      ) { connectionToSourceKitLSP in
+        try FixedCompilationDatabaseBuildSystem(
           configPath: configPath,
           connectionToSourceKitLSP: connectionToSourceKitLSP
         )

Sources/BuildSystemIntegration/BuiltInBuildSystemAdapter.swift

@@ -28,7 +28,8 @@ import Foundation
 package struct BuildSystemSpec {
   package enum Kind {
     case buildServer
-    case compilationDatabase
+    case jsonCompilationDatabase
+    case fixedCompilationDatabase
     case swiftPM
     case injected(BuildSystemInjector)
   }

Sources/BuildSystemIntegration/CMakeLists.txt

@@ -9,11 +9,12 @@ add_library(BuildSystemIntegration STATIC
   BuiltInBuildSystem.swift
   BuiltInBuildSystemAdapter.swift
   CompilationDatabase.swift
-  CompilationDatabaseBuildSystem.swift
   DetermineBuildSystem.swift
   ExternalBuildSystemAdapter.swift
   FallbackBuildSettings.swift
   FileBuildSettings.swift
+  FixedCompilationDatabaseBuildSystem.swift
+  JSONCompilationDatabaseBuildSystem.swift
   LegacyBuildServerBuildSystem.swift
   MainFilesProvider.swift
   PathPrefixMapping.swift

Sources/BuildSystemIntegration/CompilationDatabase.swift

@@ -36,7 +36,6 @@ import WinSDK
 ///
 /// See https://clang.llvm.org/docs/JSONCompilationDatabase.html
 package struct CompilationDatabaseCompileCommand: Equatable, Codable {
-
   /// The working directory for the compilation.
   package var directory: String
 
@@ -103,84 +102,6 @@ package struct CompilationDatabaseCompileCommand: Equatable, Codable {
   }
 }
 
-/// A clang-compatible compilation database.
-///
-/// See https://clang.llvm.org/docs/JSONCompilationDatabase.html
-package protocol CompilationDatabase {
-  typealias Command = CompilationDatabaseCompileCommand
-  subscript(_ uri: DocumentURI) -> [Command] { get }
-  var sourceItems: [SourceItem] { get }
-}
-
-/// Loads a compilation database from `file`.
-package func tryLoadCompilationDatabase(
-  file: URL
-) -> CompilationDatabase? {
-  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
-    }
-  }
-}
-
-/// Fixed clang-compatible compilation database (compile_flags.txt).
-///
-/// Each line in the file becomes a command line argument. Example:
-/// ```
-/// -xc++
-/// -I
-/// libwidget/include/
-/// ```
-///
-/// 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
-
-  package subscript(path: DocumentURI) -> [CompilationDatabaseCompileCommand] {
-    [Command(directory: directory, filename: path.pseudoPath, commandLine: fixedArgs + [path.pseudoPath])]
-  }
-
-  package var sourceItems: [SourceItem] {
-    return [
-      SourceItem(uri: URI(filePath: directory, isDirectory: true), kind: .directory, generated: false)
-    ]
-  }
-
-  /// 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(Self.dbName)
-    try self.init(file: path)
-  }
-
-  /// Loads the compilation database from `file`
-  /// - Returns: `nil` if the file does not exist
-  package init?(file: URL) throws {
-    self.directory = try file.deletingLastPathComponent().filePath
-
-    let fileContents: String
-    do {
-      fileContents = try String(contentsOf: file, encoding: .utf8)
-    } catch {
-      return nil
-    }
-
-    var fixedArgs: [String] = ["clang"]
-    fileContents.enumerateLines { line, _ in
-      fixedArgs.append(line.trimmingCharacters(in: .whitespacesAndNewlines))
-    }
-    self.fixedArgs = fixedArgs
-  }
-}
-
 /// The JSON clang-compatible compilation database.
 ///
 /// Example:
@@ -196,11 +117,9 @@ 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"
-
+package struct JSONCompilationDatabase: Equatable, Codable {
   private var pathToCommands: [DocumentURI: [Int]] = [:]
-  private var commands: [CompilationDatabaseCompileCommand] = []
+  var commands: [CompilationDatabaseCompileCommand] = []
 
   package init(_ commands: [CompilationDatabaseCompileCommand] = []) {
     for command in commands {
@@ -211,27 +130,22 @@ package struct JSONCompilationDatabase: CompilationDatabase, Equatable, Codable
   package init(from decoder: Decoder) throws {
     var container = try decoder.unkeyedContainer()
     while !container.isAtEnd {
-      self.add(try container.decode(Command.self))
+      self.add(try container.decode(CompilationDatabaseCompileCommand.self))
     }
   }
 
   /// Loads the compilation database located in `directory`, if any.
   ///
   /// - Returns: `nil` if `compile_commands.json` was not found
-  package init?(directory: URL) throws {
-    let path = directory.appendingPathComponent(Self.dbName)
+  package init(directory: URL) throws {
+    let path = directory.appendingPathComponent(JSONCompilationDatabaseBuildSystem.dbName)
     try self.init(file: path)
   }
 
   /// Loads the compilation database from `file`
   /// - Returns: `nil` if the file does not exist
-  package init?(file: URL) throws {
-    let data: Data
-    do {
-      data = try Data(contentsOf: file)
-    } catch {
-      return nil
-    }
+  package init(file: URL) throws {
+    let data = try Data(contentsOf: file)
     self = try JSONDecoder().decode(JSONCompilationDatabase.self, from: data)
   }
 

Sources/BuildSystemIntegration/DetermineBuildSystem.swift

@@ -11,25 +11,56 @@
 //===----------------------------------------------------------------------===//
 
 import Foundation
-
-#if compiler(>=6)
-package import LanguageServerProtocol
 import SKLogging
-package import SKOptions
 import SwiftExtensions
+import TSCExtensions
 import ToolchainRegistry
 
 import struct TSCBasic.AbsolutePath
+import struct TSCBasic.RelativePath
+
+#if compiler(>=6)
+package import LanguageServerProtocol
+package import SKOptions
 #else
 import LanguageServerProtocol
-import SKLogging
 import SKOptions
-import SwiftExtensions
-import ToolchainRegistry
-
-import struct TSCBasic.AbsolutePath
 #endif
 
+private func searchForCompilationDatabaseConfig(
+  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(JSONCompilationDatabaseBuildSystem.dbName)
+      if FileManager.default.isFile(at: jsonPath) {
+        return BuildSystemSpec(kind: .jsonCompilationDatabase, projectRoot: workspaceFolder, configPath: jsonPath)
+      }
+
+      let fixedPath = path.appendingPathComponent(FixedCompilationDatabaseBuildSystem.dbName)
+      if FileManager.default.isFile(at: fixedPath) {
+        return BuildSystemSpec(kind: .fixedCompilationDatabase, projectRoot: workspaceFolder, configPath: fixedPath)
+      }
+
+      return nil
+    }
+    .first
+}
+
 /// 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:)`). `onlyConsiderRoot` controls whether
 /// paths outside the root should be considered (eg. configuration files in the user's home directory).
@@ -66,7 +97,7 @@ package func determineBuildSystem(
         options: options
       )
     case .compilationDatabase:
-      spec = CompilationDatabaseBuildSystem.searchForConfig(in: workspaceFolderUrl, options: options)
+      spec = searchForCompilationDatabaseConfig(in: workspaceFolderUrl, options: options)
     case .swiftPM:
       #if canImport(PackageModel)
       spec = SwiftPMBuildSystem.searchForConfig(in: workspaceFolderUrl, options: options)