fix: fall back to system compilers when database compiler is unavailable

When use-system-stdlib is enabled and the compiler specified in the
compilation database cannot be found (e.g. synthetic databases that
reference "clang" on systems with only GCC), try common fallback
compilers (g++, gcc, clang++, clang, c++) to discover system include
paths. This prevents fatal "stddef.h not found" errors when running
mrdocs on systems where the database compiler isn't installed.

Author: alandefreitas

src/tool/CompilerInfo.cpp

@@ -18,15 +18,15 @@
 namespace mrdocs {
 
 Optional<std::string>
-getCompilerVerboseOutput(llvm::StringRef compilerPath) 
+getCompilerVerboseOutput(llvm::StringRef compilerPath)
 {
     if ( ! llvm::sys::fs::exists(compilerPath))
     {
         return std::nullopt;
     }
 
     llvm::SmallString<128> outputPath;
-    if (auto ec = llvm::sys::fs::createTemporaryFile("compiler-info", "txt", outputPath)) 
+    if (auto ec = llvm::sys::fs::createTemporaryFile("compiler-info", "txt", outputPath))
     {
         return std::nullopt;
     }
@@ -35,7 +35,7 @@ getCompilerVerboseOutput(llvm::StringRef compilerPath)
     std::vector<llvm::StringRef> const args = {compilerPath, "-v", "-E", "-x", "c++", "-"};
     llvm::ArrayRef<llvm::StringRef> emptyEnv;
     int const result = ExecuteAndWaitWithLogging(compilerPath, args, emptyEnv, redirects);
-    if (result != 0) 
+    if (result != 0)
     {
         llvm::sys::fs::remove(outputPath);
         return std::nullopt;
@@ -51,26 +51,26 @@ getCompilerVerboseOutput(llvm::StringRef compilerPath)
     return bufferOrError.get()->getBuffer().str();
 }
 
-std::vector<std::string> 
-parseIncludePaths(std::string const& compilerOutput) 
+std::vector<std::string>
+parseIncludePaths(std::string const& compilerOutput)
 {
     std::vector<std::string> includePaths;
     std::istringstream stream(compilerOutput);
     std::string line;
     bool capture = false;
 
-    while (std::getline(stream, line)) 
+    while (std::getline(stream, line))
     {
-        if (line.find("#include <...> search starts here:") != std::string::npos) 
+        if (line.find("#include <...> search starts here:") != std::string::npos)
         {
             capture = true;
             continue;
         }
-        if (line.find("End of search list.") != std::string::npos) 
+        if (line.find("End of search list.") != std::string::npos)
         {
             break;
         }
-        if (capture) 
+        if (capture)
         {
             line.erase(0, line.find_first_not_of(" "));
             includePaths.push_back(line);
@@ -80,8 +80,30 @@ parseIncludePaths(std::string const& compilerOutput)
     return includePaths;
 }
 
-std::unordered_map<std::string, std::vector<std::string>> 
-getCompilersDefaultIncludeDir(clang::tooling::CompilationDatabase const& compDb, bool useSystemStdlib) 
+namespace {
+
+// Try to get include paths from a compiler found by name in PATH.
+// Returns the include paths if successful, empty vector otherwise.
+std::vector<std::string>
+tryCompilerByName(llvm::StringRef name)
+{
+    auto found = llvm::sys::findProgramByName(name);
+    if (!found)
+    {
+        return {};
+    }
+    auto output = getCompilerVerboseOutput(*found);
+    if (!output)
+    {
+        return {};
+    }
+    return parseIncludePaths(*output);
+}
+
+} // anonymous namespace
+
+std::unordered_map<std::string, std::vector<std::string>>
+getCompilersDefaultIncludeDir(clang::tooling::CompilationDatabase const& compDb, bool useSystemStdlib)
 {
     if (!useSystemStdlib)
     {
@@ -100,14 +122,30 @@ getCompilersDefaultIncludeDir(clang::tooling::CompilationDatabase const& compDb,
                 continue;
             }
 
-            std::vector<std::string> includePaths;
-            auto const compilerOutput = getCompilerVerboseOutput(compilerPath);
-            if (!compilerOutput)
+            // Try the compiler specified in the compilation database
+            auto compilerOutput = getCompilerVerboseOutput(compilerPath);
+            if (compilerOutput)
             {
-                res.emplace(compilerPath, includePaths);
+                auto includePaths = parseIncludePaths(*compilerOutput);
+                res.emplace(compilerPath, std::move(includePaths));
                 continue;
             }
-            includePaths = parseIncludePaths(*compilerOutput);
+
+            // The compiler from the database wasn't found.
+            // Try common fallback compilers to discover system
+            // include paths.
+            static constexpr std::string_view fallbackCompilers[] = {
+                "g++", "gcc", "clang++", "clang", "c++"
+            };
+            std::vector<std::string> includePaths;
+            for (auto const& fallback : fallbackCompilers)
+            {
+                includePaths = tryCompilerByName(fallback);
+                if (!includePaths.empty())
+                {
+                    break;
+                }
+            }
             res.emplace(compilerPath, std::move(includePaths));
         }
     }
@@ -116,4 +154,3 @@ getCompilersDefaultIncludeDir(clang::tooling::CompilationDatabase const& compDb,
 }
 
 } // mrdocs
-