[clangd] Look for compilation database in `build` subdirectory of parents.

[sammccall]

Summary

This matches the conventional location of cmake build directories.
It also allows creating a build symlink, which seems more flexible than the
compile_commands.json symlinks.

[kadircet]

sorry this fell of my radar. LGTM.

As discussed offline i am a little bit worried about regressing the case when there's a build in a subdirectory, and a (merged) compilation database of some sort in a parent directory. But I suppose this is a rare-ish use case.

now I can delete my symlink :)

clang-tools-extra/clangd/GlobalCompilationDatabase.cpp

 #else
   return A == B;
 #endif
 }
 
 DirectoryBasedGlobalCompilationDatabase::CachedCDB &
 DirectoryBasedGlobalCompilationDatabase::getCDBInDirLocked(PathRef Dir) const {
   // FIXME(ibiryukov): Invalidate cached compilation databases on changes
-  // FIXME(sammccall): this function hot, avoid copying key when hitting cache.
   auto Key = maybeCaseFoldPath(Dir);
   auto R = CompilationDatabases.try_emplace(Key);
   if (R.second) { // Cache miss, try to load CDB.
     CachedCDB &Entry = R.first->second;
     std::string Error;
-    Entry.CDB = tooling::CompilationDatabase::loadFromDirectory(Dir, Error);
     Entry.Path = std::string(Dir);
+    Entry.CDB = tooling::CompilationDatabase::loadFromDirectory(Dir, Error);
+    // Check for $src/build, the conventional CMake build root.
+    // Probe existence first to avoid each plugin doing IO if it doesn't exist.
+    if (!CompileCommandsDir && !Entry.CDB) {
+      llvm::SmallString<256> BuildDir = Dir;
+      llvm::sys::path::append(BuildDir, "build");
+      if (llvm::sys::fs::is_directory(BuildDir)) {
+        vlog("Found candidate build directory {0}", BuildDir);
+        Entry.CDB =
+            tooling::CompilationDatabase::loadFromDirectory(BuildDir, Error);
+      }
+    }
     if (Entry.CDB)
       log("Loaded compilation database from {0}", Dir);
   }
   return R.first->second;
 }
 
 llvm::Optional<DirectoryBasedGlobalCompilationDatabase::CDBLookupResult>
 DirectoryBasedGlobalCompilationDatabase::lookupCDB(

clang-tools-extra/clangd/unittests/GlobalCompilationDatabaseTests.cpp

 //===-- GlobalCompilationDatabaseTests.cpp ----------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "GlobalCompilationDatabase.h"
 
+#include "Matchers.h"
 #include "Path.h"
 #include "TestFS.h"
 #include "clang/Tooling/CompilationDatabase.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/FileSystem.h"
EXPECT_THAT(
       ElementsAre("clang++", "-DB=1", testPath("bar.cc"), "-DAdjust_bar.cc"));
 
   // Fallback gets adjusted.
   Cmd = CDB.getFallbackCommand("baz.cc");
   EXPECT_THAT(Cmd.CommandLine, ElementsAre("clang", "-DA=2", "baz.cc",
                                            "-DFallback", "-DAdjust_baz.cc"));
 }
 
+// Allows placement of files for tests and cleans them up after.
+class ScratchFS {
+  llvm::SmallString<128> Root;
+
+public:
+  ScratchFS() {
+    EXPECT_FALSE(llvm::sys::fs::createUniqueDirectory("clangd-cdb-test", Root))
+        << "Failed to create unique directory";
+  }
+
+  ~ScratchFS() {
+    EXPECT_FALSE(llvm::sys::fs::remove_directories(Root))
+        << "Failed to cleanup " << Root;
+  }
+
+  llvm::StringRef root() const { return Root; }
+
+  void write(PathRef RelativePath, llvm::StringRef Contents) {
+    std::string AbsPath = path(RelativePath);
+    EXPECT_FALSE(llvm::sys::fs::create_directories(
+        llvm::sys::path::parent_path(AbsPath)))
+        << "Failed to create directories for: " << AbsPath;
+
+    std::error_code EC;
+    llvm::raw_fd_ostream OS(AbsPath, EC);
+    EXPECT_FALSE(EC) << "Failed to open " << AbsPath << " for writing";
+    OS << llvm::formatv(Contents.data(),
+                        llvm::sys::path::convert_to_slash(Root));
+    OS.close();
+
+    EXPECT_FALSE(OS.has_error());
+  }
+
+  std::string path(PathRef RelativePath) const {
+    llvm::SmallString<128> AbsPath(Root);
+    llvm::sys::path::append(AbsPath, RelativePath);
+    llvm::sys::path::native(AbsPath);
+    return AbsPath.str().str();
+  }
+};
+
 TEST(GlobalCompilationDatabaseTest, DiscoveryWithNestedCDBs) {
   const char *const CDBOuter =
       R"cdb(
       [
         {
           "file": "a.cc",
           "command": "",
           "directory": "{0}",
const char *const CDBInner =
       [
         {
           "file": "gen.cc",
           "command": "",
           "directory": "{0}/build",
         }
       ]
       )cdb";
-  class CleaningFS {
-  public:
-    llvm::SmallString<128> Root;
-
-    CleaningFS() {
-      EXPECT_FALSE(
-          llvm::sys::fs::createUniqueDirectory("clangd-cdb-test", Root))
-          << "Failed to create unique directory";
-    }
-
-    ~CleaningFS() {
-      EXPECT_FALSE(llvm::sys::fs::remove_directories(Root))
-          << "Failed to cleanup " << Root;
-    }
-
-    void registerFile(PathRef RelativePath, llvm::StringRef Contents) {
-      llvm::SmallString<128> AbsPath(Root);
-      llvm::sys::path::append(AbsPath, RelativePath);
-
-      EXPECT_FALSE(llvm::sys::fs::create_directories(
-          llvm::sys::path::parent_path(AbsPath)))
-          << "Failed to create directories for: " << AbsPath;
-
-      std::error_code EC;
-      llvm::raw_fd_ostream OS(AbsPath, EC);
-      EXPECT_FALSE(EC) << "Failed to open " << AbsPath << " for writing";
-      OS << llvm::formatv(Contents.data(),
-                          llvm::sys::path::convert_to_slash(Root));
-      OS.close();
-
-      EXPECT_FALSE(OS.has_error());
-    }
-  };
-
-  CleaningFS FS;
-  FS.registerFile("compile_commands.json", CDBOuter);
-  FS.registerFile("build/compile_commands.json", CDBInner);
-  llvm::SmallString<128> File;
+  ScratchFS FS;
+  FS.write("compile_commands.json", CDBOuter);
+  FS.write("build/compile_commands.json", CDBInner);
 
   // Note that gen2.cc goes missing with our following model, not sure this
   // happens in practice though.
   {
     DirectoryBasedGlobalCompilationDatabase DB(llvm::None);
     std::vector<std::string> DiscoveredFiles;
     auto Sub =
         DB.watch([&DiscoveredFiles](const std::vector<std::string> Changes) {
           DiscoveredFiles = Changes;
         });
 
-    File = FS.Root;
-    llvm::sys::path::append(File, "build", "..", "a.cc");
-    DB.getCompileCommand(File.str());
+    DB.getCompileCommand(FS.path("build/../a.cc"));
     EXPECT_THAT(DiscoveredFiles, UnorderedElementsAre(AllOf(
                                      EndsWith("a.cc"), Not(HasSubstr("..")))));
     DiscoveredFiles.clear();
 
-    File = FS.Root;
-    llvm::sys::path::append(File, "build", "gen.cc");
-    DB.getCompileCommand(File.str());
+    DB.getCompileCommand(FS.path("build/gen.cc"));
     EXPECT_THAT(DiscoveredFiles, UnorderedElementsAre(EndsWith("gen.cc")));
   }
 
   // With a custom compile commands dir.
   {
-    DirectoryBasedGlobalCompilationDatabase DB(FS.Root.str().str());
+    DirectoryBasedGlobalCompilationDatabase DB(FS.root().str());
     std::vector<std::string> DiscoveredFiles;
     auto Sub =
         DB.watch([&DiscoveredFiles](const std::vector<std::string> Changes) {
           DiscoveredFiles = Changes;
         });
 
-    File = FS.Root;
-    llvm::sys::path::append(File, "a.cc");
-    DB.getCompileCommand(File.str());
+    DB.getCompileCommand(FS.path("a.cc"));
     EXPECT_THAT(DiscoveredFiles,
                 UnorderedElementsAre(EndsWith("a.cc"), EndsWith("gen.cc"),
                                      EndsWith("gen2.cc")));
     DiscoveredFiles.clear();
 
-    File = FS.Root;
-    llvm::sys::path::append(File, "build", "gen.cc");
-    DB.getCompileCommand(File.str());
+    DB.getCompileCommand(FS.path("build/gen.cc"));
     EXPECT_THAT(DiscoveredFiles, IsEmpty());
   }
 }
 
+TEST(GlobalCompilationDatabaseTest, BuildDir) {
+  ScratchFS FS;
+  auto Command = [&](llvm::StringRef Relative) {
+    return DirectoryBasedGlobalCompilationDatabase(llvm::None)
+        .getCompileCommand(FS.path(Relative))
+        .getValueOr(tooling::CompileCommand())
+        .CommandLine;
+  };
+  EXPECT_THAT(Command("x/foo.cc"), IsEmpty());
+  FS.write("x/build/compile_flags.txt", "-DXYZZY");
+  EXPECT_THAT(Command("x/foo.cc"), Contains("-DXYZZY"));
+  EXPECT_THAT(Command("bar.cc"), IsEmpty())
+      << "x/build/compile_flags.txt only applicable to x/";
+}
+
 TEST(GlobalCompilationDatabaseTest, NonCanonicalFilenames) {
   OverlayCDB DB(nullptr);
   std::vector<std::string> DiscoveredFiles;
   auto Sub =
       DB.watch([&DiscoveredFiles](const std::vector<std::string> Changes) {
         DiscoveredFiles = Changes;
       });