[clangd] Give modules access to filesystem, scheduler, and index.

[sammccall]

Summary

This finally makes it possible to implement useful modules.

[kadircet]

thanks, lgtm!

clang-tools-extra/clangd/Module.h

42

oops, sorry for forgetting that..

clang-tools-extra/clangd/ClangdServer.cpp

BackgroundIdx = std::make_unique<BackgroundIndex>(
         TFS, CDB,
         BackgroundIndexStorage::createDiskBackedStorageFactory(
             [&CDB](llvm::StringRef File) { return CDB.getProjectInfo(File); }),
         std::move(BGOpts));
     AddIndex(BackgroundIdx.get());
   }
   if (DynamicIdx)
     AddIndex(DynamicIdx.get());
+
+  if (Opts.Modules) {
+    Module::Facilities F{
+        this->WorkScheduler,
+        this->Index,
+        this->TFS,
+    };
+    for (auto &Mod : *Opts.Modules)
+      Mod.initialize(F);
+  }
 }
 
 void ClangdServer::addDocument(PathRef File, llvm::StringRef Contents,
                                llvm::StringRef Version,
                                WantDiagnostics WantDiags, bool ForceRebuild) {
   ParseOptions Opts;
 
   // Compile command is set asynchronously during update, as it can be slow.

clang-tools-extra/clangd/Module.h

+//===--- Module.h - Plugging features into clangd -----------------*-C++-*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_MODULE_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_MODULE_H
 
-#include "LSPBinder.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/JSON.h"
 #include <memory>
 #include <type_traits>
 #include <vector>
 
 namespace clang {
 namespace clangd {
+class LSPBinder;
+class SymbolIndex;
+class ThreadsafeFS;
+class TUScheduler;
 
 /// A Module contributes a vertical feature to clangd.
 ///
 /// FIXME: Extend this to support outgoing LSP calls.
 ///
 /// The lifetime of a module is roughly:
 ///  - modules are created before the LSP server, in ClangdMain.cpp
-///  - these modules are then passed to ClangdLSPServer and ClangdServer
-///  - module hooks can be called at this point.
-///    FIXME: We should make some server facilities like TUScheduler and index
-///    available to those modules after ClangdServer is initalized.
+///  - these modules are then passed to ClangdLSPServer in a ModuleSet
+///  - initializeLSP() is called when the editor calls initialize.
+//   - initialize() is then called by ClangdServer as it is constructed.
+///  - module hooks can be called by the server at this point.
+///    Server facilities (scheduler etc) are available.
 ///  - ClangdServer will not be destroyed until all the requests are done.
 ///    FIXME: Block server shutdown until all the modules are idle.
 ///  - modules will be destroyed after ClangdLSPServer is destroyed.
 ///
 /// Conventionally, standard modules live in the `clangd` namespace, and other
 /// exposed details live in a sub-namespace.
 class Module {
 public:
   virtual ~Module() = default;
 
   /// Called by the server to connect this module to LSP.
   /// The module should register the methods/notifications/commands it handles,
   /// and update the server capabilities to advertise them.
   ///
   /// This is only called if the module is running in ClangdLSPServer!
   /// Modules with a public interface should satisfy it without LSP bindings.
   virtual void initializeLSP(LSPBinder &Bind,
                              const llvm::json::Object &ClientCaps,
                              llvm::json::Object &ServerCaps) {}
+
+  /// Shared server facilities needed by the module to get its work done.
+  struct Facilities {
+    TUScheduler &Scheduler;
+    const SymbolIndex *Index;
+    const ThreadsafeFS &FS;
+  };
+  /// Called by the server to prepare this module for use.
+  void initialize(const Facilities &F);
+
+protected:
+  /// Accessors for modules to access shared server facilities they depend on.
+  Facilities &facilities();
+  /// The scheduler is used to run tasks on worker threads and access ASTs.
+  TUScheduler &scheduler() { return facilities().Scheduler; }
+  /// The index is used to get information about the whole codebase.
+  const SymbolIndex *index() { return facilities().Index; }
+  /// The filesystem is used to read source files on disk.
+  const ThreadsafeFS &fs() { return facilities().FS; }
+
+private:
+  llvm::Optional<Facilities> Fac;
 };
 
 /// A ModuleSet is a collection of modules installed in clangd.
 ///
 /// Modules can be looked up by type, or used through the Module interface.
 /// This allows individual modules to expose a public API.
 /// For this reason, there can be only one module of each type.
 ///

clang-tools-extra/clangd/Module.cpp

+//===--- Module.cpp - Plugging features into clangd -----------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
 #include "Module.h"
+#include "support/Logger.h"
 
 namespace clang {
 namespace clangd {
 
+void Module::initialize(const Facilities &F) {
+  assert(!Fac.hasValue() && "Initialized twice");
+  Fac.emplace(F);
+}
+
+Module::Facilities &Module::facilities() {
+  assert(Fac.hasValue() && "Not initialized yet");
+  return *Fac;
+}
+
 bool ModuleSet::addImpl(void *Key, std::unique_ptr<Module> M,
                         const char *Source) {
   if (!Map.try_emplace(Key, M.get()).second) {
     // Source should (usually) include the name of the concrete module type.
     elog("Tried to register duplicate modules via {0}", Source);
     return false;
   }
   Modules.push_back(std::move(M));
   return true;
 }
 
 } // namespace clangd
 } // namespace clang

clang-tools-extra/clangd/unittests/ClangdLSPServerTests.cpp

void initializeLSP(LSPBinder &Bind, const llvm::json::Object &ClientCaps,
       Bind.notification("add", this, &MathModule::add);
       Bind.method("get", this, &MathModule::get);
     }
 
     int Value = 0;
 
   public:
     void add(const int &X) { Value += X; }
-    void get(const std::nullptr_t &, Callback<int> Reply) { Reply(Value); }
+    void get(const std::nullptr_t &, Callback<int> Reply) {
+      scheduler().runQuick(
+          "get", "",
+          [Reply(std::move(Reply)), Value(Value)]() mutable { Reply(Value); });
+    }
   };
   ModuleSet Mods;
   Mods.add(std::make_unique<MathModule>());
   Opts.Modules = &Mods;
 
   auto &Client = start();
   Client.notify("add", 2);
   Mods.get<MathModule>()->add(8);
   EXPECT_EQ(10, Client.call("get", nullptr).takeValue());
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang