chore: Absolute compilation database

Author: vinniefalco

source/AST/AbsoluteCompilationDatabase.cpp

@@ -0,0 +1,109 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco ([email protected])
+//
+// Official repository: https://github.com/cppalliance/mrdox
+//
+
+#include "Support/Debug.hpp"
+#include "Support/Path.hpp"
+#include "AST/AbsoluteCompilationDatabase.hpp"
+#include <llvm/Support/FileSystem.h>
+#include <llvm/Support/raw_ostream.h>
+
+namespace clang {
+namespace mrdox {
+
+AbsoluteCompilationDatabase::
+AbsoluteCompilationDatabase(
+    llvm::StringRef workingDir,
+    CompilationDatabase const& inner)
+{
+    namespace fs = llvm::sys::fs;
+    namespace path = llvm::sys::path;
+
+    auto allCommands = inner.getAllCompileCommands();
+    AllCommands_.reserve(allCommands.size());
+    SmallPathString temp;
+    for(auto const& cmd0 : allCommands)
+    {
+        tooling::CompileCommand cmd;
+
+        cmd.CommandLine = cmd0.CommandLine;
+        cmd.Heuristic = cmd0.Heuristic;
+        cmd.Output = cmd0.Output;
+        cmd.CommandLine = cmd0.CommandLine;
+
+        if(path::is_absolute(cmd0.Directory))
+        {
+            path::native(cmd0.Directory, temp);
+            cmd.Directory = static_cast<std::string>(temp);
+        }
+        else
+        {
+            temp = cmd0.Directory;
+            fs::make_absolute(workingDir, temp);
+            path::remove_dots(temp, true);
+            cmd.Directory = static_cast<std::string>(temp);
+        }
+
+        if(path::is_absolute(cmd0.Filename))
+        {
+            path::native(cmd0.Filename, temp);
+            cmd.Filename = static_cast<std::string>(temp);
+        }
+        else
+        {
+            temp = cmd0.Filename;
+            fs::make_absolute(workingDir, temp);
+            path::remove_dots(temp, true);
+            cmd.Filename = static_cast<std::string>(temp);
+        }
+
+        std::size_t i = AllCommands_.size();
+        auto result = IndexByFile_.try_emplace(cmd.Filename, i);
+        AllCommands_.emplace_back(std::move(cmd));
+        Assert(result.second);
+    }
+}
+
+std::vector<tooling::CompileCommand>
+AbsoluteCompilationDatabase::
+getCompileCommands(
+    llvm::StringRef FilePath) const
+{
+    SmallPathString nativeFilePath;
+    llvm::sys::path::native(FilePath, nativeFilePath);
+
+    auto const it = IndexByFile_.find(nativeFilePath);
+    if (it == IndexByFile_.end())
+        return {};
+    std::vector<tooling::CompileCommand> Commands;
+    Commands.push_back(AllCommands_[it->getValue()]);
+    return Commands;
+}
+
+std::vector<std::string>
+AbsoluteCompilationDatabase::
+getAllFiles() const
+{
+    std::vector<std::string> allFiles;
+    allFiles.reserve(AllCommands_.size());
+    for(auto const& cmd : AllCommands_)
+        allFiles.push_back(cmd.Filename);
+    return allFiles;
+}
+
+std::vector<tooling::CompileCommand>
+AbsoluteCompilationDatabase::
+getAllCompileCommands() const
+{
+    return AllCommands_;
+}
+
+} // mrdox
+} // clang

source/AST/AbsoluteCompilationDatabase.hpp

@@ -0,0 +1,61 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco ([email protected])
+//
+// Official repository: https://github.com/cppalliance/mrdox
+//
+
+#ifndef MRDOX_LIB_AST_ABSOLUTECOMPILATIONDATABASE_HPP
+#define MRDOX_LIB_AST_ABSOLUTECOMPILATIONDATABASE_HPP
+
+#include <clang/Tooling/JSONCompilationDatabase.h>
+#include <llvm/ADT/StringMap.h>
+#include <vector>
+
+namespace clang {
+namespace mrdox {
+
+/** A compilation database where all paths are absolute.
+
+    All relative paths in the compilation database
+    will be converted to absolute paths by resolving
+    them according to the working directory specified
+    at construction.
+*/
+class AbsoluteCompilationDatabase
+    : public tooling::CompilationDatabase
+{
+    std::vector<tooling::CompileCommand> AllCommands_;
+    llvm::StringMap<std::size_t> IndexByFile_;
+
+public:
+    /** Constructor.
+
+        This copies the contents of the source compilation
+        database. Every relative path is converted into an
+        absolute path by resolving against the specified
+        working directory.
+    */
+    AbsoluteCompilationDatabase(
+        llvm::StringRef workingDir,
+        CompilationDatabase const& inner);
+
+    std::vector<tooling::CompileCommand>
+    getCompileCommands(
+        llvm::StringRef FilePath) const override;
+
+    std::vector<std::string>
+    getAllFiles() const override;
+
+    std::vector<tooling::CompileCommand>
+    getAllCompileCommands() const override;
+};
+
+} // mrdox
+} // clang
+
+#endif
+

source/GenerateAction.cpp

@@ -12,9 +12,12 @@
 #include "Options.hpp"
 #include "ConfigImpl.hpp"
 #include "CorpusImpl.hpp"
+#include "AST/AbsoluteCompilationDatabase.hpp"
 #include <mrdox/Generators.hpp>
+#include <mrdox/Support/Report.hpp>
 #include <clang/Tooling/AllTUsExecution.h>
 #include <clang/Tooling/JSONCompilationDatabase.h>
+#include <llvm/Support/Path.h>
 #include <cstdlib>
 
 namespace clang {
@@ -23,6 +26,8 @@ namespace mrdox {
 Error
 DoGenerateAction()
 {
+    namespace path = llvm::sys::path;
+
     auto& generators = getGenerators();
 
     // Calculate additional YAML settings from command line options.
@@ -45,16 +50,23 @@ DoGenerateAction()
         return Error("the compilation database path argument is missing");
     if(InputPaths.size() > 1)
         return Error("got {} input paths where 1 was expected", InputPaths.size());
+    llvm::StringRef compilationsPath = InputPaths.front();
     std::string errorMessage;
-    auto compilations = tooling::JSONCompilationDatabase::loadFromFile(
-        InputPaths.front(), errorMessage, tooling::JSONCommandLineSyntax::AutoDetect);
-    if(! compilations)
+    auto jsonCompilations = tooling::JSONCompilationDatabase::loadFromFile(
+        compilationsPath, errorMessage, tooling::JSONCommandLineSyntax::AutoDetect);
+    if(! jsonCompilations)
         return Error(std::move(errorMessage));
 
+    // Calculate the working directory
+    llvm::SmallString<240> workingDir(compilationsPath);
+    path::remove_filename(workingDir);
+
+    // Convert relative paths to absolute
+    AbsoluteCompilationDatabase compilations(workingDir, *jsonCompilations);
+    
     // Create the ToolExecutor from the compilation database
     int ThreadCount = 0;
-    auto ex = std::make_unique<tooling::AllTUsToolExecutor>(
-        *compilations, ThreadCount);
+    auto ex = std::make_unique<tooling::AllTUsToolExecutor>(compilations, ThreadCount);
 
     // Create the generator
     auto generator = generators.find(FormatType.getValue());
@@ -68,7 +80,7 @@ DoGenerateAction()
 
     // Run the generator.
     if(config.get()->verboseOutput)
-        llvm::outs() << "Generating docs...\n";
+        reportInfo("Generating docs...\n");
     return generator->build(OutputPath.getValue(), **corpus);
 }
 

source/Support/Path.hpp

@@ -13,12 +13,20 @@
 #define MRDOX_LIB_SUPPORT_PATH_HPP
 
 #include <mrdox/Platform.hpp>
+#include <llvm/ADT/SmallString.h>
 #include <llvm/ADT/StringRef.h>
 #include <llvm/Support/Path.h>
 
 namespace clang {
 namespace mrdox {
 
+/** A reasonably sized small string for paths.
+
+    This is for local variables not for use
+    as data members of long-lived types.
+*/
+using SmallPathString = llvm::SmallString<340>;
+
 /** Replaces backslashes with slashes if Windows in place.
 
     @param path A path that is transformed to native format.