Merge commit '715dc556b782f718ce1815aaf5c58626f5fe839c' into ww07-08_oldPM

Author: vmaksimo

clang-tools-extra/clangd/ClangdLSPServer.cpp

@@ -14,6 +14,7 @@
 #include "Features.inc"
 #include "FindSymbols.h"
 #include "GlobalCompilationDatabase.h"
+#include "LSPBinder.h"
 #include "Protocol.h"
 #include "Transport.h"
 #include "support/Context.h"
@@ -90,8 +91,8 @@ class ClangdLSPServer : private ClangdServer::Callbacks {
   // Calls have signature void(const Params&, Callback<Response>).
   void onInitialize(const InitializeParams &, Callback<llvm::json::Value>);
   void onInitialized(const InitializedParams &);
-  void onShutdown(Callback<std::nullptr_t>);
-  void onSync(Callback<std::nullptr_t>);
+  void onShutdown(const NoParams &, Callback<std::nullptr_t>);
+  void onSync(const NoParams &, Callback<std::nullptr_t>);
   void onDocumentDidOpen(const DidOpenTextDocumentParams &);
   void onDocumentDidChange(const DidChangeTextDocumentParams &);
   void onDocumentDidClose(const DidCloseTextDocumentParams &);
@@ -157,11 +158,7 @@ class ClangdLSPServer : private ClangdServer::Callbacks {
                              Callback<SemanticTokensOrDelta>);
   /// This is a clangd extension. Provides a json tree representing memory usage
   /// hierarchy.
-  void onMemoryUsage(Callback<MemoryTree>);
-
-  llvm::StringMap<llvm::unique_function<void(const llvm::json::Value &,
-                                             Callback<llvm::json::Value>)>>
-      CommandHandlers;
+  void onMemoryUsage(const NoParams &, Callback<MemoryTree>);
   void onCommand(const ExecuteCommandParams &, Callback<llvm::json::Value>);
 
   /// Implement commands.
@@ -171,6 +168,7 @@ class ClangdLSPServer : private ClangdServer::Callbacks {
   void applyEdit(WorkspaceEdit WE, llvm::json::Value Success,
                  Callback<llvm::json::Value> Reply);
 
+  void bindMethods(LSPBinder &);
   std::vector<Fix> getFixes(StringRef File, const clangd::Diagnostic &D);
 
   /// Checks if completion request should be ignored. We need this due to the
@@ -229,29 +227,6 @@ class ClangdLSPServer : private ClangdServer::Callbacks {
   std::unique_ptr<MessageHandler> MsgHandler;
   std::mutex TranspWriter;
 
-  template <typename T>
-  static Expected<T> parse(const llvm::json::Value &Raw,
-                           llvm::StringRef PayloadName,
-                           llvm::StringRef PayloadKind) {
-    T Result;
-    llvm::json::Path::Root Root;
-    if (!fromJSON(Raw, Result, Root)) {
-      elog("Failed to decode {0} {1}: {2}", PayloadName, PayloadKind,
-           Root.getError());
-      // Dump the relevant parts of the broken message.
-      std::string Context;
-      llvm::raw_string_ostream OS(Context);
-      Root.printErrorContext(Raw, OS);
-      vlog("{0}", OS.str());
-      // Report the error (e.g. to the client).
-      return llvm::make_error<LSPError>(
-          llvm::formatv("failed to decode {0} {1}: {2}", PayloadName,
-                        PayloadKind, fmt_consume(Root.getError())),
-          ErrorCode::InvalidParams);
-    }
-    return std::move(Result);
-  }
-
   template <typename Response>
   void call(StringRef Method, llvm::json::Value Params, Callback<Response> CB) {
     // Wrap the callback with LSP conversion and error-handling.
@@ -261,7 +236,7 @@ class ClangdLSPServer : private ClangdServer::Callbacks {
             llvm::Expected<llvm::json::Value> RawResponse) mutable {
           if (!RawResponse)
             return CB(RawResponse.takeError());
-          CB(parse<Response>(*RawResponse, Method, "response"));
+          CB(LSPBinder::parse<Response>(*RawResponse, Method, "response"));
         };
     callRaw(Method, std::move(Params), std::move(HandleReply));
   }
@@ -274,19 +249,8 @@ class ClangdLSPServer : private ClangdServer::Callbacks {
     Params.value = std::move(Value);
     notify("$/progress", Params);
   }
-  template <typename Param, typename Result>
-  void bindCommand(llvm::StringLiteral Method,
-                   void (ClangdLSPServer::*Handler)(const Param &,
-                                                    Callback<Result>)) {
-    CommandHandlers[Method] = [Method, Handler,
-                               this](llvm::json::Value RawParams,
-                                     Callback<Result> Reply) {
-      auto P = parse<Param>(RawParams, Method, "command");
-      if (!P)
-        return Reply(P.takeError());
-      (this->*Handler)(*P, std::move(Reply));
-    };
-  }
+
+  LSPBinder::RawHandlers Handlers;
 
   const ThreadsafeFS &TFS;
   /// Options used for diagnostics.

clang-tools-extra/clangd/ClangdLSPServer.h

@@ -0,0 +1,147 @@
+//===--- LSPBinder.h - Tables of LSP handlers --------------------*- 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_LSPBINDER_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_LSPBINDER_H
+
+#include "Protocol.h"
+#include "support/Function.h"
+#include "support/Logger.h"
+#include "llvm/ADT/FunctionExtras.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/Support/JSON.h"
+
+namespace clang {
+namespace clangd {
+
+/// LSPBinder collects a table of functions that handle LSP calls.
+///
+/// It translates a handler method's signature, e.g.
+///    void codeComplete(CompletionParams, Callback<CompletionList>)
+/// into a wrapper with a generic signature:
+///    void(json::Value, Callback<json::Value>)
+/// The wrapper takes care of parsing/serializing responses.
+///
+/// Incoming calls can be methods, notifications, or commands - all are similar.
+///
+/// FIXME: this should also take responsibility for wrapping *outgoing* calls,
+/// replacing the typed ClangdLSPServer::call<> etc.
+class LSPBinder {
+public:
+  using JSON = llvm::json::Value;
+
+  struct RawHandlers {
+    template <typename HandlerT>
+    using HandlerMap = llvm::StringMap<llvm::unique_function<HandlerT>>;
+
+    HandlerMap<void(JSON)> NotificationHandlers;
+    HandlerMap<void(JSON, Callback<JSON>)> MethodHandlers;
+    HandlerMap<void(JSON, Callback<JSON>)> CommandHandlers;
+  };
+
+  LSPBinder(RawHandlers &Raw) : Raw(Raw) {}
+
+  /// Bind a handler for an LSP method.
+  /// e.g. Bind.method("peek", this, &ThisModule::peek);
+  /// Handler should be e.g. void peek(const PeekParams&, Callback<PeekResult>);
+  /// PeekParams must be JSON-parseable and PeekResult must be serializable.
+  template <typename Param, typename Result, typename ThisT>
+  void method(llvm::StringLiteral Method, ThisT *This,
+              void (ThisT::*Handler)(const Param &, Callback<Result>));
+
+  /// Bind a handler for an LSP notification.
+  /// e.g. Bind.notification("poke", this, &ThisModule::poke);
+  /// Handler should be e.g. void poke(const PokeParams&);
+  /// PokeParams must be JSON-parseable.
+  template <typename Param, typename ThisT>
+  void notification(llvm::StringLiteral Method, ThisT *This,
+                    void (ThisT::*Handler)(const Param &));
+
+  /// Bind a handler for an LSP command.
+  /// e.g. Bind.command("load", this, &ThisModule::load);
+  /// Handler should be e.g. void load(const LoadParams&, Callback<LoadResult>);
+  /// LoadParams must be JSON-parseable and LoadResult must be serializable.
+  template <typename Param, typename Result, typename ThisT>
+  void command(llvm::StringLiteral Command, ThisT *This,
+               void (ThisT::*Handler)(const Param &, Callback<Result>));
+
+  // FIXME: remove usage from ClangdLSPServer and make this private.
+  template <typename T>
+  static llvm::Expected<T> parse(const llvm::json::Value &Raw,
+                                 llvm::StringRef PayloadName,
+                                 llvm::StringRef PayloadKind);
+
+private:
+  RawHandlers &Raw;
+};
+
+template <typename T>
+llvm::Expected<T> LSPBinder::parse(const llvm::json::Value &Raw,
+                                   llvm::StringRef PayloadName,
+                                   llvm::StringRef PayloadKind) {
+  T Result;
+  llvm::json::Path::Root Root;
+  if (!fromJSON(Raw, Result, Root)) {
+    elog("Failed to decode {0} {1}: {2}", PayloadName, PayloadKind,
+         Root.getError());
+    // Dump the relevant parts of the broken message.
+    std::string Context;
+    llvm::raw_string_ostream OS(Context);
+    Root.printErrorContext(Raw, OS);
+    vlog("{0}", OS.str());
+    // Report the error (e.g. to the client).
+    return llvm::make_error<LSPError>(
+        llvm::formatv("failed to decode {0} {1}: {2}", PayloadName, PayloadKind,
+                      fmt_consume(Root.getError())),
+        ErrorCode::InvalidParams);
+  }
+  return std::move(Result);
+}
+
+template <typename Param, typename Result, typename ThisT>
+void LSPBinder::method(llvm::StringLiteral Method, ThisT *This,
+                       void (ThisT::*Handler)(const Param &,
+                                              Callback<Result>)) {
+  Raw.MethodHandlers[Method] = [Method, Handler, This](JSON RawParams,
+                                                       Callback<JSON> Reply) {
+    auto P = LSPBinder::parse<Param>(RawParams, Method, "request");
+    if (!P)
+      return Reply(P.takeError());
+    (This->*Handler)(*P, std::move(Reply));
+  };
+}
+
+template <typename Param, typename ThisT>
+void LSPBinder::notification(llvm::StringLiteral Method, ThisT *This,
+                             void (ThisT::*Handler)(const Param &)) {
+  Raw.NotificationHandlers[Method] = [Method, Handler, This](JSON RawParams) {
+    llvm::Expected<Param> P =
+        LSPBinder::parse<Param>(RawParams, Method, "request");
+    if (!P)
+      return llvm::consumeError(P.takeError());
+    (This->*Handler)(*P);
+  };
+}
+
+template <typename Param, typename Result, typename ThisT>
+void LSPBinder::command(llvm::StringLiteral Method, ThisT *This,
+                        void (ThisT::*Handler)(const Param &,
+                                               Callback<Result>)) {
+  Raw.CommandHandlers[Method] = [Method, Handler, This](JSON RawParams,
+                                                        Callback<JSON> Reply) {
+    auto P = LSPBinder::parse<Param>(RawParams, Method, "command");
+    if (!P)
+      return Reply(P.takeError());
+    (This->*Handler)(*P, std::move(Reply));
+  };
+}
+
+} // namespace clangd
+} // namespace clang
+
+#endif

clang-tools-extra/clangd/LSPBinder.h

@@ -1,7 +1,10 @@
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_MODULE_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_MODULE_H
 
+#include "LSPBinder.h"
+#include "Protocol.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/JSON.h"
 #include <memory>
 #include <vector>
 
@@ -10,14 +13,11 @@ namespace clangd {
 
 /// A Module contributes a vertical feature to clangd.
 ///
-/// FIXME: Extend this with LSP bindings to support reading/updating
-/// capabilities and implementing LSP endpoints.
+/// 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
-///    FIXME: LSP bindings should be registered at ClangdLSPServer
-///    initialization.
 ///  - 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.
@@ -30,6 +30,17 @@ namespace clangd {
 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.
+  // FIXME: ClientCaps should be a raw json::Object here.
+  virtual void initializeLSP(LSPBinder &Bind,
+                             const ClientCapabilities &ClientCaps,
+                             llvm::json::Object &ServerCaps) {}
 };
 
 class ModuleSet {

clang-tools-extra/clangd/Module.h

@@ -70,6 +70,7 @@ add_unittest(ClangdUnitTests ClangdTests
   IndexTests.cpp
   JSONTransportTests.cpp
   LoggerTests.cpp
+  LSPBinderTests.cpp
   LSPClient.cpp
   ModulesTests.cpp
   ParsedASTTests.cpp

clang-tools-extra/clangd/unittests/CMakeLists.txt

@@ -221,6 +221,29 @@ TEST_F(LSPTest, CDBConfigIntegration) {
                   DiagMessage("Use of undeclared identifier 'BAR'"))));
 }
 
+TEST_F(LSPTest, ModulesTest) {
+  class MathModule : public Module {
+    void initializeLSP(LSPBinder &Bind, const ClientCapabilities &ClientCaps,
+                       llvm::json::Object &ServerCaps) override {
+      Bind.notification("add", this, &MathModule::add);
+      Bind.method("get", this, &MathModule::get);
+    }
+
+    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;
+
+  auto &Client = start();
+  Client.notify("add", 2);
+  Client.notify("add", 8);
+  EXPECT_EQ(10, Client.call("get", nullptr).takeValue());
+}
+
 } // namespace
 } // namespace clangd
 } // namespace clang