Fix compilation database

Overrules the compilation database to change the compiler to
to the exact llvm/clair compiler used to compile clair-c2py.
This enables clair to find all systems path properly on complex
machines (e.g. cluster)

Two use cases:
 - when calling clair-c2py with -- option, on complex machines
 - when developping with e.g. gcc: the default compilation database
   would use gcc, we need to change it to clang for the command line

Author: parcollet

src/clu/CMakeLists.txt

@@ -12,4 +12,5 @@ target_link_libraries(clu PRIVATE fmt::fmt clang_llvm)
 target_include_directories(clu PRIVATE ${PROJECT_SOURCE_DIR}/src ${CMAKE_CURRENT_SOURCE_DIR})
 target_compile_definitions(clu PRIVATE CLANG_RESOURCE_DIR="${CLANG_RESOURCE_DIR}" 
                                        SDKROOT="${SDKROOT}" 
+                                       CMAKE_CXX_COMPILER="${CMAKE_CXX_COMPILER}"
                                        GIT_HASH="${PROJECT_GIT_HASH}")

src/clu/cmd_line_arg.cpp

@@ -10,8 +10,11 @@ namespace fs = std::filesystem;
 using namespace std::string_literals;
 
 static const std::string resource_dir = CLANG_RESOURCE_DIR;
+static const std::string cxx_compiler = CMAKE_CXX_COMPILER;
 
 namespace clu {
+  std::string get_clang_compiler_path() { return cxx_compiler; }
+
   clang::tooling::CommandLineArguments get_clang_additional_args_from_env_variables() {
 
 #ifdef __APPLE__

src/clu/cmd_line_arg.hpp

@@ -14,5 +14,8 @@ namespace clu {
   // include e.g. on stdlib will fail
   clang::tooling::CommandLineArguments get_clang_additional_args_from_env_variables();
 
+  // Get the path to the clang++ compiler used to build clair
+  std::string get_clang_compiler_path();
+
   std::string get_git_hash();
 } // namespace clu

src/clu/custom_compilation_database.hpp

@@ -0,0 +1,48 @@
+#pragma once
+#include "clang/Tooling/CompilationDatabase.h"
+#include "clang/Tooling/Tooling.h"
+#include <vector>
+#include <string>
+
+namespace clu {
+
+  /**
+   * @brief Custom implementation of CompilationDatabase.
+   * 
+   * This class provides a simple in-memory compilation database that stores
+   * a vector of compile commands. It is useful when you need to:
+   * - Modify compile commands from an existing database
+   * - Create a compilation database programmatically
+   * - Work with a fixed set of compile commands
+   */
+  class custom_compilation_database : public clang::tooling::CompilationDatabase {
+    std::vector<clang::tooling::CompileCommand> Commands;
+
+    public:
+    /**
+     * @brief Construct a custom compilation database from a vector of compile commands.
+     * @param Cmds The compile commands to store in the database.
+     */
+    custom_compilation_database(std::vector<clang::tooling::CompileCommand> Cmds) : Commands(std::move(Cmds)) {}
+
+    /**
+     * @brief Get compile commands for a specific file.
+     * @param FilePath The path to the file.
+     * @return Vector of compile commands matching the given file path.
+     */
+    std::vector<clang::tooling::CompileCommand> getCompileCommands(llvm::StringRef FilePath) const override;
+
+    /**
+     * @brief Get all files in the compilation database.
+     * @return Vector of file paths.
+     */
+    std::vector<std::string> getAllFiles() const override;
+
+    /**
+     * @brief Get all compile commands.
+     * @return Vector of all compile commands stored in the database.
+     */
+    std::vector<clang::tooling::CompileCommand> getAllCompileCommands() const override { return Commands; }
+  };
+
+} // namespace clu

src/tools/clair-c2py/main.cpp

@@ -5,6 +5,7 @@
 #include "clang/Tooling/CommonOptionsParser.h"
 #include "clang/Basic/Version.h"
 
+#include "clu/custom_compilation_database.hpp"
 #include "clu/cmd_line_arg.hpp"
 #include "utility/macros.hpp"
 #include "utility/logger.hpp"
@@ -81,9 +82,60 @@ int main(int argc, const char **argv) try {
     config = read_configuration(config_filename);
   config._depfile_name = opt_depfile;
 
-  // ------- main tool
+  // ---  Correct the compilation database
+  // Enforce that the compiler for source0 is the clang compiler used in compiling clair itself.
+  // This a ABSOLUTELY necessary to ensure clair sees the system paths, has the right -resource-dir.
+  // It is useful in at least 2 cases:
+  //  - call with -- options: the default "compiler" would be "clang-tool", and if the system path are not standard (i.e. in most cluster machine)
+  //    it would fail.
+  //  - when developing with another compiler, e.g. gcc.
+
+  auto &current_compdb  = opt_parser->getCompilations();
+  auto all_compile_cmds = current_compdb.getAllCompileCommands();
+  // WARNING: Database behavior depends on the type of the compilation database:
+  // - JSONCompilationDatabase (from compile_commands.json): getAllCompileCommands() returns all entries
+  // - FixedCompilationDatabase (from -- arguments)        : getAllCompileCommands() returns empty always
+  //   it can generate commands for any file on-demand via getCompileCommands(filename), so there's no finite "all" to return.
+  // This seems to be a long-standing LLVM design choice [Cf Claude 4.5].
+  // If future LLVM versions change this behavior, adjust the logic below accordingly.
+  bool using_fixed_db = all_compile_cmds.empty();
+  if (using_fixed_db) {
+    llvm::errs() << "Calling with --. Getting compile commands for source file.\n";
+    all_compile_cmds = current_compdb.getCompileCommands(source0);
+    if (all_compile_cmds.empty())
+      throw std::runtime_error("Internal Error: no compilation commands found or for " + source0 + "\n     and none could be generated.");
+  }
+
+  // Now fix the compiler for the compile command corresponding to source0.
+  // Use canonical for comparison (to handle symlinks), but absolute for storage (ClangTool doesn't follow symlinks).
+  auto canonical_source0 = fs::canonical(source0).string();
+  for (auto &cmd : all_compile_cmds) {
+    if (fs::canonical(cmd.Filename).string() == canonical_source0) {
+      if (cmd.CommandLine.empty()) throw std::runtime_error("CompileCommand has empty CommandLine for " + source0);
+      auto expected_compiler = clu::get_clang_compiler_path();
+      if (cmd.CommandLine[0] != expected_compiler) {
+        if (opt_verbose)
+          llvm::errs() << "Warning: clair-c2py. When analyzing source file " << source0 << ", replacing compiler \n"
+                       << cmd.CommandLine[0] << "\n   with \n"
+                       << expected_compiler << "\n";
+        cmd.CommandLine[0] = expected_compiler;
+      }
+      // For FixedCompilationDatabase: update Filename to canonical path.
+      // For JSONCompilationDatabase: do nothing
+      if (using_fixed_db) {
+        cmd.Filename = canonical_source0;
+        source0      = canonical_source0;
+      }
+      break; // we found and fixed the command for source0. we are done.
+    }
+  }
+  // Finally we construct a custom compilation database with the fixed commands
+  auto custom_db = clu::custom_compilation_database(all_compile_cmds);
 
-  clang::tooling::ClangTool main_tool(opt_parser->getCompilations(), opt_parser->getSourcePathList());
+  // ------- main tool
+  // For FixedCompilationDatabase, pass canonical path to ClangTool to match what's in the database
+  //auto source_for_tool = using_fixed_db ? canonical_source0 : source0;
+  clang::tooling::ClangTool main_tool(custom_db, {source0}); // we use the fixed compilation database
 
   // Additional Command line arguments to be given to the compiler, after all other options
   // from e.g. CXXFLAGS and co, and the -resource-dir.