[clangd] Don't invalidate LSP-set compile commands when closing a file.

[sammccall]

Summary

It doesn't make much sense: setting them is not coupled to opening the file,
it's an asynchronous notification.

I don't think this is a breaking change - this behavior is hard to observe!

[ilya-biryukov]

LGTM. Good catch!

clangd/ClangdLSPServer.h

private:
   /// Encapsulates the directory-based or the in-memory compilation database
   /// that's used by the LSP server.
   class CompilationDB {
   public:
     static CompilationDB makeInMemory();
     static CompilationDB
     makeDirectoryBased(llvm::Optional<Path> CompileCommandsDir);
 
-    void invalidate(PathRef File);
-
     /// Sets the compilation command for a particular file.
     /// Only valid for in-memory CDB, no-op and error log on DirectoryBasedCDB.
     ///
     /// \returns True if the File had no compilation command before.
     bool
     setCompilationCommandForFile(PathRef File,
                                  tooling::CompileCommand CompilationCommand);
 

clangd/ClangdLSPServer.cpp

void ClangdLSPServer::onDocumentDidChange(
   Expected<std::string> Contents =
       DraftMgr.updateDraft(File, Params.contentChanges);
   if (!Contents) {
     // If this fails, we are most likely going to be not in sync anymore with
     // the client.  It is better to remove the draft and let further operations
     // fail rather than giving wrong results.
     DraftMgr.removeDraft(File);
     Server->removeDocument(File);
-    CDB->invalidate(File);
     elog("Failed to update {0}: {1}", File, Contents.takeError());
     return;
   }
 
   Server->addDocument(File, *Contents, WantDiags);
 }
 
 void ClangdLSPServer::onFileEvent(const DidChangeWatchedFilesParams &Params) {
Server->rename(
           std::move(Reply)));
 }
 
 void ClangdLSPServer::onDocumentDidClose(
     const DidCloseTextDocumentParams &Params) {
   PathRef File = Params.textDocument.uri.file();
   DraftMgr.removeDraft(File);
   Server->removeDocument(File);
-  CDB->invalidate(File);
 }
 
 void ClangdLSPServer::onDocumentOnTypeFormatting(
     const DocumentOnTypeFormattingParams &Params,
     Callback<std::vector<TextEdit>> Reply) {
   auto File = Params.textDocument.uri.file();
   auto Code = DraftMgr.getDraft(File);
   if (!Code)

 ClangdLSPServer::CompilationDB::makeDirectoryBased(
     Optional<Path> CompileCommandsDir) {
   auto CDB = llvm::make_unique<DirectoryBasedGlobalCompilationDatabase>(
       std::move(CompileCommandsDir));
   return CompilationDB(std::move(CDB),
                        /*IsDirectoryBased=*/true);
 }
 
-void ClangdLSPServer::CompilationDB::invalidate(PathRef File) {
-  if (!IsDirectoryBased)
-    static_cast<InMemoryCompilationDb *>(CDB.get())->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;
   }

clangd/GlobalCompilationDatabase.h

public:
   getCompileCommand(PathRef File) const override;
 
   /// Sets the compilation command for a particular file.
   ///
   /// \returns True if the File had no compilation command before.
   bool setCompilationCommandForFile(PathRef File,
                                     tooling::CompileCommand CompilationCommand);
 
-  /// Removes the compilation command for \p File if it's present in the
-  /// mapping.
-  void invalidate(PathRef File);
-
 private:
   mutable std::mutex Mutex;
   llvm::StringMap<tooling::CompileCommand> Commands; /* GUARDED_BY(Mut) */
 };
 
 } // namespace clangd
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_GLOBALCOMPILATIONDATABASE_H

clangd/GlobalCompilationDatabase.cpp

bool InMemoryCompilationDb::setCompilationCommandForFile(
   std::unique_lock<std::mutex> Lock(Mutex);
   auto ItInserted = Commands.insert(std::make_pair(File, CompilationCommand));
   if (ItInserted.second)
     return true;
   ItInserted.first->setValue(std::move(CompilationCommand));
   return false;
 }
 
-void InMemoryCompilationDb::invalidate(PathRef File) {
-  std::unique_lock<std::mutex> Lock(Mutex);
-  Commands.erase(File);
-}
-
 } // namespace clangd
 } // namespace clang