[clangd] Delay binding LSP methods until initialize. NFC

[sammccall]

Summary

This is NFC because the MessageHandler refused to dispatch to them until the
server is initialized anyway.

This is a more natural time to bind them - it's when they become callable, and
it's when client capabalities are available and server ones can be set.

One module-lifecycle function will be responsible for all three.

[kadircet]

clang-tools-extra/clangd/ClangdLSPServer.cpp

175

this one is a functional change though , previously we would say notification X before initialization for cancellations that arrived before init, now we are going to say "bad cancellation request". not that it is bad, but it makes me wonder if it is intentional :D

179

you mean just else ?

[sammccall]

clang-tools-extra/clangd/ClangdLSPServer.cpp

175

Oops, yes - unintentional.
(now the structure of onNotify and onCall looks more similar, thanks!)

[sammccall]

address comments & rebase

clang-tools-extra/clangd/ClangdLSPServer.h

private:
 
   /// Implement commands.
   void onCommandApplyEdit(const WorkspaceEdit &, Callback<llvm::json::Value>);
   void onCommandApplyTweak(const TweakArgs &, Callback<llvm::json::Value>);
 
   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
   /// limitation of the LSP. Per LSP, a client sends requests for all "trigger
   /// character" we specify, but for '>' and ':' we need to check they actually
   /// produce '->' and '::', respectively.
   bool shouldRunCompletion(const CompletionParams &Params) const;
 

clang-tools-extra/clangd/ClangdLSPServer.cpp

public:
 
   bool onNotify(llvm::StringRef Method, llvm::json::Value Params) override {
     trace::Span Tracer(Method, LSPLatency);
     SPAN_ATTACH(Tracer, "Params", Params);
     WithContext HandlerContext(handlerContext());
     log("<-- {0}", Method);
     if (Method == "exit")
       return false;
-    if (!Server.Server) {
-      elog("Notification {0} before initialization", Method);
-    } else if (Method == "$/cancelRequest") {
-      onCancel(std::move(Params));
-    } else {
-      auto Handler = Server.Handlers.NotificationHandlers.find(Method);
-      if (Handler != Server.Handlers.NotificationHandlers.end()) {
-        Handler->second(std::move(Params));
-        Server.maybeExportMemoryProfile();
-        Server.maybeCleanupMemory();
-      } else {
-        log("unhandled notification {0}", Method);
-      }
-    }
+    } else if (!Server.Server) {
+      elog("Notification {0} before initialization", Method);
+    } else if (Method == "$/cancelRequest") {
+      onCancel(std::move(Params));
     return true;
   }
 
   bool onCall(llvm::StringRef Method, llvm::json::Value Params,
               llvm::json::Value ID) override {
     WithContext HandlerContext(handlerContext());
     // Calls can be canceled by the client. Add cancellation context.
     WithContext WithCancel(cancelableRequestContext(ID));
     trace::Span Tracer(Method, LSPLatency);
     SPAN_ATTACH(Tracer, "Params", Params);
     ReplyOnce Reply(ID, Method, &Server, Tracer.Args);
     log("<-- {0}({1})", Method, ID);
-    if (!Server.Server && Method != "initialize") {
-      elog("Call {0} before initialization.", Method);
-      Reply(llvm::make_error<LSPError>("server not initialized",
-                                       ErrorCode::ServerNotInitialized));
-    } else {
-      auto Handler = Server.Handlers.MethodHandlers.find(Method);
-      if (Handler != Server.Handlers.MethodHandlers.end()) {
-        Handler->second(std::move(Params), std::move(Reply));
-      } else {
-        Reply(llvm::make_error<LSPError>("method not found",
-                                         ErrorCode::MethodNotFound));
-      }
-    }
+    } else if (!Server.Server) {
+      elog("Call {0} before initialization.", Method);
+      Reply(llvm::make_error<LSPError>("server not initialized",
+                                       ErrorCode::ServerNotInitialized));
     return true;
   }
 
   bool onReply(llvm::json::Value ID,
                llvm::Expected<llvm::json::Value> Result) override {
     WithContext HandlerContext(handlerContext());
 
     Callback<llvm::json::Value> ReplyHandler = nullptr;
llvm::json::Object ServerCaps{
       {"memoryUsageProvider", true}, // clangd extension
       {"compilationDatabase",        // clangd extension
        llvm::json::Object{{"automaticReload", true}}},
       {"callHierarchyProvider", true},
   };
 
   {
     LSPBinder Binder(Handlers);
+    bindMethods(Binder);
     if (Opts.Modules)
       for (auto &Mod : *Opts.Modules)
         Mod.initializeLSP(Binder, Params.capabilities, ServerCaps);
   }
 
   // Per LSP, renameProvider can be either boolean or RenameOptions.
   // RenameOptions will be specified if the client states it supports prepare.
   ServerCaps["renameProvider"] =
: ShouldProfile(/*Period=*/std::chrono::minutes(5),
       SupportedSymbolKinds(defaultSymbolKinds()),
       SupportedCompletionItemKinds(defaultCompletionItemKinds()), Opts(Opts) {
   if (Opts.ConfigProvider) {
     assert(!Opts.ContextProvider &&
            "Only one of ConfigProvider and ContextProvider allowed!");
     this->Opts.ContextProvider = ClangdServer::createConfiguredContextProvider(
         Opts.ConfigProvider, this);
   }
-
-  // clang-format off
   LSPBinder Bind(this->Handlers);
   Bind.method("initialize", this, &ClangdLSPServer::onInitialize);
+}
+
+void ClangdLSPServer::bindMethods(LSPBinder &Bind) {
+  // clang-format off
   Bind.notification("initialized", this, &ClangdLSPServer::onInitialized);
   Bind.method("shutdown", this, &ClangdLSPServer::onShutdown);
   Bind.method("sync", this, &ClangdLSPServer::onSync);
   Bind.method("textDocument/rangeFormatting", this, &ClangdLSPServer::onDocumentRangeFormatting);
   Bind.method("textDocument/onTypeFormatting", this, &ClangdLSPServer::onDocumentOnTypeFormatting);
   Bind.method("textDocument/formatting", this, &ClangdLSPServer::onDocumentFormatting);
   Bind.method("textDocument/codeAction", this, &ClangdLSPServer::onCodeAction);
   Bind.method("textDocument/completion", this, &ClangdLSPServer::onCompletion);