[clangd] Mark results of clangd requests with a tag provided by the FileSystemProvider.

[ilya-biryukov]

Summary

This allows an implementation of FileSystemProvider that can track which vfs::FileSystem
were used for each of the requests.

[bkramer]

lg

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

 
 } // namespace
 
 class ClangdLSPServer::LSPDiagnosticsConsumer : public DiagnosticsConsumer {
 public:
   LSPDiagnosticsConsumer(ClangdLSPServer &Server) : Server(Server) {}
 
   virtual void onDiagnosticsReady(PathRef File,
-                                  std::vector<DiagWithFixIts> Diagnostics) {
-    Server.consumeDiagnostics(File, Diagnostics);
+                                  Tagged<std::vector<DiagWithFixIts>> Diagnostics) {
+    Server.consumeDiagnostics(File, Diagnostics.Value);
   }
 
 private:
   ClangdLSPServer &Server;
 };
 
 class ClangdLSPServer::LSPProtocolCallbacks : public ProtocolCallbacks {
 public:
Out.writeMessage(
       R"(]})");
 }
 
 void ClangdLSPServer::LSPProtocolCallbacks::onCompletion(
     TextDocumentPositionParams Params, StringRef ID, JSONOutput &Out) {
 
   auto Items = LangServer.Server.codeComplete(
       Params.textDocument.uri.file,
-      Position{Params.position.line, Params.position.character});
+      Position{Params.position.line, Params.position.character}).Value;
 
   std::string Completions;
   for (const auto &Item : Items) {
     Completions += CompletionItem::unparse(Item);
     Completions += ",";
   }
   if (!Completions.empty())
     Completions.pop_back();

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

 #include "ClangdUnit.h"
 #include "Protocol.h"
 
 #include <condition_variable>
 #include <functional>
 #include <mutex>
 #include <string>
 #include <thread>
+#include <type_traits>
 #include <utility>
 
 namespace clang {
 class PCHContainerOperations;
 
 namespace clangd {
 
 /// Turn a [line, column] pair into an offset in Code.
 size_t positionToOffset(StringRef Code, Position P);
 
 /// Turn an offset in Code into a [line, column] pair.
 Position offsetToPosition(StringRef Code, size_t Offset);
 
+/// A tag supplied by the FileSytemProvider.
+typedef int VFSTag;
+
+/// A value of an arbitrary type and VFSTag that was supplied by the
+/// FileSystemProvider when this value was computed.
+template <class T> class Tagged {
+public:
+  template <class U>
+  Tagged(U &&Value, VFSTag Tag) : Value(std::forward<U>(Value)), Tag(Tag) {}
+
+  template <class U>
+  Tagged(const Tagged<U> &Other) : Value(Other.Value), Tag(Other.Tag) {}
+
+  template <class U>
+  Tagged(Tagged<U> &&Other) : Value(std::move(Other.Value)), Tag(Other.Tag) {}
+
+  T Value;
+  VFSTag Tag;
+};
+
+template <class T>
+Tagged<typename std::decay<T>::type> make_tagged(T &&Value, VFSTag Tag) {
+  return Tagged<T>(std::forward<T>(Value), Tag);
+}
+
 class DiagnosticsConsumer {
 public:
   virtual ~DiagnosticsConsumer() = default;
 
   /// Called by ClangdServer when \p Diagnostics for \p File are ready.
-  virtual void onDiagnosticsReady(PathRef File,
-                                  std::vector<DiagWithFixIts> Diagnostics) = 0;
+  virtual void
+  onDiagnosticsReady(PathRef File,
+                     Tagged<std::vector<DiagWithFixIts>> Diagnostics) = 0;
 };
 
 class FileSystemProvider {
 public:
   virtual ~FileSystemProvider() = default;
-  virtual IntrusiveRefCntPtr<vfs::FileSystem> getFileSystem() = 0;
+  /// \return A filesystem that will be used for all file accesses in clangd.
+  /// A Tag returned by this method will be propagated to all results of clangd
+  /// that will use this filesystem.
+  virtual Tagged<IntrusiveRefCntPtr<vfs::FileSystem>> getTaggedFileSystem() = 0;
 };
 
 class RealFileSystemProvider : public FileSystemProvider {
 public:
-  IntrusiveRefCntPtr<vfs::FileSystem> getFileSystem() override;
+  /// \return getRealFileSystem() tagged with default tag, i.e. VFSTag()
+  Tagged<IntrusiveRefCntPtr<vfs::FileSystem>> getTaggedFileSystem() override;
 };
 
 class ClangdServer;
 
 /// Handles running WorkerRequests of ClangdServer on a separate threads.
 /// Currently runs only one worker thread.
 class ClangdScheduler {
 public:
public:
   void addDocument(PathRef File, StringRef Contents);
   /// Remove \p File from list of tracked files, schedule a request to free
   /// resources associated with it.
   void removeDocument(PathRef File);
   /// Force \p File to be reparsed using the latest contents.
   void forceReparse(PathRef File);
 
   /// Run code completion for \p File at \p Pos.
-  std::vector<CompletionItem> codeComplete(PathRef File, Position Pos);
+  Tagged<std::vector<CompletionItem>> codeComplete(PathRef File, Position Pos);
 
   /// Run formatting for \p Rng inside \p File.
   std::vector<tooling::Replacement> formatRange(PathRef File, Range Rng);
   /// Run formatting for the whole \p File.
   std::vector<tooling::Replacement> formatFile(PathRef File);
   /// Run formatting after a character was typed at \p Pos in \p File.
   std::vector<tooling::Replacement> formatOnType(PathRef File, Position Pos);
 

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

Position clangd::offsetToPosition(StringRef Code, size_t Offset) {
   StringRef JustBefore = Code.substr(0, Offset);
   // FIXME: \r\n
   // FIXME: UTF-8
   int Lines = JustBefore.count('\n');
   int Cols = JustBefore.size() - JustBefore.rfind('\n') - 1;
   return {Lines, Cols};
 }
 
-IntrusiveRefCntPtr<vfs::FileSystem> RealFileSystemProvider::getFileSystem() {
-  return vfs::getRealFileSystem();
+Tagged<IntrusiveRefCntPtr<vfs::FileSystem>>
+RealFileSystemProvider::getTaggedFileSystem() {
+  return make_tagged(vfs::getRealFileSystem(), VFSTag());
 }
 
 ClangdScheduler::ClangdScheduler(bool RunSynchronously)
     : RunSynchronously(RunSynchronously) {
   if (RunSynchronously) {
     // Don't start the worker thread if we're running synchronously
     return;
   }
void ClangdServer::addDocument(PathRef File, StringRef Contents) {
   Path FileStr = File;
   WorkScheduler.addToFront([this, FileStr, Version]() {
     auto FileContents = DraftMgr.getDraft(FileStr);
     if (FileContents.Version != Version)
       return; // This request is outdated, do nothing
 
     assert(FileContents.Draft &&
            "No contents inside a file that was scheduled for reparse");
-    Units.runOnUnit(FileStr, *FileContents.Draft, *CDB, PCHs,
-                    FSProvider->getFileSystem(), [&](ClangdUnit const &Unit) {
-                      DiagConsumer->onDiagnosticsReady(
-                          FileStr, Unit.getLocalDiagnostics());
-                    });
+    auto TaggedFS = FSProvider->getTaggedFileSystem();
+    Units.runOnUnit(
+        FileStr, *FileContents.Draft, *CDB, PCHs, TaggedFS.Value,
+        [&](ClangdUnit const &Unit) {
+              FileStr, make_tagged(Unit.getLocalDiagnostics(), TaggedFS.Tag));
   });
 }
 
 void ClangdServer::removeDocument(PathRef File) {
   auto Version = DraftMgr.removeDraft(File);
   Path FileStr = File;
   WorkScheduler.addToFront([this, FileStr, Version]() {
     if (Version != DraftMgr.getVersion(FileStr))
       return; // This request is outdated, do nothing
 
     Units.removeUnitIfPresent(FileStr);
   });
 }
 
 void ClangdServer::forceReparse(PathRef File) {
   // The addDocument schedules the reparse even if the contents of the file
   // never changed, so we just call it here.
   addDocument(File, getDocument(File));
 }
 
-std::vector<CompletionItem> ClangdServer::codeComplete(PathRef File,
+Tagged<std::vector<CompletionItem>> ClangdServer::codeComplete(PathRef File,
                                                                Position Pos) {
   auto FileContents = DraftMgr.getDraft(File);
   assert(FileContents.Draft && "codeComplete is called for non-added document");
 
   std::vector<CompletionItem> Result;
-  auto VFS = FSProvider->getFileSystem();
+  auto TaggedFS = FSProvider->getTaggedFileSystem();
   Units.runOnUnitWithoutReparse(
-      File, *FileContents.Draft, *CDB, PCHs, VFS, [&](ClangdUnit &Unit) {
-        Result = Unit.codeComplete(*FileContents.Draft, Pos, VFS);
+      File, *FileContents.Draft, *CDB, PCHs, TaggedFS.Value, [&](ClangdUnit &Unit) {
+        Result = Unit.codeComplete(*FileContents.Draft, Pos, TaggedFS.Value);
       });
-  return Result;
+  return make_tagged(std::move(Result), TaggedFS.Tag);
 }
 
 std::vector<tooling::Replacement> ClangdServer::formatRange(PathRef File,
                                                             Range Rng) {
   std::string Code = getDocument(File);
 
   size_t Begin = positionToOffset(Code, Rng.start);
   size_t Len = positionToOffset(Code, Rng.end) - Begin;

clang-tools-extra/trunk/unittests/clangd/ClangdTests.cpp

 } // namespace vfs
 
 namespace clangd {
 namespace {
 
 class ErrorCheckingDiagConsumer : public DiagnosticsConsumer {
 public:
   void onDiagnosticsReady(PathRef File,
-                          std::vector<DiagWithFixIts> Diagnostics) override {
+                          Tagged<std::vector<DiagWithFixIts>> Diagnostics) override {
     bool HadError = false;
-    for (const auto &DiagAndFixIts : Diagnostics) {
+    for (const auto &DiagAndFixIts : Diagnostics.Value) {
       // FIXME: severities returned by clangd should have a descriptive
       // diagnostic severity enum
       const int ErrorSeverity = 1;
       HadError = DiagAndFixIts.Diag.severity == ErrorSeverity;
     }
 
     std::lock_guard<std::mutex> Lock(Mutex);
     HadErrorInLastDiags = HadError;
+    LastVFSTag = Diagnostics.Tag;
   }
 
   bool hadErrorInLastDiags() {
     std::lock_guard<std::mutex> Lock(Mutex);
     return HadErrorInLastDiags;
   }
 
+  VFSTag lastVFSTag() {
+    return LastVFSTag;
+  }
+
 private:
   std::mutex Mutex;
   bool HadErrorInLastDiags = false;
+  VFSTag LastVFSTag = VFSTag();
 };
 
 class MockCompilationDatabase : public GlobalCompilationDatabase {
 public:
   std::vector<tooling::CompileCommand>
   getCompileCommands(PathRef File) override {
     return {};
   }
 };
 
 class MockFSProvider : public FileSystemProvider {
 public:
-  IntrusiveRefCntPtr<vfs::FileSystem> getFileSystem() override {
+  Tagged<IntrusiveRefCntPtr<vfs::FileSystem>> getTaggedFileSystem() override {
     IntrusiveRefCntPtr<vfs::InMemoryFileSystem> MemFS(
         new vfs::InMemoryFileSystem);
     for (auto &FileAndContents : Files)
       MemFS->addFile(FileAndContents.first(), time_t(),
                      llvm::MemoryBuffer::getMemBuffer(FileAndContents.second,
                                                       FileAndContents.first()));
 
     auto OverlayFS = IntrusiveRefCntPtr<vfs::OverlayFileSystem>(
         new vfs::OverlayFileSystem(vfs::getTempOnlyFS()));
     OverlayFS->pushOverlay(std::move(MemFS));
-    return OverlayFS;
+    return make_tagged(OverlayFS, Tag);
   }
 
   llvm::StringMap<std::string> Files;
+  VFSTag Tag = VFSTag();
 };
 
 /// Replaces all patterns of the form 0x123abc with spaces
 std::string replacePtrsInDump(std::string const &Dump) {
   llvm::Regex RE("0x[0-9a-fA-F]+");
   llvm::SmallVector<StringRef, 1> Matches;
   llvm::StringRef Pending = Dump;
 
)cpp";
   Server.forceReparse(FooCpp);
   auto DumpParse2 = dumpASTWithoutMemoryLocs(Server, FooCpp);
   EXPECT_FALSE(DiagConsumer->hadErrorInLastDiags());
 
   EXPECT_EQ(DumpParse1, DumpParse2);
   EXPECT_NE(DumpParse1, DumpParseDifferent);
 }
 
+TEST_F(ClangdVFSTest, CheckVersions) {
+  MockFSProvider *FS;
+  ErrorCheckingDiagConsumer *DiagConsumer;
+
+  ClangdServer Server(
+      llvm::make_unique<MockCompilationDatabase>(),
+      getAndMove(llvm::make_unique<ErrorCheckingDiagConsumer>(), DiagConsumer),
+      getAndMove(llvm::make_unique<MockFSProvider>(), FS),
+      /*RunSynchronously=*/true);
+
+  auto FooCpp = getVirtualTestFilePath("foo.cpp");
+  const auto SourceContents = "int a;";
+  FS->Files[FooCpp] = SourceContents;
+  FS->Tag = 123;
+
+  Server.addDocument(FooCpp, SourceContents);
+  EXPECT_EQ(DiagConsumer->lastVFSTag(), FS->Tag);
+  EXPECT_EQ(Server.codeComplete(FooCpp, Position{0, 0}).Tag, FS->Tag);
+
+  FS->Tag = 321;
+  Server.addDocument(FooCpp, SourceContents);
+  EXPECT_EQ(DiagConsumer->lastVFSTag(), FS->Tag);
+  EXPECT_EQ(Server.codeComplete(FooCpp, Position{0, 0}).Tag, FS->Tag);
+}
+
 } // namespace clangd
 } // namespace clang