[clangd] Add clangd.serverInfo command to inspect server state.

[sammccall]

Summary

Initially just export the information that's easily available.
(I want to measure changes in dynamic index size, so this is good enough for now)

[ioeric]

How will this command be triggered? What's the advantage comparing to vloging?

[MaskRay]

Rather than use a workspace/executeCommand command, you may consider making it a custom request message whose method name starts with $/

https://microsoft.github.io/language-server-protocol/specification

Notification and requests whose methods start with ‘$/’ are messages which are protocol implementation dependent and might not be implementable in all clients or servers. For example if the server implementation uses a single threaded synchronous programming language then there is little a server can do to react to a ‘$/cancelRequest’. If a server or client receives notifications or requests starting with ‘$/’ it is free to ignore them if they are unknown.

The return type of workspace/executeCommand is any | null per spec, but its interpretation may not be that flexible in some clients. It is pretty simple to use lsp-mode eglot vscode-languageclient to send custom request messages, though.

clangd/ClangdLSPServer.cpp

 //===--- ClangdLSPServer.cpp - LSP server ------------------------*- C++-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ClangdLSPServer.h"
 #include "Diagnostics.h"
 #include "JSONRPCDispatcher.h"
 #include "SourceCode.h"
 #include "URI.h"
+#include "clang/Basic/Version.h"
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/Path.h"
 
 using namespace clang::clangd;
 using namespace clang;
 using namespace llvm;
if (Params.command == ExecuteCommandParams::CLANGD_APPLY_FIX_COMMAND &&
     // 3. We send code actions, with the fixit embedded as context
     // 4. The user selects the fixit, the editor asks us to apply it
     // 5. We unwrap the changes and send them back to the editor
     // 6. The editor applies the changes (applyEdit), and sends us a reply (but
     // we ignore it)
 
     reply("Fix applied.");
     ApplyEdit(*Params.workspaceEdit);
+  } else if (Params.command == ExecuteCommandParams::CLANGD_SERVER_INFO) {
+    json::Object Info{
+        {"version", getClangToolFullVersion("clangd")},
+    };
+    if (const auto *DynIndex = Server->dynamicIndex()) {
+      Info["dynamicIndex"] = json::Object{
+          {"memory", int64_t(DynIndex->estimateMemoryUsage())},
+      };
+    }
+    json::Object TrackedFiles;
+    auto MemUse = Server->getUsedBytesPerFile();
+    DenseMap<StringRef, size_t> MemUseMap = {MemUse.begin(), MemUse.end()};
+    for (const auto &File : DraftMgr.getActiveFiles()) {
+      json::Object FileInfo;
+      if (auto Data = DraftMgr.getDraft(File))
+        FileInfo["size"] = int64_t(Data->size());
+      if (auto Mem = MemUseMap.lookup(File))
+        FileInfo["memory"] = int64_t(Mem);
+      TrackedFiles[File] = std::move(FileInfo);
+    }
+    Info["files"] = std::move(TrackedFiles);
+    reply(std::move(Info));
   } else {
     // We should not get here because ExecuteCommandParams would not have
     // parsed in the first place and this handler should not be called. But if
     // more commands are added, this will be here has a safe guard.
     replyError(
         ErrorCode::InvalidParams,
         llvm::formatv("Unsupported command \"{0}\".", Params.command).str());
   }

clangd/Protocol.h

 /// handle maps to a certain llvm::Optional of some struct to contain its
 /// arguments. Different commands could reuse the same llvm::Optional as
 /// arguments but a command that needs different arguments would simply add a
 /// new llvm::Optional and not use any other ones. In practice this means only
 /// one argument type will be parsed and set.
 struct ExecuteCommandParams {
   // Command to apply fix-its. Uses WorkspaceEdit as argument.
   const static llvm::StringLiteral CLANGD_APPLY_FIX_COMMAND;
+  // Retrieve information about the server state. No arguments.
+  const static llvm::StringLiteral CLANGD_SERVER_INFO;
 
   /// The command identifier, e.g. CLANGD_APPLY_FIX_COMMAND
   std::string command;
 
   // Arguments
   llvm::Optional<WorkspaceEdit> workspaceEdit;
 };
 bool fromJSON(const llvm::json::Value &, ExecuteCommandParams &);

clangd/Protocol.cpp

 
 bool fromJSON(const json::Value &Params, WorkspaceEdit &R) {
   json::ObjectMapper O(Params);
   return O && O.map("changes", R.changes);
 }
 
 const llvm::StringLiteral ExecuteCommandParams::CLANGD_APPLY_FIX_COMMAND =
     "clangd.applyFix";
+const llvm::StringLiteral ExecuteCommandParams::CLANGD_SERVER_INFO =
+    "clangd.serverInfo";
 bool fromJSON(const json::Value &Params, ExecuteCommandParams &R) {
   json::ObjectMapper O(Params);
   if (!O || !O.map("command", R.command))
     return false;
 
   auto Args = Params.getAsObject()->getArray("arguments");
   if (R.command == ExecuteCommandParams::CLANGD_APPLY_FIX_COMMAND) {
     return Args && Args->size() == 1 &&
            fromJSON(Args->front(), R.workspaceEdit);
+  } else if (R.command == ExecuteCommandParams::CLANGD_SERVER_INFO) {
+    return true; // No args.
   }
   return false; // Unrecognized command.
 }
 
 json::Value toJSON(const SymbolInformation &P) {
   return json::Object{
       {"name", P.name},
       {"kind", static_cast<int>(P.kind)},