[clangd] WIP: warn the user about missing compile_commands.json

clang-tools-extra/clangd/GlobalCompilationDatabase.h

public:
   llvm::Optional<ProjectInfo> getProjectInfo(PathRef File) const override;
 
 private:
   /// Caches compilation databases loaded from directories.
   struct CachedCDB {
     std::string Path; // Not case-folded.
     std::unique_ptr<clang::tooling::CompilationDatabase> CDB = nullptr;
     bool SentBroadcast = false;
+    bool Diagnosed = false;
   };
   CachedCDB &getCDBInDirLocked(PathRef File) const;
 
   struct CDBLookupRequest {
     PathRef FileName;
     // Whether this lookup should trigger discovery of the CDB found.
     bool ShouldBroadcast = false;
+    // If no CDB is found, attempt diagnosis of the directories searched.
+    bool ShouldDiagnose = false;
   };
   struct CDBLookupResult {
     tooling::CompilationDatabase *CDB = nullptr;
     ProjectInfo PI;
   };
   llvm::Optional<CDBLookupResult> lookupCDB(CDBLookupRequest Request) const;
 
+  // Examines a directory where a CDB was not found, to suggest fixes.
+  bool diagnose(llvm::StringRef Path) const;
+
   // Performs broadcast on governed files.
   void broadcastCDB(CDBLookupResult Res) const;
 
   mutable std::mutex Mutex;
   // Keyed by possibly-case-folded directory path.
   mutable llvm::StringMap<CachedCDB> CompilationDatabases;
 
   /// Used for command argument pointing to folder where compile_commands.json

clang-tools-extra/clangd/GlobalCompilationDatabase.cpp

 #include "Logger.h"
 #include "Path.h"
 #include "clang/Frontend/CompilerInvocation.h"
 #include "clang/Tooling/ArgumentsAdjusters.h"
 #include "clang/Tooling/CompilationDatabase.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/ScopeExit.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Program.h"
 #include <string>
 #include <tuple>
 #include <vector>

 DirectoryBasedGlobalCompilationDatabase::
     ~DirectoryBasedGlobalCompilationDatabase() = default;
 
 llvm::Optional<tooling::CompileCommand>
 DirectoryBasedGlobalCompilationDatabase::getCompileCommand(PathRef File) const {
   CDBLookupRequest Req;
   Req.FileName = File;
   Req.ShouldBroadcast = true;
+  Req.ShouldDiagnose = true;
 
   auto Res = lookupCDB(Req);
   if (!Res) {
     log("Failed to find compilation database for {0}", File);
     return llvm::None;
   }
 
   auto Candidates = Res->CDB->getCompileCommands(File);
DirectoryBasedGlobalCompilationDatabase::getCDBInDirLocked(PathRef Dir) const {
   return R.first->second;
 }
 
 llvm::Optional<DirectoryBasedGlobalCompilationDatabase::CDBLookupResult>
 DirectoryBasedGlobalCompilationDatabase::lookupCDB(
     CDBLookupRequest Request) const {
   assert(llvm::sys::path::is_absolute(Request.FileName) &&
          "path must be absolute");
+  std::string CanonicalName = removeDots(Request.FileName);
 
   bool ShouldBroadcast = false;
   CDBLookupResult Result;
 
+  llvm::SmallVector<PathRef, 8> DiagnoseDirs;
+  auto DiagnoseBeforeReturn = llvm::make_scope_exit([&]{
+    for (PathRef Dir : DiagnoseDirs)
+      if (diagnose(Dir))
+        break;
+  });
+
   {
     std::lock_guard<std::mutex> Lock(Mutex);
     CachedCDB *Entry = nullptr;
     if (CompileCommandsDir) {
       Entry = &getCDBInDirLocked(*CompileCommandsDir);
     } else {
       // Traverse the canonical version to prevent false positives. i.e.:
       // src/build/../a.cc can detect a CDB in /src/build if not canonicalized.
       // FIXME(sammccall): this loop is hot, use a union-find-like structure.
-      actOnAllParentDirectories(removeDots(Request.FileName),
-                                [&](PathRef Path) {
-                                  Entry = &getCDBInDirLocked(Path);
-                                  return Entry->CDB != nullptr;
-                                });
+      actOnAllParentDirectories(CanonicalName, [&](PathRef Path) {
+        if (Request.ShouldDiagnose && !Entry->CDB && !Entry->Diagnosed) {
+          Entry->Diagnosed = true;
+          DiagnoseDirs.push_back(Path);
+        }
     }
 
     if (!Entry || !Entry->CDB)
       return llvm::None;
 
+    // Don't diagnose if we found a CDB in the end.
+    DiagnoseDirs.clear();
+
     // Mark CDB as broadcasted to make sure discovery is performed once.
     if (Request.ShouldBroadcast && !Entry->SentBroadcast) {
       Entry->SentBroadcast = true;
       ShouldBroadcast = true;
     }
 
     Result.CDB = Entry->CDB.get();
     Result.PI.SourceRoot = Entry->Path;
DirectoryBasedGlobalCompilationDatabase::getProjectInfo(PathRef File) const {
   Req.FileName = File;
   Req.ShouldBroadcast = false;
   auto Res = lookupCDB(Req);
   if (!Res)
     return llvm::None;
   return Res->PI;
 }
 
+bool DirectoryBasedGlobalCompilationDatabase::diagnose(PathRef Dir) const {
+  vlog("Diagnosing missing CDB in {0}", Dir);
+
+  namespace fs = llvm::sys::fs;
+  namespace path = llvm::sys::path;
+  llvm::SmallString<256> Path = Dir;
+  auto Exists = [&](llvm::StringRef Filename){
+    auto Size = Path.size();
+    path::append(Path, Filename);
+    bool Ret = fs::exists(Path);
+    Path.resize(Size);
+    return Ret;
+  };
+  if (Exists("CMakeLists.txt")) {
+    Path.resize(path::parent_path(Path).size());
+    if (!Exists("CMakeLists.txt")) {
+      elog("Missing compile_commands.json in {0}", Dir);
+      return true;
+    }
+  }
+  return false;
+}
+
 OverlayCDB::OverlayCDB(const GlobalCompilationDatabase *Base,
                        std::vector<std::string> FallbackFlags,
                        tooling::ArgumentsAdjuster Adjuster)
     : Base(Base), ArgsAdjuster(std::move(Adjuster)),
       FallbackFlags(std::move(FallbackFlags)) {
   if (Base)
     BaseChanged = Base->watch([this](const std::vector<std::string> Changes) {
       OnCommandChanged.broadcast(Changes);