[clangd] Remove caching of compilation database commands.

[sammccall]

Summary

The CDB implementations used in open-source code are fast, and our private
slow CDB will soon do the relevant caching itself.

Simplifying the GlobalCDB layer in clangd is important to get auto-index
implemented at the right layer.

[sammccall]

Ping - this seems straightforward, and blocks further cleanups.

clang-tools-extra/trunk/clangd/ClangdLSPServer.h

void setExtraFlagsForFile(PathRef File,
                               std::vector<std::string> ExtraFlags);
 
     /// Set the compile commands directory to \p P.
     /// Only valid for directory-based CDB, no-op and error log on InMemoryCDB;
     void setCompileCommandsDir(Path P);
 
     /// Returns a CDB that should be used to get compile commands for the
     /// current instance of ClangdLSPServer.
-    GlobalCompilationDatabase &getCDB();
+    GlobalCompilationDatabase &getCDB() { return *CDB; }
 
   private:
     CompilationDB(std::unique_ptr<GlobalCompilationDatabase> CDB,
-                  std::unique_ptr<CachingCompilationDb> CachingCDB,
                   bool IsDirectoryBased)
-        : CDB(std::move(CDB)), CachingCDB(std::move(CachingCDB)),
-          IsDirectoryBased(IsDirectoryBased) {}
+        : CDB(std::move(CDB)), IsDirectoryBased(IsDirectoryBased) {}
 
     // if IsDirectoryBased is true, an instance of InMemoryCDB.
     // If IsDirectoryBased is false, an instance of DirectoryBasedCDB.
     // unique_ptr<GlobalCompilationDatabase> CDB;
     std::unique_ptr<GlobalCompilationDatabase> CDB;
-    // Non-null only for directory-based CDB
-    std::unique_ptr<CachingCompilationDb> CachingCDB;
     bool IsDirectoryBased;
   };
 
   // Most code should not deal with Transport directly.
   // MessageHandler deals with incoming messages, use call() etc for outgoing.
   clangd::Transport &Transp;
   class MessageHandler;
   std::unique_ptr<MessageHandler> MsgHandler;

clang-tools-extra/trunk/clangd/ClangdLSPServer.cpp

 
 void ClangdLSPServer::reparseOpenedFiles() {
   for (const Path &FilePath : DraftMgr.getActiveFiles())
     Server->addDocument(FilePath, *DraftMgr.getDraft(FilePath),
                         WantDiagnostics::Auto);
 }
 
 ClangdLSPServer::CompilationDB ClangdLSPServer::CompilationDB::makeInMemory() {
-  return CompilationDB(llvm::make_unique<InMemoryCompilationDb>(), nullptr,
+  return CompilationDB(llvm::make_unique<InMemoryCompilationDb>(),
                        /*IsDirectoryBased=*/false);
 }
 
 ClangdLSPServer::CompilationDB
 ClangdLSPServer::CompilationDB::makeDirectoryBased(
     Optional<Path> CompileCommandsDir) {
   auto CDB = llvm::make_unique<DirectoryBasedGlobalCompilationDatabase>(
       std::move(CompileCommandsDir));
-  auto CachingCDB = llvm::make_unique<CachingCompilationDb>(*CDB);
-  return CompilationDB(std::move(CDB), std::move(CachingCDB),
+  return CompilationDB(std::move(CDB),
                        /*IsDirectoryBased=*/true);
 }
 
 void ClangdLSPServer::CompilationDB::invalidate(PathRef File) {
   if (!IsDirectoryBased)
     static_cast<InMemoryCompilationDb *>(CDB.get())->invalidate(File);
-  else
-    CachingCDB->invalidate(File);
 }
 
 bool ClangdLSPServer::CompilationDB::setCompilationCommandForFile(
     PathRef File, tooling::CompileCommand CompilationCommand) {
   if (IsDirectoryBased) {
     elog("Trying to set compile command for {0} while using directory-based "
          "compilation database",
          File);
     return false;
   }
   return static_cast<InMemoryCompilationDb *>(CDB.get())
       ->setCompilationCommandForFile(File, std::move(CompilationCommand));
 }
 
 void ClangdLSPServer::CompilationDB::setExtraFlagsForFile(
     PathRef File, std::vector<std::string> ExtraFlags) {
   if (!IsDirectoryBased) {
     elog("Trying to set extra flags for {0} while using in-memory compilation "
          "database",
          File);
     return;
   }
   static_cast<DirectoryBasedGlobalCompilationDatabase *>(CDB.get())
       ->setExtraFlagsForFile(File, std::move(ExtraFlags));
-  CachingCDB->invalidate(File);
 }
 
 void ClangdLSPServer::CompilationDB::setCompileCommandsDir(Path P) {
   if (!IsDirectoryBased) {
     elog("Trying to set compile commands dir while using in-memory compilation "
          "database");
     return;
   }
   static_cast<DirectoryBasedGlobalCompilationDatabase *>(CDB.get())
       ->setCompileCommandsDir(P);
-  CachingCDB->clear();
-}
-
-GlobalCompilationDatabase &ClangdLSPServer::CompilationDB::getCDB() {
-  if (CachingCDB)
-    return *CachingCDB;
-  return *CDB;
 }
 
 } // namespace clangd
 } // namespace clang

clang-tools-extra/trunk/clangd/GlobalCompilationDatabase.h

private:
 
   /// Stores extra flags per file.
   llvm::StringMap<std::vector<std::string>> ExtraFlagsForFile;
   /// Used for command argument pointing to folder where compile_commands.json
   /// is located.
   llvm::Optional<Path> CompileCommandsDir;
 };
 
-/// A wrapper around GlobalCompilationDatabase that caches the compile commands.
-/// Note that only results of getCompileCommand are cached.
-class CachingCompilationDb : public GlobalCompilationDatabase {
-public:
-  explicit CachingCompilationDb(const GlobalCompilationDatabase &InnerCDB);
-
-  /// Gets compile command for \p File from cache or CDB if it's not in the
-  /// cache.
-  llvm::Optional<tooling::CompileCommand>
-  getCompileCommand(PathRef File) const override;
-
-  /// Forwards to the inner CDB. Results of this function are not cached.
-  tooling::CompileCommand getFallbackCommand(PathRef File) const override;
-
-  /// Removes an entry for \p File if it's present in the cache.
-  void invalidate(PathRef File);
-
-  /// Removes all cached compile commands.
-  void clear();
-
-private:
-  const GlobalCompilationDatabase &InnerCDB;
-  mutable std::mutex Mut;
-  mutable llvm::StringMap<llvm::Optional<tooling::CompileCommand>>
-      Cached; /* GUARDED_BY(Mut) */
-};
-
 /// Gets compile args from an in-memory mapping based on a filepath. Typically
 /// used by clients who provide the compile commands themselves.
 class InMemoryCompilationDb : public GlobalCompilationDatabase {
 public:
   /// Gets compile command for \p File from the stored mapping.
   llvm::Optional<tooling::CompileCommand>
   getCompileCommand(PathRef File) const override;
 

clang-tools-extra/trunk/clangd/GlobalCompilationDatabase.cpp

if (CompileCommandsDir)
     return getCDBInDirLocked(*CompileCommandsDir);
   for (auto Path = path::parent_path(File); !Path.empty();
        Path = path::parent_path(Path))
     if (auto CDB = getCDBInDirLocked(Path))
       return CDB;
   return nullptr;
 }
 
-CachingCompilationDb::CachingCompilationDb(
-    const GlobalCompilationDatabase &InnerCDB)
-    : InnerCDB(InnerCDB) {}
-
-Optional<tooling::CompileCommand>
-CachingCompilationDb::getCompileCommand(PathRef File) const {
-  std::unique_lock<std::mutex> Lock(Mut);
-  auto It = Cached.find(File);
-  if (It != Cached.end())
-    return It->second;
-
-  Lock.unlock();
-  Optional<tooling::CompileCommand> Command = InnerCDB.getCompileCommand(File);
-  Lock.lock();
-  return Cached.try_emplace(File, std::move(Command)).first->getValue();
-}
-
-tooling::CompileCommand
-CachingCompilationDb::getFallbackCommand(PathRef File) const {
-  return InnerCDB.getFallbackCommand(File);
-}
-
-void CachingCompilationDb::invalidate(PathRef File) {
-  std::unique_lock<std::mutex> Lock(Mut);
-  Cached.erase(File);
-}
-
-void CachingCompilationDb::clear() {
-  std::unique_lock<std::mutex> Lock(Mut);
-  Cached.clear();
-}
-
 Optional<tooling::CompileCommand>
 InMemoryCompilationDb::getCompileCommand(PathRef File) const {
   std::lock_guard<std::mutex> Lock(Mutex);
   auto It = Commands.find(File);
   if (It == Commands.end())
     return None;
   return It->second;
 }