[clangd] Modules can have a public API. NFC

[kadircet]

thanks, lgtm!

clang-tools-extra/clangd/ClangdServer.h

349

nit: = nullptr

clang-tools-extra/clangd/Module.cpp

8

should we log/assert?

clang-tools-extra/clangd/CMakeLists.txt

add_clang_library(clangDaemon
   FuzzyMatch.cpp
   GlobalCompilationDatabase.cpp
   Headers.cpp
   HeaderSourceSwitch.cpp
   HeuristicResolver.cpp
   Hover.cpp
   IncludeFixer.cpp
   JSONTransport.cpp
+  Module.cpp
   PathMapping.cpp
   Protocol.cpp
   Quality.cpp
   ParsedAST.cpp
   Preamble.cpp
   RIFF.cpp
   Selection.cpp
   SemanticHighlighting.cpp

clang-tools-extra/clangd/ClangdServer.h

public:
   /// ClangdServer uses \p CDB to obtain compilation arguments for parsing. Note
   /// that ClangdServer only obtains compilation arguments once for each newly
   /// added file (i.e., when processing a first call to addDocument) and reuses
   /// those arguments for subsequent reparses. However, ClangdServer will check
   /// if compilation arguments changed on calls to forceReparse().
   ClangdServer(const GlobalCompilationDatabase &CDB, const ThreadsafeFS &TFS,
                const Options &Opts, Callbacks *Callbacks = nullptr);
 
+  /// Gets the installed module of a given type, if any.
+  /// This exposes access the public interface of modules that have one.
+  template <typename Mod> Mod *getModule() {
+    return Modules ? Modules->get<Mod>() : nullptr;
+  }
+  template <typename Mod> const Mod *getModule() const {
+    return Modules ? Modules->get<Mod>() : nullptr;
+  }
+
   /// 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.
   /// Version identifies this snapshot and is propagated to ASTs, preambles,
   /// diagnostics etc built from it.
   void addDocument(PathRef File, StringRef Contents,
                    llvm::StringRef Version = "null",
public:
   /// Builds a nested representation of memory used by components.
   void profile(MemoryTree &MT) const;
 
 private:
   void formatCode(PathRef File, llvm::StringRef Code,
                   ArrayRef<tooling::Range> Ranges,
                   Callback<tooling::Replacements> CB);
 
+  ModuleSet *Modules;
   const GlobalCompilationDatabase &CDB;
   const ThreadsafeFS &TFS;
 
   Path ResourceDir;
   // The index used to look up symbols. This could be:
   //   - null (all index functionality is optional)
   //   - the dynamic index owned by ClangdServer (DynamicIdx)
   //   - the static index passed to the constructor

clang-tools-extra/clangd/ClangdServer.cpp

ClangdServer::Options::operator TUScheduler::Options() const {
   Opts.UpdateDebounce = UpdateDebounce;
   Opts.ContextProvider = ContextProvider;
   return Opts;
 }
 
 ClangdServer::ClangdServer(const GlobalCompilationDatabase &CDB,
                            const ThreadsafeFS &TFS, const Options &Opts,
                            Callbacks *Callbacks)
-    : CDB(CDB), TFS(TFS),
+    : Modules(Opts.Modules), CDB(CDB), TFS(TFS),
       DynamicIdx(Opts.BuildDynamicSymbolIndex ? new FileIndex() : nullptr),
       ClangTidyProvider(Opts.ClangTidyProvider),
       WorkspaceRoot(Opts.WorkspaceRoot),
       // Pass a callback into `WorkScheduler` to extract symbols from a newly
       // parsed file and rebuild the file index synchronously each time an AST
       // is parsed.
       // FIXME(ioeric): this can be slow and we may be able to index on less
       // critical paths.

clang-tools-extra/clangd/Module.h

 #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 {
 
 /// A Module contributes a vertical feature to clangd.
 ///
 /// FIXME: Extend this to support outgoing LSP calls.
public:
   ///
   /// 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) {}
 };
 
+/// 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.
+///
+/// ModuleSet owns the modules. It is itself owned by main, not ClangdServer.
 class ModuleSet {
   std::vector<std::unique_ptr<Module>> Modules;
+  llvm::DenseMap<void *, Module *> Map;
+
+  template <typename Mod> struct ID {
+    static_assert(std::is_base_of<Module, Mod>::value &&
+                      std::is_final<Mod>::value,
+                  "Modules must be final classes derived from clangd::Module");
+    static int Key;
+  };
+
+  bool addImpl(void *Key, std::unique_ptr<Module>, const char *Source);
 
 public:
-  explicit ModuleSet(std::vector<std::unique_ptr<Module>> Modules)
-      : Modules(std::move(Modules)) {}
+  ModuleSet() = default;
 
   using iterator = llvm::pointee_iterator<decltype(Modules)::iterator>;
   using const_iterator =
       llvm::pointee_iterator<decltype(Modules)::const_iterator>;
   iterator begin() { return iterator(Modules.begin()); }
   iterator end() { return iterator(Modules.end()); }
   const_iterator begin() const { return const_iterator(Modules.begin()); }
   const_iterator end() const { return const_iterator(Modules.end()); }
+
+  template <typename Mod> bool add(std::unique_ptr<Mod> M) {
+    return addImpl(&ID<Mod>::Key, std::move(M), LLVM_PRETTY_FUNCTION);
+  }
+  template <typename Mod> Mod *get() {
+    return static_cast<Mod *>(Map.lookup(&ID<Mod>::Key));
+  }
+  template <typename Mod> const Mod *get() const {
+    return const_cast<ModuleSet *>(this)->get<Mod>();
+  }
 };
+
+template <typename Mod> int ModuleSet::ID<Mod>::Key;
+
 } // namespace clangd
 } // namespace clang
 #endif

clang-tools-extra/clangd/Module.cpp

+#include "Module.h"
+
+namespace clang {
+namespace clangd {
+
+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

)yaml";
   // bar.cpp shows the configured compile command.
   Client.didOpen("bar.cpp", "int x = FOO;");
   EXPECT_THAT(Client.diagnostics("bar.cpp"),
               llvm::ValueIs(testing::ElementsAre(
                   DiagMessage("Use of undeclared identifier 'BAR'"))));
 }
 
 TEST_F(LSPTest, ModulesTest) {
-  class MathModule : public Module {
+  class MathModule final : public Module {
     void initializeLSP(LSPBinder &Bind, const llvm::json::Object &ClientCaps,
                        llvm::json::Object &ServerCaps) override {
       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); }
-    int Value = 0;
   };
-  std::vector<std::unique_ptr<Module>> Mods;
-  Mods.push_back(std::make_unique<MathModule>());
-  ModuleSet ModSet(std::move(Mods));
-  Opts.Modules = &ModSet;
+  ModuleSet Mods;
+  Mods.add(std::make_unique<MathModule>());
+  Opts.Modules = &Mods;
 
   auto &Client = start();
   Client.notify("add", 2);
-  Client.notify("add", 8);
+  Mods.get<MathModule>()->add(8);
   EXPECT_EQ(10, Client.call("get", nullptr).takeValue());
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang