[clangd] Allow to use vfs::FileSystem for file accesses.

[ilya-biryukov]

Summary

Custom vfs::FileSystem is currently used for unit tests.
This revision depends on https://reviews.llvm.org/D33397.

[bkramer]

unittests/clangd/ClangdTests.cpp

119

We should delete those when we're done, otherwise the unit test will litter /tmp on every run.

[ilya-biryukov]

unittests/clangd/ClangdTests.cpp

119

ASTUnit handles that, right?
It's only here to provide access to PCHs ASTUnit creates, we don't actually write to those dirs ourselves.

[ilya-biryukov]

Changed tests to use Windows-style paths for virtual directory when running on Windows.

[krasimir]

unittests/clangd/ClangdTests.cpp

298

Move this to the previous line.

336

Move this to the previous line.

[ilya-biryukov]

Minor refactoring to address @krasimir's comments

[bkramer]

Looks good. Make sure to watch the windows buildbots after submitting.

[ilya-biryukov]

• Fixed file comment of ClangdTests.cpp

[chapuni]

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

123 ↗

(On Diff #100389)

Did you mean, "TmpDir1 != TmpDir2" ?
Fixed in r304067.

[ilya-biryukov]

Thanks for fixing the failures. Sorry for not being around to look into that myself.

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

123 ↗

(On Diff #100389)

I sure did. Thanks.

clangd/ClangdLSPServer.cpp

Out.writeMessage(
       R"({"jsonrpc":"2.0","id":)" + ID.str() +
       R"(,"result":[)" + Completions + R"(]})");
 }
 
 ClangdLSPServer::ClangdLSPServer(JSONOutput &Out, bool RunSynchronously)
     : Out(Out),
       Server(llvm::make_unique<DirectoryBasedGlobalCompilationDatabase>(),
              llvm::make_unique<LSPDiagnosticsConsumer>(*this),
+             llvm::make_unique<RealFileSystemProvider>(),
              RunSynchronously) {}
 
 void ClangdLSPServer::run(std::istream &In) {
   assert(!IsDone && "Run was called before");
 
   // Set up JSONRPCDispatcher.
   LSPProtocolCallbacks Callbacks(*this);
   JSONRPCDispatcher Dispatcher(llvm::make_unique<Handler>(Out));

clangd/ClangdServer.h

 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;
 };
 
+class FileSystemProvider {
+public:
+  virtual ~FileSystemProvider() = default;
+  virtual IntrusiveRefCntPtr<vfs::FileSystem> getFileSystem() = 0;
+};
+
+class RealFileSystemProvider : public FileSystemProvider {
+public:
+  IntrusiveRefCntPtr<vfs::FileSystem> getFileSystem() override;
+};
+
 class ClangdServer;
 
 /// Handles running WorkerRequests of ClangdServer on a separate threads.
 /// Currently runs only one worker thread.
 class ClangdScheduler {
 public:
   ClangdScheduler(bool RunSynchronously);
   ~ClangdScheduler();

 
 /// Provides API to manage ASTs for a collection of C++ files and request
 /// various language features(currently, only codeCompletion and async
 /// diagnostics for tracked files).
 class ClangdServer {
 public:
   ClangdServer(std::unique_ptr<GlobalCompilationDatabase> CDB,
                std::unique_ptr<DiagnosticsConsumer> DiagConsumer,
+               std::unique_ptr<FileSystemProvider> FSProvider,
                bool RunSynchronously);
 
   /// Add a \p File to the list of tracked C++ files or update the contents if
   /// \p File is already tracked. Also schedules parsing of the AST for it on a
   /// separate thread. When the parsing is complete, DiagConsumer passed in
   /// constructor will receive onDiagnosticsReady callback.
   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);
 
   /// 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);
public:
   /// Only for testing purposes.
   /// Waits until all requests to worker thread are finished and dumps AST for
   /// \p File. \p File must be in the list of added documents.
   std::string dumpAST(PathRef File);
 
 private:
   std::unique_ptr<GlobalCompilationDatabase> CDB;
   std::unique_ptr<DiagnosticsConsumer> DiagConsumer;
+  std::unique_ptr<FileSystemProvider> FSProvider;
   DraftStore DraftMgr;
   ClangdUnitStore Units;
   std::shared_ptr<PCHContainerOperations> PCHs;
   // WorkScheduler has to be the last member, because its destructor has to be
   // called before all other members to stop the worker thread that references
   // ClangdServer
   ClangdScheduler WorkScheduler;
 };
 
 } // namespace clangd
 } // namespace clang
 
 #endif

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();
+}
+
 ClangdScheduler::ClangdScheduler(bool RunSynchronously)
     : RunSynchronously(RunSynchronously) {
   if (RunSynchronously) {
     // Don't start the worker thread if we're running synchronously
     return;
   }
 
   // Initialize Worker in ctor body, rather than init list to avoid potentially
if (RunSynchronously) {
     std::lock_guard<std::mutex> Lock(Mutex);
     RequestQueue.push_back(Request);
   }
   RequestCV.notify_one();
 }
 
 ClangdServer::ClangdServer(std::unique_ptr<GlobalCompilationDatabase> CDB,
                            std::unique_ptr<DiagnosticsConsumer> DiagConsumer,
+                           std::unique_ptr<FileSystemProvider> FSProvider,
                            bool RunSynchronously)
     : CDB(std::move(CDB)), DiagConsumer(std::move(DiagConsumer)),
+      FSProvider(std::move(FSProvider)),
       PCHs(std::make_shared<PCHContainerOperations>()),
       WorkScheduler(RunSynchronously) {}
 
 void ClangdServer::addDocument(PathRef File, StringRef Contents) {
   DocVersion Version = DraftMgr.updateDraft(File, 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, [&](ClangdUnit const &Unit) {
-          DiagConsumer->onDiagnosticsReady(FileStr, Unit.getLocalDiagnostics());
+    Units.runOnUnit(FileStr, *FileContents.Draft, *CDB, PCHs,
+                    FSProvider->getFileSystem(), [&](ClangdUnit const &Unit) {
+                      DiagConsumer->onDiagnosticsReady(
+                          FileStr, Unit.getLocalDiagnostics());
                     });
   });
 }
 
 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,
                                                        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();
   Units.runOnUnitWithoutReparse(
-      File, *FileContents.Draft, *CDB, PCHs, [&](ClangdUnit &Unit) {
-        Result = Unit.codeComplete(*FileContents.Draft, Pos);
+      File, *FileContents.Draft, *CDB, PCHs, VFS, [&](ClangdUnit &Unit) {
+        Result = Unit.codeComplete(*FileContents.Draft, Pos, VFS);
       });
   return Result;
 }
 
 std::vector<tooling::Replacement> ClangdServer::formatRange(PathRef File,
                                                             Range Rng) {
   std::string Code = getDocument(File);
 

clangd/ClangdUnit.h

 //===--- ClangdUnit.h -------------------------------------------*- C++-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===---------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_CLANGDUNIT_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_CLANGDUNIT_H
 
-#include "Protocol.h"
 #include "Path.h"
+#include "Protocol.h"
 #include "clang/Frontend/ASTUnit.h"
 #include "clang/Tooling/Core/Replacement.h"
 #include <memory>
 
 namespace llvm {
 class raw_ostream;
 }
 
 namespace clang {
 class ASTUnit;
 class PCHContainerOperations;
 
+namespace vfs {
+class FileSystem;
+}
+
 namespace tooling {
 struct CompileCommand;
 }
 
 namespace clangd {
 
 /// A diagnostic with its FixIts.
 struct DiagWithFixIts {
   clangd::Diagnostic Diag;
   llvm::SmallVector<tooling::Replacement, 1> FixIts;
 };
 
 /// Stores parsed C++ AST and provides implementations of all operations clangd
 /// would want to perform on parsed C++ files.
 class ClangdUnit {
 public:
   ClangdUnit(PathRef FileName, StringRef Contents,
              std::shared_ptr<PCHContainerOperations> PCHs,
-             std::vector<tooling::CompileCommand> Commands);
+             std::vector<tooling::CompileCommand> Commands,
+             IntrusiveRefCntPtr<vfs::FileSystem> VFS);
 
   /// Reparse with new contents.
-  void reparse(StringRef Contents);
+  void reparse(StringRef Contents, IntrusiveRefCntPtr<vfs::FileSystem> VFS);
 
   /// Get code completions at a specified \p Line and \p Column in \p File.
   ///
   /// This function is thread-safe and returns completion items that own the
   /// data they contain.
-  std::vector<CompletionItem> codeComplete(StringRef Contents, Position Pos);
+  std::vector<CompletionItem>
+  codeComplete(StringRef Contents, Position Pos,
+               IntrusiveRefCntPtr<vfs::FileSystem> VFS);
   /// Returns diagnostics and corresponding FixIts for each diagnostic that are
   /// located in the current file.
   std::vector<DiagWithFixIts> getLocalDiagnostics() const;
 
   /// For testing/debugging purposes. Note that this method deserializes all
   /// unserialized Decls, so use with care.
   void dumpAST(llvm::raw_ostream &OS) const;
 

clangd/ClangdUnit.cpp

 //===--- ClangdUnit.cpp -----------------------------------------*- C++-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===---------------------------------------------------------------------===//
 
 #include "ClangdUnit.h"
 #include "clang/Frontend/ASTUnit.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/CompilerInvocation.h"
+#include "clang/Frontend/Utils.h"
 #include "clang/Tooling/CompilationDatabase.h"
 
 using namespace clang::clangd;
 using namespace clang;
 
 ClangdUnit::ClangdUnit(PathRef FileName, StringRef Contents,
                        std::shared_ptr<PCHContainerOperations> PCHs,
-                       std::vector<tooling::CompileCommand> Commands)
+                       std::vector<tooling::CompileCommand> Commands,
+                       IntrusiveRefCntPtr<vfs::FileSystem> VFS)
     : FileName(FileName), PCHs(PCHs) {
   assert(!Commands.empty() && "No compile commands provided");
 
   // Inject the resource dir.
   // FIXME: Don't overwrite it if it's already there.
   static int Dummy; // Just an address in this process.
   std::string ResourceDir =
       CompilerInvocation::GetResourcesPath("clangd", (void *)&Dummy);
ClangdUnit::ClangdUnit(PathRef FileName, StringRef Contents,
   auto ArgP = &*ArgStrs.begin();
   Unit = std::unique_ptr<ASTUnit>(ASTUnit::LoadFromCommandLine(
       ArgP, ArgP + ArgStrs.size(), PCHs, Diags, ResourceDir,
       /*OnlyLocalDecls=*/false, /*CaptureDiagnostics=*/true, RemappedSource,
       /*RemappedFilesKeepOriginalName=*/true,
       /*PrecompilePreambleAfterNParses=*/1, /*TUKind=*/TU_Prefix,
       /*CacheCodeCompletionResults=*/true,
       /*IncludeBriefCommentsInCodeCompletion=*/true,
-      /*AllowPCHWithCompilerErrors=*/true));
+      /*AllowPCHWithCompilerErrors=*/true,
+      /*SkipFunctionBodies=*/false,
+      /*UserFilesAreVolatile=*/false, /*ForSerialization=*/false,
+      /*ModuleFormat=*/llvm::None,
+      /*ErrAST=*/nullptr, VFS));
+  assert(Unit && "Unit wasn't created");
 }
 
-void ClangdUnit::reparse(StringRef Contents) {
+void ClangdUnit::reparse(StringRef Contents,
+                         IntrusiveRefCntPtr<vfs::FileSystem> VFS) {
   // Do a reparse if this wasn't the first parse.
   // FIXME: This might have the wrong working directory if it changed in the
   // meantime.
   ASTUnit::RemappedFile RemappedSource(
       FileName,
       llvm::MemoryBuffer::getMemBufferCopy(Contents, FileName).release());
 
-  Unit->Reparse(PCHs, RemappedSource);
+  Unit->Reparse(PCHs, RemappedSource, VFS);
 }
 
 namespace {
 
 CompletionItemKind getKind(CXCursorKind K) {
   switch (K) {
   case CXCursor_MacroInstantiation:
   case CXCursor_MacroDefinition:
public:
   }
 
   GlobalCodeCompletionAllocator &getAllocator() override { return *Allocator; }
 
   CodeCompletionTUInfo &getCodeCompletionTUInfo() override { return CCTUInfo; }
 };
 } // namespace
 
-std::vector<CompletionItem> ClangdUnit::codeComplete(StringRef Contents,
-                                                     Position Pos) {
+std::vector<CompletionItem>
+ClangdUnit::codeComplete(StringRef Contents, Position Pos,
+                         IntrusiveRefCntPtr<vfs::FileSystem> VFS) {
   CodeCompleteOptions CCO;
   CCO.IncludeBriefComments = 1;
   // This is where code completion stores dirty buffers. Need to free after
   // completion.
   SmallVector<const llvm::MemoryBuffer *, 4> OwnedBuffers;
   SmallVector<StoredDiagnostic, 4> StoredDiagnostics;
   IntrusiveRefCntPtr<DiagnosticsEngine> DiagEngine(
       new DiagnosticsEngine(new DiagnosticIDs, new DiagnosticOptions));
   std::vector<CompletionItem> Items;
   CompletionItemsCollector Collector(&Items, CCO);
 
   ASTUnit::RemappedFile RemappedSource(
       FileName,
       llvm::MemoryBuffer::getMemBufferCopy(Contents, FileName).release());
 
+  IntrusiveRefCntPtr<FileManager> FileMgr(
+      new FileManager(Unit->getFileSystemOpts(), VFS));
   IntrusiveRefCntPtr<SourceManager> SourceMgr(
-      new SourceManager(*DiagEngine, Unit->getFileManager()));
+      new SourceManager(*DiagEngine, *FileMgr));
   // CodeComplete seems to require fresh LangOptions.
   LangOptions LangOpts = Unit->getLangOpts();
   // The language server protocol uses zero-based line and column numbers.
   // The clang code completion uses one-based numbers.
   Unit->CodeComplete(FileName, Pos.line + 1, Pos.character + 1, RemappedSource,
                      CCO.IncludeMacros, CCO.IncludeCodePatterns,
                      CCO.IncludeBriefComments, Collector, PCHs, *DiagEngine,
-                     LangOpts, *SourceMgr, Unit->getFileManager(),
-                     StoredDiagnostics, OwnedBuffers);
+                     LangOpts, *SourceMgr, *FileMgr, StoredDiagnostics,
+                     OwnedBuffers);
   for (const llvm::MemoryBuffer *Buffer : OwnedBuffers)
     delete Buffer;
   return Items;
 }
 
 namespace {
 /// Convert from clang diagnostic level to LSP severity.
 static int getSeverity(DiagnosticsEngine::Level L) {

clangd/ClangdUnitStore.h

public:
   /// Run specified \p Action on the ClangdUnit for \p File.
   /// If the file is not present in ClangdUnitStore, a new ClangdUnit will be
   /// created from the \p FileContents. If the file is already present in the
   /// store, ClangdUnit::reparse will be called with the new contents before
   /// running \p Action.
   template <class Func>
   void runOnUnit(PathRef File, StringRef FileContents,
                  GlobalCompilationDatabase &CDB,
-                 std::shared_ptr<PCHContainerOperations> PCHs, Func Action) {
+                 std::shared_ptr<PCHContainerOperations> PCHs,
+                 IntrusiveRefCntPtr<vfs::FileSystem> VFS, Func Action) {
     runOnUnitImpl(File, FileContents, CDB, PCHs, /*ReparseBeforeAction=*/true,
-                  std::forward<Func>(Action));
+                  VFS, std::forward<Func>(Action));
   }
 
   /// Run specified \p Action on the ClangdUnit for \p File.
   /// If the file is not present in ClangdUnitStore, a new ClangdUnit will be
   /// created from the \p FileContents. If the file is already present in the
   /// store, the \p Action will be run directly on it.
   template <class Func>
   void runOnUnitWithoutReparse(PathRef File, StringRef FileContents,
                                GlobalCompilationDatabase &CDB,
                                std::shared_ptr<PCHContainerOperations> PCHs,
+                               IntrusiveRefCntPtr<vfs::FileSystem> VFS,
                                Func Action) {
     runOnUnitImpl(File, FileContents, CDB, PCHs, /*ReparseBeforeAction=*/false,
-                  std::forward<Func>(Action));
+                  VFS, std::forward<Func>(Action));
   }
 
   /// Run the specified \p Action on the ClangdUnit for \p File.
   /// Unit for \p File should exist in the store.
   template <class Func>
   void runOnExistingUnit(PathRef File, Func Action) {
     std::lock_guard<std::mutex> Lock(Mutex);
 
     auto It = OpenedFiles.find(File);
     assert(It != OpenedFiles.end() && "File is not in OpenedFiles");
 
     Action(It->second);
   }
 
   /// Remove ClangdUnit for \p File, if any
   void removeUnitIfPresent(PathRef File);
 
 private:
   /// Run specified \p Action on the ClangdUnit for \p File.
   template <class Func>
   void runOnUnitImpl(PathRef File, StringRef FileContents,
                      GlobalCompilationDatabase &CDB,
                      std::shared_ptr<PCHContainerOperations> PCHs,
-                     bool ReparseBeforeAction, Func Action) {
+                     bool ReparseBeforeAction,
+                     IntrusiveRefCntPtr<vfs::FileSystem> VFS, Func Action) {
     std::lock_guard<std::mutex> Lock(Mutex);
 
     auto Commands = getCompileCommands(CDB, File);
     assert(!Commands.empty() &&
            "getCompileCommands should add default command");
-    // chdir. This is thread hostile.
-    // FIXME(ibiryukov): get rid of this
-    llvm::sys::fs::set_current_path(Commands.front().Directory);
+    VFS->setCurrentWorkingDirectory(Commands.front().Directory);
 
     auto It = OpenedFiles.find(File);
     if (It == OpenedFiles.end()) {
       It = OpenedFiles
                .insert(std::make_pair(
-                   File, ClangdUnit(File, FileContents, PCHs, Commands)))
+                   File, ClangdUnit(File, FileContents, PCHs, Commands, VFS)))
                .first;
     } else if (ReparseBeforeAction) {
-      It->second.reparse(FileContents);
+      It->second.reparse(FileContents, VFS);
     }
     return Action(It->second);
   }
 
   std::vector<tooling::CompileCommand>
   getCompileCommands(GlobalCompilationDatabase &CDB, PathRef File);
 
   std::mutex Mutex;
   llvm::StringMap<ClangdUnit> OpenedFiles;
 };
 } // namespace clangd
 } // namespace clang
 
 #endif

unittests/CMakeLists.txt

 add_custom_target(ExtraToolsUnitTests)
 set_target_properties(ExtraToolsUnitTests PROPERTIES FOLDER "Extra Tools Unit Tests")
 
 function(add_extra_unittest test_dirname)
   add_unittest(ExtraToolsUnitTests ${test_dirname} ${ARGN})
 endfunction()
 
 add_subdirectory(change-namespace)
 add_subdirectory(clang-apply-replacements)
 add_subdirectory(clang-move)
 add_subdirectory(clang-query)
 add_subdirectory(clang-tidy)
 add_subdirectory(clang-rename)
+add_subdirectory(clangd)
 add_subdirectory(include-fixer)

unittests/clangd/CMakeLists.txt

+set(LLVM_LINK_COMPONENTS
+  support
+  )
+
+get_filename_component(CLANGD_SOURCE_DIR
+  ${CMAKE_CURRENT_SOURCE_DIR}/../../clangd REALPATH)
+include_directories(
+  ${CLANGD_SOURCE_DIR}
+  )
+
+add_extra_unittest(ClangdTests
+  ClangdTests.cpp
+  )
+
+target_link_libraries(ClangdTests
+  clangBasic
+  clangDaemon
+  clangFormat
+  clangFrontend
+  clangSema
+  clangTooling
+  clangToolingCore
+  LLVMSupport
+  )

unittests/clangd/ClangdTests.cpp

+//===-- ClangdTes.cpp - Change namespace unit tests ---*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ClangdServer.h"
+#include "clang/Basic/VirtualFileSystem.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/Config/config.h"
+#include "llvm/Support/Errc.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/Regex.h"
+#include "gtest/gtest.h"
+#include <algorithm>
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace clang {
+namespace vfs {
+
+/// An implementation of vfs::FileSystem that only allows access to
+/// files and folders inside a set of whitelisted directories.
+///
+/// FIXME(ibiryukov): should it also emulate access to parents of whitelisted
+/// directories with only whitelisted contents?
+class FilteredFileSystem : public vfs::FileSystem {
+public:
+  /// The paths inside \p WhitelistedDirs should be absolute
+  FilteredFileSystem(std::vector<std::string> WhitelistedDirs,
+                     IntrusiveRefCntPtr<vfs::FileSystem> InnerFS)
+      : WhitelistedDirs(std::move(WhitelistedDirs)), InnerFS(InnerFS) {
+    assert(std::all_of(WhitelistedDirs.begin(), WhitelistedDirs.end(),
+                       [](const std::string &Path) -> bool {
+                         return llvm::sys::path::is_absolute(Path);
+                       }) &&
+           "Not all WhitelistedDirs are absolute");
+  }
+
+  virtual llvm::ErrorOr<Status> status(const Twine &Path) {
+    if (!isInsideWhitelistedDir(Path))
+      return llvm::errc::no_such_file_or_directory;
+    return InnerFS->status(Path);
+  }
+
+  virtual llvm::ErrorOr<std::unique_ptr<File>>
+  openFileForRead(const Twine &Path) {
+    if (!isInsideWhitelistedDir(Path))
+      return llvm::errc::no_such_file_or_directory;
+    return InnerFS->openFileForRead(Path);
+  }
+
+  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
+  getBufferForFile(const Twine &Name, int64_t FileSize = -1,
+                   bool RequiresNullTerminator = true,
+                   bool IsVolatile = false) {
+    if (!isInsideWhitelistedDir(Name))
+      return llvm::errc::no_such_file_or_directory;
+    return InnerFS->getBufferForFile(Name, FileSize, RequiresNullTerminator,
+                                     IsVolatile);
+  }
+
+  virtual directory_iterator dir_begin(const Twine &Dir, std::error_code &EC) {
+    if (!isInsideWhitelistedDir(Dir)) {
+      EC = llvm::errc::no_such_file_or_directory;
+      return directory_iterator();
+    }
+    return InnerFS->dir_begin(Dir, EC);
+  }
+
+  virtual std::error_code setCurrentWorkingDirectory(const Twine &Path) {
+    return InnerFS->setCurrentWorkingDirectory(Path);
+  }
+
+  virtual llvm::ErrorOr<std::string> getCurrentWorkingDirectory() const {
+    return InnerFS->getCurrentWorkingDirectory();
+  }
+
+  bool exists(const Twine &Path) {
+    if (!isInsideWhitelistedDir(Path))
+      return false;
+    return InnerFS->exists(Path);
+  }
+
+  std::error_code makeAbsolute(SmallVectorImpl<char> &Path) const {
+    return InnerFS->makeAbsolute(Path);
+  }
+
+private:
+  bool isInsideWhitelistedDir(const Twine &InputPath) const {
+    SmallString<128> Path;
+    InputPath.toVector(Path);
+
+    if (makeAbsolute(Path))
+      return false;
+
+    for (const auto &Dir : WhitelistedDirs) {
+      if (Path.startswith(Dir))
+        return true;
+    }
+    return false;
+  }
+
+  std::vector<std::string> WhitelistedDirs;
+  IntrusiveRefCntPtr<vfs::FileSystem> InnerFS;
+};
+
+/// Create a vfs::FileSystem that has access only to temporary directories
+/// (obtained by calling system_temp_directory).
+IntrusiveRefCntPtr<vfs::FileSystem> getTempOnlyFS() {
+  llvm::SmallString<128> TmpDir1;
+  llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false, TmpDir1);
+  llvm::SmallString<128> TmpDir2;
+  llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/true, TmpDir2);
+
+  std::vector<std::string> TmpDirs;
+  TmpDirs.push_back(TmpDir1.str());
+  if (TmpDir2 != TmpDir2)
+    TmpDirs.push_back(TmpDir2.str());
+  return new vfs::FilteredFileSystem(std::move(TmpDirs),
+                                     vfs::getRealFileSystem());
+}
+} // namespace vfs
+
+namespace clangd {
+namespace {
+
+class ErrorCheckingDiagConsumer : public DiagnosticsConsumer {
+public:
+  void onDiagnosticsReady(PathRef File,
+                          std::vector<DiagWithFixIts> Diagnostics) override {
+    bool HadError = false;
+    for (const auto &DiagAndFixIts : Diagnostics) {
+      // 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;
+  }
+
+  bool hadErrorInLastDiags() {
+    std::lock_guard<std::mutex> Lock(Mutex);
+    return HadErrorInLastDiags;
+  }
+
+private:
+  std::mutex Mutex;
+  bool HadErrorInLastDiags = false;
+};
+
+class MockCompilationDatabase : public GlobalCompilationDatabase {
+public:
+  std::vector<tooling::CompileCommand>
+  getCompileCommands(PathRef File) override {
+    return {};
+  }
+};
+
+class MockFSProvider : public FileSystemProvider {
+public:
+  IntrusiveRefCntPtr<vfs::FileSystem> getFileSystem() 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;
+  }
+
+  llvm::StringMap<std::string> Files;
+};
+
+/// Replaces all patterns of the form 0x123abc with spaces
+void replacePtrsInDump(std::string &Dump) {
+  llvm::Regex RE("0x[0-9a-fA-F]+");
+  llvm::SmallVector<StringRef, 1> Matches;
+  while (RE.match(Dump, &Matches)) {
+    assert(Matches.size() == 1 && "Exactly one match expected");
+    auto MatchPos = Matches[0].data() - Dump.data();
+    std::fill(Dump.begin() + MatchPos,
+              Dump.begin() + MatchPos + Matches[0].size(), ' ');
+  }
+}
+
+std::string dumpASTWithoutMemoryLocs(ClangdServer &Server, PathRef File) {
+  auto Dump = Server.dumpAST(File);
+  replacePtrsInDump(Dump);
+  return Dump;
+}
+
+template <class T>
+std::unique_ptr<T> getAndMove(std::unique_ptr<T> Ptr, T *&Output) {
+  Output = Ptr.get();
+  return Ptr;
+}
+} // namespace
+
+class ClangdVFSTest : public ::testing::Test {
+protected:
+  SmallString<16> getVirtualTestRoot() {
+#ifdef LLVM_ON_WIN32
+    return SmallString<16>("C:\\clangd-test");
+#else
+    return SmallString<16>("/clangd-test");
+#endif
+  }
+
+  llvm::SmallString<32> getVirtualTestFilePath(PathRef File) {
+    assert(llvm::sys::path::is_relative(File) && "FileName should be relative");
+
+    llvm::SmallString<32> Path;
+    llvm::sys::path::append(Path, getVirtualTestRoot(), File);
+    return Path;
+  }
+
+  std::string parseSourceAndDumpAST(
+      PathRef SourceFileRelPath, StringRef SourceContents,
+      std::vector<std::pair<PathRef, StringRef>> ExtraFiles = {},
+      bool ExpectErrors = false) {
+    MockFSProvider *FS;
+    ErrorCheckingDiagConsumer *DiagConsumer;
+    ClangdServer Server(
+        llvm::make_unique<MockCompilationDatabase>(),
+        getAndMove(llvm::make_unique<ErrorCheckingDiagConsumer>(),
+                   DiagConsumer),
+        getAndMove(llvm::make_unique<MockFSProvider>(), FS),
+        /*RunSynchronously=*/false);
+    for (const auto &FileWithContents : ExtraFiles)
+      FS->Files[getVirtualTestFilePath(FileWithContents.first)] =
+          FileWithContents.second;
+
+    auto SourceFilename = getVirtualTestFilePath(SourceFileRelPath);
+    Server.addDocument(SourceFilename, SourceContents);
+    auto Result = dumpASTWithoutMemoryLocs(Server, SourceFilename);
+    EXPECT_EQ(ExpectErrors, DiagConsumer->hadErrorInLastDiags());
+    return Result;
+  }
+};
+
+TEST_F(ClangdVFSTest, Parse) {
+  // FIXME: figure out a stable format for AST dumps, so that we can check the
+  // output of the dump itself is equal to the expected one, not just that it's
+  // different.
+  auto Empty = parseSourceAndDumpAST("foo.cpp", "", {});
+  auto OneDecl = parseSourceAndDumpAST("foo.cpp", "int a;", {});
+  auto SomeDecls = parseSourceAndDumpAST("foo.cpp", "int a; int b; int c;", {});
+  EXPECT_NE(Empty, OneDecl);
+  EXPECT_NE(Empty, SomeDecls);
+  EXPECT_NE(SomeDecls, OneDecl);
+
+  auto Empty2 = parseSourceAndDumpAST("foo.cpp", "");
+  auto OneDecl2 = parseSourceAndDumpAST("foo.cpp", "int a;");
+  auto SomeDecls2 = parseSourceAndDumpAST("foo.cpp", "int a; int b; int c;");
+  EXPECT_EQ(Empty, Empty2);
+  EXPECT_EQ(OneDecl, OneDecl2);
+  EXPECT_EQ(SomeDecls, SomeDecls2);
+}
+
+TEST_F(ClangdVFSTest, ParseWithHeader) {
+  parseSourceAndDumpAST("foo.cpp", "#include \"foo.h\"", {},
+                        /*ExpectErrors=*/true);
+  parseSourceAndDumpAST("foo.cpp", "#include \"foo.h\"", {{"foo.h", ""}},
+                        /*ExpectErrors=*/false);
+
+  const auto SourceContents = R"cpp(
+#include "foo.h"
+int b = a;
+)cpp";
+  parseSourceAndDumpAST("foo.cpp", SourceContents, {{"foo.h", ""}},
+                        /*ExpectErrors=*/true);
+  parseSourceAndDumpAST("foo.cpp", SourceContents, {{"foo.h", "int a;"}},
+                        /*ExpectErrors=*/false);
+}
+
+TEST_F(ClangdVFSTest, Reparse) {
+  MockFSProvider *FS;
+  ErrorCheckingDiagConsumer *DiagConsumer;
+  ClangdServer Server(
+      llvm::make_unique<MockCompilationDatabase>(),
+      getAndMove(llvm::make_unique<ErrorCheckingDiagConsumer>(), DiagConsumer),
+      getAndMove(llvm::make_unique<MockFSProvider>(), FS),
+      /*RunSynchronously=*/false);
+
+  const auto SourceContents =
+      R"cpp(
+#include "foo.h"
+int b = a;
+)cpp";
+
+  auto FooCpp = getVirtualTestFilePath("foo.cpp");
+  auto FooH = getVirtualTestFilePath("foo.h");
+
+  FS->Files[FooH] = "int a;";
+  FS->Files[FooCpp] = SourceContents;
+
+  Server.addDocument(FooCpp, SourceContents);
+  auto DumpParse1 = dumpASTWithoutMemoryLocs(Server, FooCpp);
+  EXPECT_FALSE(DiagConsumer->hadErrorInLastDiags());
+
+  Server.addDocument(FooCpp, "");
+  auto DumpParseEmpty = dumpASTWithoutMemoryLocs(Server, FooCpp);
+  EXPECT_FALSE(DiagConsumer->hadErrorInLastDiags());
+
+  Server.addDocument(FooCpp, SourceContents);
+  auto DumpParse2 = dumpASTWithoutMemoryLocs(Server, FooCpp);
+  EXPECT_FALSE(DiagConsumer->hadErrorInLastDiags());
+
+  EXPECT_EQ(DumpParse1, DumpParse2);
+  EXPECT_NE(DumpParse1, DumpParseEmpty);
+}
+
+TEST_F(ClangdVFSTest, ReparseOnHeaderChange) {
+  MockFSProvider *FS;
+  ErrorCheckingDiagConsumer *DiagConsumer;
+
+  ClangdServer Server(
+      llvm::make_unique<MockCompilationDatabase>(),
+      getAndMove(llvm::make_unique<ErrorCheckingDiagConsumer>(), DiagConsumer),
+      getAndMove(llvm::make_unique<MockFSProvider>(), FS),
+      /*RunSynchronously=*/false);
+
+  const auto SourceContents =
+      R"cpp(
+#include "foo.h"
+int b = a;
+)cpp";
+
+  auto FooCpp = getVirtualTestFilePath("foo.cpp");
+  auto FooH = getVirtualTestFilePath("foo.h");
+
+  FS->Files[FooH] = "int a;";
+  FS->Files[FooCpp] = SourceContents;
+
+  Server.addDocument(FooCpp, SourceContents);
+  auto DumpParse1 = dumpASTWithoutMemoryLocs(Server, FooCpp);
+  EXPECT_FALSE(DiagConsumer->hadErrorInLastDiags());
+
+  FS->Files[FooH] = "";
+  Server.forceReparse(FooCpp);
+  auto DumpParseDifferent = dumpASTWithoutMemoryLocs(Server, FooCpp);
+  EXPECT_TRUE(DiagConsumer->hadErrorInLastDiags());
+
+  FS->Files[FooH] = "int a;";
+  Server.forceReparse(FooCpp);
+  auto DumpParse2 = dumpASTWithoutMemoryLocs(Server, FooCpp);
+  EXPECT_FALSE(DiagConsumer->hadErrorInLastDiags());
+
+  EXPECT_EQ(DumpParse1, DumpParse2);
+  EXPECT_NE(DumpParse1, DumpParseDifferent);
+}
+
+} // namespace clangd
+} // namespace clang