[clangd] Allow to override resource dir in ClangdServer.

[klimek]

LG

clangd/ClangdServer.h

public:
   /// thread will be created and all requests will be completed synchronously on
   /// the calling thread (this is mostly used for tests). If \p RunSynchronously
   /// is true, a worker thread will be created to parse files in the background
   /// and provide diagnostics results via DiagConsumer.onDiagnosticsReady
   /// callback. File accesses for each instance of parsing will be conducted via
   /// a vfs::FileSystem provided by \p FSProvider. Results of code
   /// completion/diagnostics also include a tag, that \p FSProvider returns
   /// along with the vfs::FileSystem.
+  /// When \p ResourceDir is set, it will be used to search for internal headers
+  /// (overriding defaults and -resource-dir compiler flag, if set). If \p
+  /// ResourceDir is None, ClangdServer will attempt to set it to a standard
+  /// location, obtained via CompilerInvocation::GetResourcePath.
   ClangdServer(GlobalCompilationDatabase &CDB,
                DiagnosticsConsumer &DiagConsumer,
-               FileSystemProvider &FSProvider, bool RunSynchronously);
+               FileSystemProvider &FSProvider, bool RunSynchronously,
+               llvm::Optional<StringRef> ResourceDir = llvm::None);
 
   /// 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.
public:
   std::string dumpAST(PathRef File);
 
 private:
   GlobalCompilationDatabase &CDB;
   DiagnosticsConsumer &DiagConsumer;
   FileSystemProvider &FSProvider;
   DraftStore DraftMgr;
   ClangdUnitStore Units;
+  std::string ResourceDir;
   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

std::vector<tooling::Replacement> formatCode(StringRef Code, StringRef Filename,
   // Call clang-format.
   // FIXME: Don't ignore style.
   format::FormatStyle Style = format::getLLVMStyle();
   auto Result = format::reformat(Style, Code, Ranges, Filename);
 
   return std::vector<tooling::Replacement>(Result.begin(), Result.end());
 }
 
+std::string getStandardResourceDir() {
+  static int Dummy; // Just an address in this process.
+  return CompilerInvocation::GetResourcesPath("clangd", (void *)&Dummy);
+}
+
 } // namespace
 
 size_t clangd::positionToOffset(StringRef Code, Position P) {
   size_t Offset = 0;
   for (int I = 0; I != P.line; ++I) {
     // FIXME: \r\n
     // FIXME: UTF-8
     size_t F = Code.find('\n', Offset);
if (RunSynchronously) {
     RequestQueue.push_back(Request);
   }
   RequestCV.notify_one();
 }
 
 ClangdServer::ClangdServer(GlobalCompilationDatabase &CDB,
                            DiagnosticsConsumer &DiagConsumer,
                            FileSystemProvider &FSProvider,
-                           bool RunSynchronously)
+                           bool RunSynchronously,
+                           llvm::Optional<StringRef> ResourceDir)
     : CDB(CDB), DiagConsumer(DiagConsumer), FSProvider(FSProvider),
+      ResourceDir(ResourceDir ? ResourceDir->str() : getStandardResourceDir()),
       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");
     auto TaggedFS = FSProvider.getTaggedFileSystem(FileStr);
     Units.runOnUnit(
-        FileStr, *FileContents.Draft, CDB, PCHs, TaggedFS.Value,
+        FileStr, *FileContents.Draft, ResourceDir, CDB, PCHs, TaggedFS.Value,
         [&](ClangdUnit const &Unit) {
           DiagConsumer.onDiagnosticsReady(
               FileStr, make_tagged(Unit.getLocalDiagnostics(), TaggedFS.Tag));
         });
   });
 }
 
 void ClangdServer::removeDocument(PathRef File) {
if (!OverridenContents) {
     OverridenContents = DraftStorage;
   }
 
   std::vector<CompletionItem> Result;
   auto TaggedFS = FSProvider.getTaggedFileSystem(File);
   // It would be nice to use runOnUnitWithoutReparse here, but we can't
   // guarantee the correctness of code completion cache here if we don't do the
   // reparse.
-  Units.runOnUnit(File, *OverridenContents, CDB, PCHs, TaggedFS.Value,
-                  [&](ClangdUnit &Unit) {
+  Units.runOnUnit(File, *OverridenContents, ResourceDir, CDB, PCHs,
+                  TaggedFS.Value, [&](ClangdUnit &Unit) {
                     Result = Unit.codeComplete(*OverridenContents, Pos,
                                                TaggedFS.Value);
                   });
   return make_tagged(std::move(Result), TaggedFS.Tag);
 }
 
 std::vector<tooling::Replacement> ClangdServer::formatRange(PathRef File,
                                                             Range Rng) {

clangd/ClangdUnit.h

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,
+  ClangdUnit(PathRef FileName, StringRef Contents, StringRef ResourceDir,
              std::shared_ptr<PCHContainerOperations> PCHs,
              std::vector<tooling::CompileCommand> Commands,
              IntrusiveRefCntPtr<vfs::FileSystem> VFS);
 
   /// Reparse with new contents.
   void reparse(StringRef Contents, IntrusiveRefCntPtr<vfs::FileSystem> VFS);
 
   /// Get code completions at a specified \p Line and \p Column in \p File.

clangd/ClangdUnit.cpp

 #include "clang/Frontend/Utils.h"
 #include "clang/Tooling/CompilationDatabase.h"
 #include "llvm/Support/Format.h"
 
 using namespace clang::clangd;
 using namespace clang;
 
 ClangdUnit::ClangdUnit(PathRef FileName, StringRef Contents,
+                       StringRef ResourceDir,
                        std::shared_ptr<PCHContainerOperations> PCHs,
                        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);
-  Commands.front().CommandLine.push_back("-resource-dir=" + ResourceDir);
+  Commands.front().CommandLine.push_back("-resource-dir=" + std::string(ResourceDir));
 
   IntrusiveRefCntPtr<DiagnosticsEngine> Diags =
       CompilerInstance::createDiagnostics(new DiagnosticOptions);
 
   std::vector<const char *> ArgStrs;
   for (const auto &S : Commands.front().CommandLine)
     ArgStrs.push_back(S.c_str());
 

clangd/ClangdUnitStore.h

 class ClangdUnitStore {
 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,
+  void runOnUnit(PathRef File, StringRef FileContents, StringRef ResourceDir,
                  GlobalCompilationDatabase &CDB,
                  std::shared_ptr<PCHContainerOperations> PCHs,
                  IntrusiveRefCntPtr<vfs::FileSystem> VFS, Func Action) {
-    runOnUnitImpl(File, FileContents, CDB, PCHs, /*ReparseBeforeAction=*/true,
-                  VFS, std::forward<Func>(Action));
+    runOnUnitImpl(File, FileContents, ResourceDir, CDB, PCHs,
+                  /*ReparseBeforeAction=*/true, 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,
+                               StringRef ResourceDir,
                                GlobalCompilationDatabase &CDB,
                                std::shared_ptr<PCHContainerOperations> PCHs,
                                IntrusiveRefCntPtr<vfs::FileSystem> VFS,
                                Func Action) {
-    runOnUnitImpl(File, FileContents, CDB, PCHs, /*ReparseBeforeAction=*/false,
-                  VFS, std::forward<Func>(Action));
+    runOnUnitImpl(File, FileContents, ResourceDir, CDB, PCHs,
+                  /*ReparseBeforeAction=*/false, 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) {
+  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,
+                     StringRef ResourceDir, GlobalCompilationDatabase &CDB,
                      std::shared_ptr<PCHContainerOperations> PCHs,
                      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");
     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, VFS)))
+               .insert(std::make_pair(File, ClangdUnit(File, FileContents,
+                                                       ResourceDir, PCHs,
+                                                       Commands, VFS)))
                .first;
     } else if (ReparseBeforeAction) {
       It->second.reparse(FileContents, VFS);
     }
     return Action(It->second);
   }
 
   std::vector<tooling::CompileCommand>