[clangd] Use in-memory preambles in clangd.

[ilya-biryukov]

After looking at the numbers, I think we should make this configurable. I'll update this change accordingly. Not sure what should be the default, though. I'm currently erring on the side of "in-memory by default".

Current implementation eats almost twice as much memory, which quickly adds up (tried comparing with earlier builds on ClangdUnit.cpp).
Even without proper benchmarks, it's clear that if we run out of memory (and we easily could if run on a machine with, say, 8GB of RAM) on-disk preambles are an easy way out of trouble.

[sammccall]

Heh, I was just going to ask :-)

As a very first step, can we make this configurable but off-by-default? That will address the pressing diskless-servers need.

In a typical workstation scenario, disk is plentiful (if slow) and RAM is scarce - very likely we're running browser + editor (VSCode is another browser really) + clangd + build system, and clangd is likely the least important of these...
So if we're going to increase mem usage by a significant amount I think we want to measure it carefully first.

[ilya-biryukov]

Made in-memory preambles optional (on-disk by default).

[ilya-biryukov]

In D39843#920568, @sammccall wrote:

As a very first step, can we make this configurable but off-by-default? That will address the pressing diskless-servers need.

I think on-disk by default makes sense now until we do the measurements and have a the data to prove the on-memory is really better.

[sammccall]

As discussed, we should probably bundle together some related options into structs to make plumbing easier. Not a blocker here though.

If these options are pure-data, I think it's OK if some layers end up with access to other layers' options.

clangd/ClangdUnit.cpp

238

ref is still here :-)

clangd/tool/ClangdMain.cpp

48

Couple of questions about the flag syntax:

• I wonder about the granularity - if we had another temp storage (indexes?), would we want another flag or something shared like -in-memory-storage
• Having this as a bool seems confusing compared to -pch-storage={memory/disk}. (We could also overload such a flag to allow setting the location, but nobody's asked for that yet)

[ilya-biryukov]

• Removed /*ref*/.
• Changed the command-line flag: it's -pch-storage now instead of -in-memory-pchs.
• Actually pass the StoreInMemory flag to PrecompiledPreamble::Build.
• Fixed a new usage of ClangdServer after rebase (In ClangdTests).

clangd/ClangdUnit.cpp

238

Thx. Missed that. Removed.

clangd/tool/ClangdMain.cpp

48

• Indexes are fundamentally different because we actually want to persist them across multiple sessions. But I see your point. I'd go with another flag for greater flexibility. We do want clangd work great by-default, so those flags are mostly for people who know what they're doing and can figure out which flags they want to change and why. Maybe I'm not right, though, and people would want those kinds of switches.
• Totally like the -pch-storage={memory/disk} more, updated the change accordingly.

clangd/ClangdLSPServer.h

 /// This class provides implementation of an LSP server, glueing the JSON
 /// dispatch and ClangdServer together.
 class ClangdLSPServer : private DiagnosticsConsumer, private ProtocolCallbacks {
 public:
   /// If \p CompileCommandsDir has a value, compile_commands.json will be
   /// loaded only from \p CompileCommandsDir. Otherwise, clangd will look
   /// for compile_commands.json in all parent directories of each file.
   ClangdLSPServer(JSONOutput &Out, unsigned AsyncThreadsCount,
-                  bool SnippetCompletions,
+                  bool StorePreamblesInMemory, bool SnippetCompletions,
                   llvm::Optional<StringRef> ResourceDir,
                   llvm::Optional<Path> CompileCommandsDir);
 
   /// Run LSP server loop, receiving input for it from \p In. \p In must be
   /// opened in binary mode. Output will be written using Out variable passed to
   /// class constructor. This method must not be executed more than once for
   /// each instance of ClangdLSPServer.
   ///

clangd/ClangdLSPServer.cpp

 void ClangdLSPServer::onSwitchSourceHeader(Ctx C,
                                            TextDocumentIdentifier &Params) {
   llvm::Optional<Path> Result = Server.switchSourceHeader(Params.uri.file);
   std::string ResultUri;
   C.reply(Result ? URI::fromFile(*Result).uri : "");
 }
 
 ClangdLSPServer::ClangdLSPServer(JSONOutput &Out, unsigned AsyncThreadsCount,
+                                 bool StorePreamblesInMemory,
                                  bool SnippetCompletions,
                                  llvm::Optional<StringRef> ResourceDir,
                                  llvm::Optional<Path> CompileCommandsDir)
     : Out(Out), CDB(/*Logger=*/Out, std::move(CompileCommandsDir)),
       Server(CDB, /*DiagConsumer=*/*this, FSProvider, AsyncThreadsCount,
+             StorePreamblesInMemory,
              clangd::CodeCompleteOptions(
                  /*EnableSnippetsAndCodePatterns=*/SnippetCompletions),
              /*Logger=*/Out, ResourceDir) {}
 
 bool ClangdLSPServer::run(std::istream &In) {
   assert(!IsDone && "Run was called before");
 
   // Set up JSONRPCDispatcher.

clangd/ClangdServer.h

public:
   /// those arguments for subsequent reparses. However, ClangdServer will check
   /// if compilation arguments changed on calls to forceReparse().
   ///
   /// After each parsing request finishes, ClangdServer reports diagnostics to
   /// \p DiagConsumer. Note that a callback to \p DiagConsumer happens on a
   /// worker thread. Therefore, instances of \p DiagConsumer must properly
   /// synchronize access to shared state.
   ///
+  /// \p StorePreamblesInMemory defines whether the Preambles generated by
+  /// clangd are stored in-memory or on disk.
+  ///
   /// Various messages are logged using \p Logger.
   ClangdServer(GlobalCompilationDatabase &CDB,
                DiagnosticsConsumer &DiagConsumer,
                FileSystemProvider &FSProvider, unsigned AsyncThreadsCount,
+               bool StorePreamblesInMemory,
                clangd::CodeCompleteOptions CodeCompleteOpts,
                clangd::Logger &Logger,
                llvm::Optional<StringRef> ResourceDir = llvm::None);
 
   /// Set the root path of the workspace.
   void setRootPath(PathRef RootPath);
 
   /// Add a \p File to the list of tracked C++ files or update the contents if
private:
   DiagnosticsConsumer &DiagConsumer;
   FileSystemProvider &FSProvider;
   DraftStore DraftMgr;
   CppFileCollection Units;
   std::string ResourceDir;
   // If set, this represents the workspace path.
   llvm::Optional<std::string> RootPath;
   std::shared_ptr<PCHContainerOperations> PCHs;
+  bool StorePreamblesInMemory;
   clangd::CodeCompleteOptions CodeCompleteOpts;
   /// Used to serialize diagnostic callbacks.
   /// FIXME(ibiryukov): get rid of an extra map and put all version counters
   /// into CppFile.
   std::mutex DiagnosticsMutex;
   /// Maps from a filename to the latest version of reported diagnostics.
   llvm::StringMap<DocVersion> ReportedDiagnosticVersions;
   // WorkScheduler has to be the last member, because its destructor has to be

clangd/ClangdServer.cpp

if (RunSynchronously)
     Done = true;
   } // unlock Mutex
   RequestCV.notify_all();
 
   for (auto &Worker : Workers)
     Worker.join();
 }
 
-ClangdServer::ClangdServer(GlobalCompilationDatabase &CDB,
-                           DiagnosticsConsumer &DiagConsumer,
-                           FileSystemProvider &FSProvider,
-                           unsigned AsyncThreadsCount,
-                           clangd::CodeCompleteOptions CodeCompleteOpts,
-                           clangd::Logger &Logger,
-                           llvm::Optional<StringRef> ResourceDir)
+ClangdServer::ClangdServer(
+    GlobalCompilationDatabase &CDB, DiagnosticsConsumer &DiagConsumer,
+    FileSystemProvider &FSProvider, unsigned AsyncThreadsCount,
+    bool StorePreamblesInMemory, clangd::CodeCompleteOptions CodeCompleteOpts,
+    clangd::Logger &Logger, llvm::Optional<StringRef> ResourceDir)
     : Logger(Logger), CDB(CDB), DiagConsumer(DiagConsumer),
       FSProvider(FSProvider),
       ResourceDir(ResourceDir ? ResourceDir->str() : getStandardResourceDir()),
       PCHs(std::make_shared<PCHContainerOperations>()),
+      StorePreamblesInMemory(StorePreamblesInMemory),
       CodeCompleteOpts(CodeCompleteOpts), WorkScheduler(AsyncThreadsCount) {}
 
 void ClangdServer::setRootPath(PathRef RootPath) {
   std::string NewRootPath = llvm::sys::path::convert_to_slash(
       RootPath, llvm::sys::path::Style::posix);
   if (llvm::sys::fs::is_directory(NewRootPath))
     this->RootPath = NewRootPath;
 }
 
 std::future<void> ClangdServer::addDocument(PathRef File, StringRef Contents) {
   DocVersion Version = DraftMgr.updateDraft(File, Contents);
 
   auto TaggedFS = FSProvider.getTaggedFileSystem(File);
-  std::shared_ptr<CppFile> Resources =
-      Units.getOrCreateFile(File, ResourceDir, CDB, PCHs, Logger);
+  std::shared_ptr<CppFile> Resources = Units.getOrCreateFile(
+      File, ResourceDir, CDB, StorePreamblesInMemory, PCHs, Logger);
   return scheduleReparseAndDiags(File, VersionedDraft{Version, Contents.str()},
                                  std::move(Resources), std::move(TaggedFS));
 }
 
 std::future<void> ClangdServer::removeDocument(PathRef File) {
   DraftMgr.removeDraft(File);
   std::shared_ptr<CppFile> Resources = Units.removeIfPresent(File);
   return scheduleCancelRebuild(std::move(Resources));
 }
 
 std::future<void> ClangdServer::forceReparse(PathRef File) {
   auto FileContents = DraftMgr.getDraft(File);
   assert(FileContents.Draft &&
          "forceReparse() was called for non-added document");
 
   auto TaggedFS = FSProvider.getTaggedFileSystem(File);
-  auto Recreated = Units.recreateFileIfCompileCommandChanged(File, ResourceDir,
-                                                             CDB, PCHs, Logger);
+  auto Recreated = Units.recreateFileIfCompileCommandChanged(
+      File, ResourceDir, CDB, StorePreamblesInMemory, PCHs, Logger);
 
   // Note that std::future from this cleanup action is ignored.
   scheduleCancelRebuild(std::move(Recreated.RemovedFile));
   // Schedule a reparse.
   return scheduleReparseAndDiags(File, std::move(FileContents),
                                  std::move(Recreated.FileInCollection),
                                  std::move(TaggedFS));
 }

clangd/ClangdUnit.h

 /// Manages resources, required by clangd. Allows to rebuild file with new
 /// contents, and provides AST and Preamble for it.
 class CppFile : public std::enable_shared_from_this<CppFile> {
 public:
   // We only allow to create CppFile as shared_ptr, because a future returned by
   // deferRebuild will hold references to it.
   static std::shared_ptr<CppFile>
   Create(PathRef FileName, tooling::CompileCommand Command,
+         bool StorePreamblesInMemory,
          std::shared_ptr<PCHContainerOperations> PCHs, clangd::Logger &Logger);
 
 private:
   CppFile(PathRef FileName, tooling::CompileCommand Command,
+          bool StorePreamblesInMemory,
           std::shared_ptr<PCHContainerOperations> PCHs, clangd::Logger &Logger);
 
 public:
   CppFile(CppFile const &) = delete;
   CppFile(CppFile &&) = delete;
 
   /// Cancels a scheduled rebuild, if any, and sets AST and Preamble to nulls.
   /// If a rebuild is in progress, will wait for it to finish.
private:
   private:
     CppFile &File;
     unsigned RequestRebuildCounter;
     bool WasCancelledBeforeConstruction;
   };
 
   Path FileName;
   tooling::CompileCommand Command;
+  bool StorePreamblesInMemory;
 
   /// Mutex protects all fields, declared below it, FileName and Command are not
   /// mutated.
   mutable std::mutex Mutex;
   /// A counter to cancel old rebuilds.
   unsigned RebuildCounter;
   /// Used to wait when rebuild is finished before starting another one.
   bool RebuildInProgress;

clangd/ClangdUnit.cpp

prepareCompilerInstance(std::unique_ptr<clang::CompilerInvocation> CI,
   assert(VFS && "VFS is null");
   assert(!CI->getPreprocessorOpts().RetainRemappedFileBuffers &&
          "Setting RetainRemappedFileBuffers to true will cause a memory leak "
          "of ContentsBuffer");
 
   // NOTE: we use Buffer.get() when adding remapped files, so we have to make
   // sure it will be released if no error is emitted.
   if (Preamble) {
-    Preamble->AddImplicitPreamble(*CI, Buffer.get());
+    Preamble->AddImplicitPreamble(*CI, /*ref*/ VFS, Buffer.get());
   } else {
     CI->getPreprocessorOpts().addRemappedFile(
         CI->getFrontendOpts().Inputs[0].getFile(), Buffer.get());
   }
 
   auto Clang = llvm::make_unique<CompilerInstance>(PCHs);
   Clang->setInvocation(std::move(CI));
   Clang->createDiagnostics(&DiagsClient, false);

 PreambleData::PreambleData(PrecompiledPreamble Preamble,
                            std::vector<serialization::DeclID> TopLevelDeclIDs,
                            std::vector<DiagWithFixIts> Diags)
     : Preamble(std::move(Preamble)),
       TopLevelDeclIDs(std::move(TopLevelDeclIDs)), Diags(std::move(Diags)) {}
 
 std::shared_ptr<CppFile>
 CppFile::Create(PathRef FileName, tooling::CompileCommand Command,
+                bool StorePreamblesInMemory,
                 std::shared_ptr<PCHContainerOperations> PCHs,
                 clangd::Logger &Logger) {
-  return std::shared_ptr<CppFile>(
-      new CppFile(FileName, std::move(Command), std::move(PCHs), Logger));
+  return std::shared_ptr<CppFile>(new CppFile(FileName, std::move(Command),
+                                              StorePreamblesInMemory,
+                                              std::move(PCHs), Logger));
 }
 
 CppFile::CppFile(PathRef FileName, tooling::CompileCommand Command,
+                 bool StorePreamblesInMemory,
                  std::shared_ptr<PCHContainerOperations> PCHs,
                  clangd::Logger &Logger)
-    : FileName(FileName), Command(std::move(Command)), RebuildCounter(0),
+    : FileName(FileName), Command(std::move(Command)),
+      StorePreamblesInMemory(StorePreamblesInMemory), RebuildCounter(0),
       RebuildInProgress(false), PCHs(std::move(PCHs)), Logger(Logger) {
 
   std::lock_guard<std::mutex> Lock(Mutex);
   LatestAvailablePreamble = nullptr;
   PreamblePromise.set_value(nullptr);
   PreambleFuture = PreamblePromise.get_future();
 
   ASTPromise.set_value(std::make_shared<ParsedASTWrapper>(llvm::None));
auto DoRebuildPreamble = [&]() -> std::shared_ptr<const PreambleData> {
       std::vector<DiagWithFixIts> PreambleDiags;
       StoreDiagsConsumer PreambleDiagnosticsConsumer(/*ref*/ PreambleDiags);
       IntrusiveRefCntPtr<DiagnosticsEngine> PreambleDiagsEngine =
           CompilerInstance::createDiagnostics(
               &CI->getDiagnosticOpts(), &PreambleDiagnosticsConsumer, false);
       CppFilePreambleCallbacks SerializedDeclsCollector;
       auto BuiltPreamble = PrecompiledPreamble::Build(
           *CI, ContentsBuffer.get(), Bounds, *PreambleDiagsEngine, VFS, PCHs,
-          SerializedDeclsCollector);
+          /*StoreInMemory=*/true, SerializedDeclsCollector);
 
       if (BuiltPreamble) {
         return std::make_shared<PreambleData>(
             std::move(*BuiltPreamble),
             SerializedDeclsCollector.takeTopLevelDeclIDs(),
             std::move(PreambleDiags));
       } else {
         return nullptr;

clangd/ClangdUnitStore.h

 namespace clang {
 namespace clangd {
 
 class Logger;
 
 /// Thread-safe mapping from FileNames to CppFile.
 class CppFileCollection {
 public:
-  std::shared_ptr<CppFile> getOrCreateFile(
-      PathRef File, PathRef ResourceDir, GlobalCompilationDatabase &CDB,
-      std::shared_ptr<PCHContainerOperations> PCHs, clangd::Logger &Logger) {
+  std::shared_ptr<CppFile>
+  getOrCreateFile(PathRef File, PathRef ResourceDir,
+                  GlobalCompilationDatabase &CDB, bool StorePreamblesInMemory,
+                  std::shared_ptr<PCHContainerOperations> PCHs,
+                  clangd::Logger &Logger) {
     std::lock_guard<std::mutex> Lock(Mutex);
 
     auto It = OpenedFiles.find(File);
     if (It == OpenedFiles.end()) {
       auto Command = getCompileCommand(CDB, File, ResourceDir);
 
       It = OpenedFiles
                .try_emplace(File, CppFile::Create(File, std::move(Command),
+                                                  StorePreamblesInMemory,
                                                   std::move(PCHs), Logger))
                .first;
     }
     return It->second;
   }
 
   struct RecreateResult {
     /// A CppFile, stored in this CppFileCollection for the corresponding
     /// filepath after calling recreateFileIfCompileCommandChanged.
     std::shared_ptr<CppFile> FileInCollection;
     /// If a new CppFile had to be created to account for changed
     /// CompileCommand, a previous CppFile instance will be returned in this
     /// field.
     std::shared_ptr<CppFile> RemovedFile;
   };
 
   /// Similar to getOrCreateFile, but will replace a current CppFile for \p File
   /// with a new one if CompileCommand, provided by \p CDB has changed.
   /// If a currently stored CppFile had to be replaced, the previous instance
   /// will be returned in RecreateResult.RemovedFile.
   RecreateResult recreateFileIfCompileCommandChanged(
       PathRef File, PathRef ResourceDir, GlobalCompilationDatabase &CDB,
-      std::shared_ptr<PCHContainerOperations> PCHs, clangd::Logger &Logger);
+      bool StorePreamblesInMemory, std::shared_ptr<PCHContainerOperations> PCHs,
+      clangd::Logger &Logger);
 
   std::shared_ptr<CppFile> getFile(PathRef File) {
     std::lock_guard<std::mutex> Lock(Mutex);
 
     auto It = OpenedFiles.find(File);
     if (It == OpenedFiles.end())
       return nullptr;
     return It->second;

clangd/ClangdUnitStore.cpp

std::shared_ptr<CppFile> CppFileCollection::removeIfPresent(PathRef File) {
   std::shared_ptr<CppFile> Result = It->second;
   OpenedFiles.erase(It);
   return Result;
 }
 
 CppFileCollection::RecreateResult
 CppFileCollection::recreateFileIfCompileCommandChanged(
     PathRef File, PathRef ResourceDir, GlobalCompilationDatabase &CDB,
-    std::shared_ptr<PCHContainerOperations> PCHs, clangd::Logger &Logger) {
+    bool StorePreamblesInMemory, std::shared_ptr<PCHContainerOperations> PCHs,
+    clangd::Logger &Logger) {
   auto NewCommand = getCompileCommand(CDB, File, ResourceDir);
 
   std::lock_guard<std::mutex> Lock(Mutex);
 
   RecreateResult Result;
 
   auto It = OpenedFiles.find(File);
   if (It == OpenedFiles.end()) {
     It = OpenedFiles
              .try_emplace(File, CppFile::Create(File, std::move(NewCommand),
+                                                StorePreamblesInMemory,
                                                 std::move(PCHs), Logger))
              .first;
   } else if (!compileCommandsAreEqual(It->second->getCompileCommand(),
                                       NewCommand)) {
     Result.RemovedFile = std::move(It->second);
     It->second =
-        CppFile::Create(File, std::move(NewCommand), std::move(PCHs), Logger);
+        CppFile::Create(File, std::move(NewCommand), StorePreamblesInMemory,
+                        std::move(PCHs), Logger);
   }
   Result.FileInCollection = It->second;
   return Result;
 }
 
 tooling::CompileCommand
 CppFileCollection::getCompileCommand(GlobalCompilationDatabase &CDB,
                                      PathRef File, PathRef ResourceDir) {

clangd/tool/ClangdMain.cpp

static llvm::cl::opt<bool> EnableSnippets(
     llvm::cl::desc(
         "Present snippet completions instead of plaintext completions"),
     llvm::cl::init(false));
 
 static llvm::cl::opt<bool>
     PrettyPrint("pretty", llvm::cl::desc("Pretty-print JSON output"),
                 llvm::cl::init(false));
 
+static llvm::cl::opt<bool> StorePreamblesInMemory(
+    "in-memory-pchs",
+    llvm::cl::desc("Store PCHs in memory instead of disk. Enabling this option "
+                   "increases memory consumption considerably, but also "
+                   "increases performance"),
+    llvm::cl::init(false));
+
 static llvm::cl::opt<bool> RunSynchronously(
     "run-synchronously",
     llvm::cl::desc("Parse on main thread. If set, -j is ignored"),
     llvm::cl::init(false), llvm::cl::Hidden);
 
 static llvm::cl::opt<Path>
     ResourceDir("resource-dir",
                 llvm::cl::desc("Directory for system clang headers"),
int main(int argc, char *argv[]) {
   llvm::Optional<StringRef> ResourceDirRef = None;
   if (!ResourceDir.empty())
     ResourceDirRef = ResourceDir;
 
   // Change stdin to binary to not lose \r\n on windows.
   llvm::sys::ChangeStdinToBinary();
 
   // Initialize and run ClangdLSPServer.
-  ClangdLSPServer LSPServer(Out, WorkerThreadsCount, EnableSnippets,
-                            ResourceDirRef, CompileCommandsDirPath);
+  ClangdLSPServer LSPServer(Out, WorkerThreadsCount, StorePreamblesInMemory,
+                            EnableSnippets, ResourceDirRef,
+                            CompileCommandsDirPath);
   constexpr int NoShutdownRequestErrorCode = 1;
   llvm::set_thread_name("clangd.main");
   return LSPServer.run(std::cin) ? 0 : NoShutdownRequestErrorCode;
 }

test/clangd/completion.test

 # RUN: clangd -pretty -run-synchronously < %s | FileCheck -strict-whitespace %s
+# RUN: clangd -pretty -run-synchronously -in-memory-pchs < %s | FileCheck -strict-whitespace %s
 # It is absolutely vital that this file has CRLF line endings.
 #
 Content-Length: 125
 
 {"jsonrpc":"2.0","id":0,"method":"initialize","params":{"processId":123,"rootPath":"clangd","capabilities":{},"trace":"off"}}
 
 Content-Length: 246
 

test/clangd/diagnostics-preamble.test

 # RUN: clangd -pretty -run-synchronously < %s | FileCheck -strict-whitespace %s
+# RUN: clangd -pretty -run-synchronously -in-memory-pchs < %s | FileCheck -strict-whitespace %s
 # It is absolutely vital that this file has CRLF line endings.
 #
 Content-Length: 125
 
 {"jsonrpc":"2.0","id":0,"method":"initialize","params":{"processId":123,"rootPath":"clangd","capabilities":{},"trace":"off"}}
 
 Content-Length: 206
 

unittests/clangd/ClangdTests.cpp

#endif
   std::string parseSourceAndDumpAST(
       PathRef SourceFileRelPath, StringRef SourceContents,
       std::vector<std::pair<PathRef, StringRef>> ExtraFiles = {},
       bool ExpectErrors = false) {
     MockFSProvider FS;
     ErrorCheckingDiagConsumer DiagConsumer;
     MockCompilationDatabase CDB(/*AddFreestandingFlag=*/true);
     ClangdServer Server(CDB, DiagConsumer, FS, getDefaultAsyncThreadsCount(),
+                        /*StorePreamblesInMemory=*/true,
                         clangd::CodeCompleteOptions(),
                         EmptyLogger::getInstance());
     for (const auto &FileWithContents : ExtraFiles)
       FS.Files[getVirtualTestFilePath(FileWithContents.first)] =
           FileWithContents.second;
 
     auto SourceFilename = getVirtualTestFilePath(SourceFileRelPath);
 
parseSourceAndDumpAST("foo.cpp", SourceContents, {{"foo.h", "int a;"}},
                         /*ExpectErrors=*/false);
 }
 
 TEST_F(ClangdVFSTest, Reparse) {
   MockFSProvider FS;
   ErrorCheckingDiagConsumer DiagConsumer;
   MockCompilationDatabase CDB(/*AddFreestandingFlag=*/true);
   ClangdServer Server(CDB, DiagConsumer, FS, getDefaultAsyncThreadsCount(),
+                      /*StorePreamblesInMemory=*/true,
                       clangd::CodeCompleteOptions(),
                       EmptyLogger::getInstance());
 
   const auto SourceContents = R"cpp(
 #include "foo.h"
 int b = a;
 )cpp";
 

 }
 
 TEST_F(ClangdVFSTest, ReparseOnHeaderChange) {
   MockFSProvider FS;
   ErrorCheckingDiagConsumer DiagConsumer;
   MockCompilationDatabase CDB(/*AddFreestandingFlag=*/true);
 
   ClangdServer Server(CDB, DiagConsumer, FS, getDefaultAsyncThreadsCount(),
+                      /*StorePreamblesInMemory=*/true,
                       clangd::CodeCompleteOptions(),
                       EmptyLogger::getInstance());
 
   const auto SourceContents = R"cpp(
 #include "foo.h"
 int b = a;
 )cpp";
 

 }
 
 TEST_F(ClangdVFSTest, CheckVersions) {
   MockFSProvider FS;
   ErrorCheckingDiagConsumer DiagConsumer;
   MockCompilationDatabase CDB(/*AddFreestandingFlag=*/true);
   // Run ClangdServer synchronously.
   ClangdServer Server(CDB, DiagConsumer, FS,
-                      /*AsyncThreadsCount=*/0, clangd::CodeCompleteOptions(),
+                      /*AsyncThreadsCount=*/0,
+                      /*StorePreamblesInMemory=*/true,
+                      clangd::CodeCompleteOptions(),
                       EmptyLogger::getInstance());
 
   auto FooCpp = getVirtualTestFilePath("foo.cpp");
   const auto SourceContents = "int a;";
   FS.Files[FooCpp] = SourceContents;
   FS.ExpectedFile = FooCpp;
 
   // No need to sync reparses, because requests are processed on the calling
TEST_F(ClangdVFSTest, SearchLibDir) {
   ErrorCheckingDiagConsumer DiagConsumer;
   MockCompilationDatabase CDB(/*AddFreestandingFlag=*/true);
   CDB.ExtraClangFlags.insert(CDB.ExtraClangFlags.end(),
                              {"-xc++", "-target", "x86_64-linux-unknown",
                               "-m64", "--gcc-toolchain=/randomusr",
                               "-stdlib=libstdc++"});
   // Run ClangdServer synchronously.
   ClangdServer Server(CDB, DiagConsumer, FS,
-                      /*AsyncThreadsCount=*/0, clangd::CodeCompleteOptions(),
+                      /*AsyncThreadsCount=*/0,
+                      /*StorePreamblesInMemory=*/true,
+                      clangd::CodeCompleteOptions(),
                       EmptyLogger::getInstance());
 
   // Just a random gcc version string
   SmallString<8> Version("4.9.3");
 
   // A lib dir for gcc installation
   SmallString<64> LibDir("/randomusr/lib/gcc/x86_64-linux-gnu");
   llvm::sys::path::append(LibDir, Version);

 }
 #endif // LLVM_ON_UNIX
 
 TEST_F(ClangdVFSTest, ForceReparseCompileCommand) {
   MockFSProvider FS;
   ErrorCheckingDiagConsumer DiagConsumer;
   MockCompilationDatabase CDB(/*AddFreestandingFlag=*/true);
   ClangdServer Server(CDB, DiagConsumer, FS,
-                      /*AsyncThreadsCount=*/0, clangd::CodeCompleteOptions(),
+                      /*AsyncThreadsCount=*/0,
+                      /*StorePreamblesInMemory=*/true,
+                      clangd::CodeCompleteOptions(),
                       EmptyLogger::getInstance());
   // No need to sync reparses, because reparses are performed on the calling
   // thread to true.
 
   auto FooCpp = getVirtualTestFilePath("foo.cpp");
   const auto SourceContents1 = R"cpp(
 template <class T>
 struct foo { T x; };

 };
 
 TEST_F(ClangdCompletionTest, CheckContentsOverride) {
   MockFSProvider FS;
   ErrorCheckingDiagConsumer DiagConsumer;
   MockCompilationDatabase CDB(/*AddFreestandingFlag=*/true);
 
   ClangdServer Server(CDB, DiagConsumer, FS, getDefaultAsyncThreadsCount(),
+                      /*StorePreamblesInMemory=*/true,
                       clangd::CodeCompleteOptions(),
                       EmptyLogger::getInstance());
 
   auto FooCpp = getVirtualTestFilePath("foo.cpp");
   const auto SourceContents = R"cpp(
 int aba;
 int b =   ;
 )cpp";
)cpp";
 
   StringWithPos GlobalCompletion =
       parseTextMarker(GlobalCompletionSourceTemplate, "complete");
   StringWithPos MemberCompletion =
       parseTextMarker(MemberCompletionSourceTemplate, "complete");
 
   auto TestWithOpts = [&](clangd::CodeCompleteOptions Opts) {
     ClangdServer Server(CDB, DiagConsumer, FS, getDefaultAsyncThreadsCount(),
-                        Opts, EmptyLogger::getInstance());
+                        /*StorePreamblesInMemory=*/true, Opts,
+                        EmptyLogger::getInstance());
     // No need to sync reparses here as there are no asserts on diagnostics (or
     // other async operations).
     Server.addDocument(FooCpp, GlobalCompletion.Text);
 
     StringRef MethodItemText = Opts.EnableSnippets ? "method()" : "method";
     StringRef GlobalFuncItemText =
         Opts.EnableSnippets ? "global_func()" : "global_func";
 
)cpp";
   ReqStats.reserve(FilesCount);
   for (unsigned FileIndex = 0; FileIndex < FilesCount; ++FileIndex)
     ReqStats.emplace_back();
 
   TestDiagConsumer DiagConsumer;
   {
     MockCompilationDatabase CDB(/*AddFreestandingFlag=*/true);
     ClangdServer Server(CDB, DiagConsumer, FS, getDefaultAsyncThreadsCount(),
+                        /*StorePreamblesInMemory=*/true,
                         clangd::CodeCompleteOptions(),
                         EmptyLogger::getInstance());
 
     // Prepare some random distributions for the test.
     std::random_device RandGen;
 
     std::uniform_int_distribution<unsigned> FileIndexDist(0, FilesCount - 1);
     // Pass a text that contains compiler errors to addDocument in about 20% of

 }
 
 TEST_F(ClangdVFSTest, CheckSourceHeaderSwitch) {
   MockFSProvider FS;
   ErrorCheckingDiagConsumer DiagConsumer;
   MockCompilationDatabase CDB(/*AddFreestandingFlag=*/true);
 
   ClangdServer Server(CDB, DiagConsumer, FS, getDefaultAsyncThreadsCount(),
+                      /*StorePreamblesInMemory=*/true,
                       clangd::CodeCompleteOptions(),
                       EmptyLogger::getInstance());
 
   auto SourceContents = R"cpp(
   #include "foo.h"
   int b = a;
   )cpp";
 
)cpp";
 
   std::promise<void> StartSecondReparsePromise;
   std::future<void> StartSecondReparse = StartSecondReparsePromise.get_future();
 
   NoConcurrentAccessDiagConsumer DiagConsumer(
       std::move(StartSecondReparsePromise));
 
   MockCompilationDatabase CDB(/*AddFreestandingFlag=*/true);
-  ClangdServer Server(CDB, DiagConsumer, FS, 4, clangd::CodeCompleteOptions(),
+  ClangdServer Server(CDB, DiagConsumer, FS, 4, /*StorePreamblesInMemory=*/true,
+                      clangd::CodeCompleteOptions(),
                       EmptyLogger::getInstance());
   Server.addDocument(FooCpp, SourceContentsWithErrors);
   StartSecondReparse.wait();
 
   auto Future = Server.addDocument(FooCpp, SourceContentsWithoutErrors);
   Future.wait();
 }
 
 } // namespace clangd
 } // namespace clang