CbC/CbC_llvm: clang-tools-extra/clangd/ClangdLSPServer.cpp comparison

comparison clang-tools-extra/clangd/ClangdLSPServer.cpp @ 207:2e18cbf3894f

LLVM12

author	Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date	Tue, 08 Jun 2021 06:07:14 +0900
parents	0572611fdcc8
children	5f17cb93ff66

comparison

equal deleted inserted replaced

-:0572611fdcc8
+:2e18cbf3894f
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #include "ClangdLSPServer.h"
+#include "ClangdServer.h"
 #include "CodeComplete.h"
 #include "Diagnostics.h"
 #include "DraftStore.h"
+#include "DumpAST.h"
 #include "GlobalCompilationDatabase.h"
+#include "LSPBinder.h"
 #include "Protocol.h"
 #include "SemanticHighlighting.h"
 #include "SourceCode.h"
 #include "TUScheduler.h"
 #include "URI.h"
 #include "refactor/Tweak.h"
 #include "support/Context.h"
+#include "support/MemoryTree.h"
 #include "support/Trace.h"
+#include "clang/AST/ASTContext.h"
 #include "clang/Basic/Version.h"
 #include "clang/Tooling/Core/Replacement.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/iterator_range.h"
+#include "llvm/Support/Allocator.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/JSON.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/SHA1.h"
 #include "llvm/Support/ScopedPrinter.h"
+#include "llvm/Support/raw_ostream.h"
+#include <chrono>
 #include <cstddef>
+#include <cstdint>
+#include <functional>
 #include <memory>
 #include <mutex>
 #include <string>
 #include <vector>
 namespace clang {
 namespace clangd {
 namespace {
 // Tracks end-to-end latency of high level lsp calls. Measurements are in
 // seconds.
 constexpr trace::Metric LSPLatency("lsp_latency", trace::Metric::Distribution,
 "method_name");
 // LSP defines file versions as numbers that increase.
 // ClangdServer treats them as opaque and therefore uses strings instead.
-std::string encodeVersion(int64_t LSPVersion) {
+std::string encodeVersion(llvm::Optional<int64_t> LSPVersion) {
-return llvm::to_string(LSPVersion);
+return LSPVersion ? llvm::to_string(*LSPVersion) : "";
 }
 llvm::Optional<int64_t> decodeVersion(llvm::StringRef Encoded) {
 int64_t Result;
 if (llvm::to_integer(Encoded, Result, 10))
 return Result;
-else if (!Encoded.empty()) // Empty can be e.g. diagnostics on close.
+if (!Encoded.empty()) // Empty can be e.g. diagnostics on close.
 elog("unexpected non-numeric version {0}", Encoded);
 return llvm::None;
 }
+const llvm::StringLiteral APPLY_FIX_COMMAND = "clangd.applyFix";
+const llvm::StringLiteral APPLY_TWEAK_COMMAND = "clangd.applyTweak";
 /// Transforms a tweak into a code action that would apply it if executed.
 /// EXPECTS: T.prepare() was called and returned true.
 CodeAction toCodeAction(const ClangdServer::TweakRef &T, const URIForFile &File,
 Range Selection) {
 CodeAction CA;
 CA.title = T.Title;
-switch (T.Intent) {
+CA.kind = T.Kind.str();
-case Tweak::Refactor:
-CA.kind = std::string(CodeAction::REFACTOR_KIND);
-break;
-case Tweak::Info:
-CA.kind = std::string(CodeAction::INFO_KIND);
-break;
-}
 // This tweak may have an expensive second stage, we only run it if the user
 // actually chooses it in the UI. We reply with a command that would run the
 // corresponding tweak.
 // FIXME: for some tweaks, computing the edits is cheap and we could send them
 //        directly.
 CA.command.emplace();
 CA.command->title = T.Title;
-CA.command->command = std::string(Command::CLANGD_APPLY_TWEAK);
+CA.command->command = std::string(APPLY_TWEAK_COMMAND);
-CA.command->tweakArgs.emplace();
+TweakArgs Args;
-CA.command->tweakArgs->file = File;
+Args.file = File;
-CA.command->tweakArgs->tweakID = T.ID;
+Args.tweakID = T.ID;
-CA.command->tweakArgs->selection = Selection;
+Args.selection = Selection;
+CA.command->argument = std::move(Args);
 return CA;
 }
 void adjustSymbolKinds(llvm::MutableArrayRef<DocumentSymbol> Syms,
 SymbolKindBitset Kinds) {
 I <= static_cast<size_t>(CompletionItemKind::Reference); ++I)
 Defaults.set(I);
 return Defaults;
 }
-// Build a lookup table (HighlightingKind => {TextMate Scopes}), which is sent
-// to the LSP client.
-std::vector<std::vector<std::string>> buildHighlightScopeLookupTable() {
-std::vector<std::vector<std::string>> LookupTable;
-// HighlightingKind is using as the index.
-for (int KindValue = 0; KindValue <= (int)HighlightingKind::LastKind;
-++KindValue)
-LookupTable.push_back(
-{std::string(toTextMateScope((HighlightingKind)(KindValue)))});
-return LookupTable;
-}
 // Makes sure edits in \p FE are applicable to latest file contents reported by
 // editor. If not generates an error message containing information about files
 // that needs to be saved.
-llvm::Error validateEdits(const DraftStore &DraftMgr, const FileEdits &FE) {
+llvm::Error validateEdits(const ClangdServer &Server, const FileEdits &FE) {
 size_t InvalidFileCount = 0;
 llvm::StringRef LastInvalidFile;
 for (const auto &It : FE) {
-if (auto Draft = DraftMgr.getDraft(It.first())) {
+if (auto Draft = Server.getDraft(It.first())) {
 // If the file is open in user's editor, make sure the version we
 // saw and current version are compatible as this is the text that
 // will be replaced by editors.
-if (!It.second.canApplyTo(Draft->Contents)) {
+if (!It.second.canApplyTo(*Draft)) {
 ++InvalidFileCount;
 LastInvalidFile = It.first();
 }
 }
 }
 if (!InvalidFileCount)
 return llvm::Error::success();
 if (InvalidFileCount == 1)
-return llvm::createStringError(llvm::inconvertibleErrorCode(),
+return error("File must be saved first: {0}", LastInvalidFile);
-"File must be saved first: " +
+return error("Files must be saved first: {0} (and {1} others)",
-LastInvalidFile);
+LastInvalidFile, InvalidFileCount - 1);
-return llvm::createStringError(
+}
-llvm::inconvertibleErrorCode(),
-"Files must be saved first: " + LastInvalidFile + " (and " +
-llvm::to_string(InvalidFileCount - 1) + " others)");
-}
 } // namespace
 // MessageHandler dispatches incoming LSP messages.
 // It handles cross-cutting concerns:
 //  - serializes/deserializes protocol objects to JSON
 class ClangdLSPServer::MessageHandler : public Transport::MessageHandler {
 public:
 MessageHandler(ClangdLSPServer &Server) : Server(Server) {}
 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)
+auto Handler = Server.Handlers.NotificationHandlers.find(Method);
+if (Handler != Server.Handlers.NotificationHandlers.end()) {
+Handler->second(std::move(Params));
+Server.maybeExportMemoryProfile();
+Server.maybeCleanupMemory();
+} else if (!Server.Server) {
 elog("Notification {0} before initialization", Method);
-else if (Method == "$/cancelRequest")
+} else if (Method == "$/cancelRequest") {
 onCancel(std::move(Params));
-else if (auto Handler = Notifications.lookup(Method))
+} else {
-Handler(std::move(Params));
-else
 log("unhandled notification {0}", Method);
+}
 return true;
 }
 bool onCall(llvm::StringRef Method, llvm::json::Value Params,
 llvm::json::Value ID) override {
 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") {
+auto Handler = Server.Handlers.MethodHandlers.find(Method);
+if (Handler != Server.Handlers.MethodHandlers.end()) {
+Handler->second(std::move(Params), std::move(Reply));
+} else if (!Server.Server) {
 elog("Call {0} before initialization.", Method);
 Reply(llvm::make_error<LSPError>("server not initialized",
 ErrorCode::ServerNotInitialized));
-} else if (auto Handler = Calls.lookup(Method))
+} else {
-Handler(std::move(Params), std::move(Reply));
-else
 Reply(llvm::make_error<LSPError>("method not found",
 ErrorCode::MethodNotFound));
+}
 return true;
 }
 bool onReply(llvm::json::Value ID,
 llvm::Expected<llvm::json::Value> Result) override {
 ReplyHandler(std::move(Err));
 }
 return true;
 }
-// Bind an LSP method name to a call.
-template <typename Param, typename Result>
-void bind(const char *Method,
-void (ClangdLSPServer::*Handler)(const Param &, Callback<Result>)) {
-Calls[Method] = [Method, Handler, this](llvm::json::Value RawParams,
-ReplyOnce Reply) {
-Param P;
-if (fromJSON(RawParams, P)) {
-(Server.*Handler)(P, std::move(Reply));
-} else {
-elog("Failed to decode {0} request.", Method);
-Reply(llvm::make_error<LSPError>("failed to decode request",
-ErrorCode::InvalidRequest));
-}
-};
-}
 // Bind a reply callback to a request. The callback will be invoked when
 // clangd receives the reply from the LSP client.
 // Return a call id of the request.
 llvm::json::Value bindReply(Callback<llvm::json::Value> Reply) {
 llvm::Optional<std::pair<int, Callback<llvm::json::Value>>> OldestCB;
 OldestCB = std::move(ReplyCallbacks.front());
 ReplyCallbacks.pop_front();
 }
 }
 if (OldestCB)
-OldestCB->second(llvm::createStringError(
+OldestCB->second(
-llvm::inconvertibleErrorCode(),
+error("failed to receive a client reply for request ({0})",
-llvm::formatv("failed to receive a client reply for request ({0})",
+OldestCB->first));
-OldestCB->first)));
 return ID;
-}
-// Bind an LSP method name to a notification.
-template <typename Param>
-void bind(const char *Method,
-void (ClangdLSPServer::*Handler)(const Param &)) {
-Notifications[Method] = [Method, Handler,
-this](llvm::json::Value RawParams) {
-Param P;
-if (!fromJSON(RawParams, P)) {
-elog("Failed to decode {0} request.", Method);
-return;
-}
-trace::Span Tracer(Method, LSPLatency);
-SPAN_ATTACH(Tracer, "Params", RawParams);
-(Server.*Handler)(P);
-};
 }
 private:
 // Function object to reply to an LSP call.
 // Each instance must be called exactly once, otherwise:
 Server->Transp.reply(std::move(ID), std::move(Err));
 }
 }
 };
-llvm::StringMap<std::function<void(llvm::json::Value)>> Notifications;
-llvm::StringMap<std::function<void(llvm::json::Value, ReplyOnce)>> Calls;
 // Method calls may be cancelled by ID, so keep track of their state.
 // This needs a mutex: handlers may finish on a different thread, and that's
 // when we clean up entries in the map.
 mutable std::mutex RequestCancelersMutex;
 llvm::StringMap<std::pair<Canceler, /*Cookie*/ unsigned>> RequestCancelers;
 }
 Context handlerContext() const {
 return Context::current().derive(
 kCurrentOffsetEncoding,
-Server.NegotiatedOffsetEncoding.getValueOr(OffsetEncoding::UTF16));
+Server.Opts.Encoding.getValueOr(OffsetEncoding::UTF16));
 }
 // We run cancelable requests in a context that does two things:
 //  - allows cancellation using RequestCancelers[ID]
 //  - cleans up the entry in RequestCancelers when it's no longer needed
 ClangdLSPServer &Server;
 };
 constexpr int ClangdLSPServer::MessageHandler::MaxReplayCallbacks;
 // call(), notify(), and reply() wrap the Transport, adding logging and locking.
-void ClangdLSPServer::callRaw(StringRef Method, llvm::json::Value Params,
+void ClangdLSPServer::callMethod(StringRef Method, llvm::json::Value Params,
 Callback<llvm::json::Value> CB) {
 auto ID = MsgHandler->bindReply(std::move(CB));
 log("--> {0}({1})", Method, ID);
 std::lock_guard<std::mutex> Lock(TranspWriter);
 Transp.call(Method, std::move(Params), ID);
 }
 void ClangdLSPServer::notify(llvm::StringRef Method, llvm::json::Value Params) {
 log("--> {0}", Method);
+maybeCleanupMemory();
 std::lock_guard<std::mutex> Lock(TranspWriter);
 Transp.notify(Method, std::move(Params));
 }
 static std::vector<llvm::StringRef> semanticTokenTypes() {
 ++I)
 Types.push_back(toSemanticTokenType(static_cast<HighlightingKind>(I)));
 return Types;
 }
+static std::vector<llvm::StringRef> semanticTokenModifiers() {
+std::vector<llvm::StringRef> Modifiers;
+for (unsigned I = 0;
+I <= static_cast<unsigned>(HighlightingModifier::LastModifier); ++I)
+Modifiers.push_back(
+toSemanticTokenModifier(static_cast<HighlightingModifier>(I)));
+return Modifiers;
+}
 void ClangdLSPServer::onInitialize(const InitializeParams &Params,
 Callback<llvm::json::Value> Reply) {
 // Determine character encoding first as it affects constructed ClangdServer.
-if (Params.capabilities.offsetEncoding && !NegotiatedOffsetEncoding) {
+if (Params.capabilities.offsetEncoding && !Opts.Encoding) {
-NegotiatedOffsetEncoding = OffsetEncoding::UTF16; // fallback
+Opts.Encoding = OffsetEncoding::UTF16; // fallback
 for (OffsetEncoding Supported : *Params.capabilities.offsetEncoding)
 if (Supported != OffsetEncoding::UnsupportedEncoding) {
-NegotiatedOffsetEncoding = Supported;
+Opts.Encoding = Supported;
 break;
 }
 }
-ClangdServerOpts.TheiaSemanticHighlighting =
-Params.capabilities.TheiaSemanticHighlighting;
 if (Params.capabilities.TheiaSemanticHighlighting &&
-Params.capabilities.SemanticTokens) {
+!Params.capabilities.SemanticTokens) {
-log("Client supports legacy semanticHighlights notification and standard "
+elog("Client requested legacy semanticHighlights notification, which is "
-"semanticTokens request, choosing the latter (no notifications).");
+"no longer supported. Migrate to standard semanticTokens request");
-ClangdServerOpts.TheiaSemanticHighlighting = false;
 }
 if (Params.rootUri && *Params.rootUri)
-ClangdServerOpts.WorkspaceRoot = std::string(Params.rootUri->file());
+Opts.WorkspaceRoot = std::string(Params.rootUri->file());
 else if (Params.rootPath && !Params.rootPath->empty())
-ClangdServerOpts.WorkspaceRoot = *Params.rootPath;
+Opts.WorkspaceRoot = *Params.rootPath;
 if (Server)
 return Reply(llvm::make_error<LSPError>("server already initialized",
 ErrorCode::InvalidRequest));
-if (const auto &Dir = Params.initializationOptions.compilationDatabasePath)
+if (Opts.UseDirBasedCDB) {
-CompileCommandsDir = Dir;
+DirectoryBasedGlobalCompilationDatabase::Options CDBOpts(TFS);
-if (UseDirBasedCDB) {
+if (const auto &Dir = Params.initializationOptions.compilationDatabasePath)
-BaseCDB = std::make_unique<DirectoryBasedGlobalCompilationDatabase>(
+CDBOpts.CompileCommandsDir = Dir;
-CompileCommandsDir);
+CDBOpts.ContextProvider = Opts.ContextProvider;
-BaseCDB = getQueryDriverDatabase(
+BaseCDB =
-llvm::makeArrayRef(ClangdServerOpts.QueryDriverGlobs),
+std::make_unique<DirectoryBasedGlobalCompilationDatabase>(CDBOpts);
-std::move(BaseCDB));
+BaseCDB = getQueryDriverDatabase(llvm::makeArrayRef(Opts.QueryDriverGlobs),
+std::move(BaseCDB));
 }
 auto Mangler = CommandMangler::detect();
-if (ClangdServerOpts.ResourceDir)
+if (Opts.ResourceDir)
-Mangler.ResourceDir = *ClangdServerOpts.ResourceDir;
+Mangler.ResourceDir = *Opts.ResourceDir;
 CDB.emplace(BaseCDB.get(), Params.initializationOptions.fallbackFlags,
-tooling::ArgumentsAdjuster(Mangler));
+tooling::ArgumentsAdjuster(std::move(Mangler)));
 {
 // Switch caller's context with LSPServer's background context. Since we
 // rather want to propagate information from LSPServer's context into the
 // Server, CDB, etc.
 WithContext MainContext(BackgroundContext.clone());
 llvm::Optional<WithContextValue> WithOffsetEncoding;
-if (NegotiatedOffsetEncoding)
+if (Opts.Encoding)
-WithOffsetEncoding.emplace(kCurrentOffsetEncoding,
+WithOffsetEncoding.emplace(kCurrentOffsetEncoding, *Opts.Encoding);
-*NegotiatedOffsetEncoding);
+Server.emplace(*CDB, TFS, Opts,
-Server.emplace(*CDB, FSProvider, ClangdServerOpts,
 static_cast<ClangdServer::Callbacks *>(this));
 }
 applyConfiguration(Params.initializationOptions.ConfigSettings);
-CCOpts.EnableSnippets = Params.capabilities.CompletionSnippets;
+Opts.CodeComplete.EnableSnippets = Params.capabilities.CompletionSnippets;
-CCOpts.IncludeFixIts = Params.capabilities.CompletionFixes;
+Opts.CodeComplete.IncludeFixIts = Params.capabilities.CompletionFixes;
-if (!CCOpts.BundleOverloads.hasValue())
+if (!Opts.CodeComplete.BundleOverloads.hasValue())
-CCOpts.BundleOverloads = Params.capabilities.HasSignatureHelp;
+Opts.CodeComplete.BundleOverloads = Params.capabilities.HasSignatureHelp;
-CCOpts.DocumentationFormat =
+Opts.CodeComplete.DocumentationFormat =
 Params.capabilities.CompletionDocumentationFormat;
 DiagOpts.EmbedFixesInDiagnostics = Params.capabilities.DiagnosticFixes;
 DiagOpts.SendDiagnosticCategory = Params.capabilities.DiagnosticCategory;
 DiagOpts.EmitRelatedLocations =
 Params.capabilities.DiagnosticRelatedInformation;
 HoverContentFormat = Params.capabilities.HoverContentFormat;
 SupportsOffsetsInSignatureHelp = Params.capabilities.OffsetsInSignatureHelp;
 if (Params.capabilities.WorkDoneProgress)
 BackgroundIndexProgressState = BackgroundIndexProgress::Empty;
 BackgroundIndexSkipCreate = Params.capabilities.ImplicitProgressCreation;
+Opts.ImplicitCancellation = !Params.capabilities.CancelsStaleRequests;
+llvm::json::Object ServerCaps{
+{"textDocumentSync",
+llvm::json::Object{
+{"openClose", true},
+{"change", (int)TextDocumentSyncKind::Incremental},
+{"save", true},
+}},
+{"documentFormattingProvider", true},
+{"documentRangeFormattingProvider", true},
+{"documentOnTypeFormattingProvider",
+llvm::json::Object{
+{"firstTriggerCharacter", "\n"},
+{"moreTriggerCharacter", {}},
+}},
+{"completionProvider",
+llvm::json::Object{
+{"allCommitCharacters",
+{" ", "\t", "(", ")", "[", "]", "{",  "}", "<",
+">", ":",  ";", ",", "+", "-", "/",  "*", "%",
+"^", "&",  "#", "?", ".", "=", "\"", "'", "|"}},
+{"resolveProvider", false},
+// We do extra checks, e.g. that > is part of ->.
+{"triggerCharacters", {".", "<", ">", ":", "\"", "/"}},
+}},
+{"semanticTokensProvider",
+llvm::json::Object{
+{"full", llvm::json::Object{{"delta", true}}},
+{"range", false},
+{"legend",
+llvm::json::Object{{"tokenTypes", semanticTokenTypes()},
+{"tokenModifiers", semanticTokenModifiers()}}},
+}},
+{"signatureHelpProvider",
+llvm::json::Object{
+{"triggerCharacters", {"(", ","}},
+}},
+{"declarationProvider", true},
+{"definitionProvider", true},
+{"implementationProvider", true},
+{"documentHighlightProvider", true},
+{"documentLinkProvider",
+llvm::json::Object{
+{"resolveProvider", false},
+}},
+{"hoverProvider", true},
+{"selectionRangeProvider", true},
+{"documentSymbolProvider", true},
+{"workspaceSymbolProvider", true},
+{"referencesProvider", true},
+{"astProvider", true}, // clangd extension
+{"typeHierarchyProvider", true},
+{"memoryUsageProvider", true}, // clangd extension
+{"compilationDatabase",        // clangd extension
+llvm::json::Object{{"automaticReload", true}}},
+{"callHierarchyProvider", true},
+};
+{
+LSPBinder Binder(Handlers, *this);
+bindMethods(Binder, Params.capabilities);
+if (Opts.FeatureModules)
+for (auto &Mod : *Opts.FeatureModules)
+Mod.initializeLSP(Binder, Params.rawCapabilities, ServerCaps);
+}
 // Per LSP, renameProvider can be either boolean or RenameOptions.
 // RenameOptions will be specified if the client states it supports prepare.
-llvm::json::Value RenameProvider =
+ServerCaps["renameProvider"] =
-llvm::json::Object{{"prepareProvider", true}};
+Params.capabilities.RenamePrepareSupport
-if (!Params.capabilities.RenamePrepareSupport) // Only boolean allowed per LSP
+? llvm::json::Object{{"prepareProvider", true}}
-RenameProvider = true;
+: llvm::json::Value(true);
-// Per LSP, codeActionProvide can be either boolean or CodeActionOptions.
+// Per LSP, codeActionProvider can be either boolean or CodeActionOptions.
 // CodeActionOptions is only valid if the client supports action literal
 // via textDocument.codeAction.codeActionLiteralSupport.
 llvm::json::Value CodeActionProvider = true;
-if (Params.capabilities.CodeActionStructure)
+ServerCaps["codeActionProvider"] =
-CodeActionProvider = llvm::json::Object{
+Params.capabilities.CodeActionStructure
-{"codeActionKinds",
+? llvm::json::Object{{"codeActionKinds",
-{CodeAction::QUICKFIX_KIND, CodeAction::REFACTOR_KIND,
+{CodeAction::QUICKFIX_KIND,
-CodeAction::INFO_KIND}}};
+CodeAction::REFACTOR_KIND,
+CodeAction::INFO_KIND}}}
+: llvm::json::Value(true);
+if (Opts.FoldingRanges)
+ServerCaps["foldingRangeProvider"] = true;
+if (Opts.InlayHints)
+ServerCaps["clangdInlayHintsProvider"] = true;
+std::vector<llvm::StringRef> Commands;
+for (llvm::StringRef Command : Handlers.CommandHandlers.keys())
+Commands.push_back(Command);
+llvm::sort(Commands);
+ServerCaps["executeCommandProvider"] =
+llvm::json::Object{{"commands", Commands}};
 llvm::json::Object Result{
 {{"serverInfo",
 llvm::json::Object{{"name", "clangd"},
 {"version", getClangToolFullVersion("clangd")}}},
-{"capabilities",
+{"capabilities", std::move(ServerCaps)}}};
-llvm::json::Object{
+if (Opts.Encoding)
-{"textDocumentSync",
+Result["offsetEncoding"] = *Opts.Encoding;
-llvm::json::Object{
-{"openClose", true},
-{"change", (int)TextDocumentSyncKind::Incremental},
-{"save", true},
-}},
-{"documentFormattingProvider", true},
-{"documentRangeFormattingProvider", true},
-{"documentOnTypeFormattingProvider",
-llvm::json::Object{
-{"firstTriggerCharacter", "\n"},
-{"moreTriggerCharacter", {}},
-}},
-{"codeActionProvider", std::move(CodeActionProvider)},
-{"completionProvider",
-llvm::json::Object{
-{"allCommitCharacters", " \t()[]{}<>:;,+-/*%^&#?.=\"'|"},
-{"resolveProvider", false},
-// We do extra checks, e.g. that > is part of ->.
-{"triggerCharacters", {".", "<", ">", ":", "\"", "/"}},
-}},
-{"semanticTokensProvider",
-llvm::json::Object{
-{"documentProvider", llvm::json::Object{{"edits", true}}},
-{"rangeProvider", false},
-{"legend",
-llvm::json::Object{{"tokenTypes", semanticTokenTypes()},
-{"tokenModifiers", llvm::json::Array()}}},
-}},
-{"signatureHelpProvider",
-llvm::json::Object{
-{"triggerCharacters", {"(", ","}},
-}},
-{"declarationProvider", true},
-{"definitionProvider", true},
-{"documentHighlightProvider", true},
-{"documentLinkProvider",
-llvm::json::Object{
-{"resolveProvider", false},
-}},
-{"hoverProvider", true},
-{"renameProvider", std::move(RenameProvider)},
-{"selectionRangeProvider", true},
-{"documentSymbolProvider", true},
-{"workspaceSymbolProvider", true},
-{"referencesProvider", true},
-{"executeCommandProvider",
-llvm::json::Object{
-{"commands",
-{ExecuteCommandParams::CLANGD_APPLY_FIX_COMMAND,
-ExecuteCommandParams::CLANGD_APPLY_TWEAK}},
-}},
-{"typeHierarchyProvider", true},
-}}}};
-if (NegotiatedOffsetEncoding)
-Result["offsetEncoding"] = *NegotiatedOffsetEncoding;
-if (ClangdServerOpts.TheiaSemanticHighlighting)
-Result.getObject("capabilities")
-->insert(
-{"semanticHighlighting",
-llvm::json::Object{{"scopes", buildHighlightScopeLookupTable()}}});
 Reply(std::move(Result));
 }
 void ClangdLSPServer::onInitialized(const InitializedParams &Params) {}
-void ClangdLSPServer::onShutdown(const ShutdownParams &Params,
+void ClangdLSPServer::onShutdown(const NoParams &,
 Callback<std::nullptr_t> Reply) {
 // Do essentially nothing, just say we're ready to exit.
 ShutdownRequestReceived = true;
 Reply(nullptr);
 }
 // sync is a clangd extension: it blocks until all background work completes.
 // It blocks the calling thread, so no messages are processed until it returns!
-void ClangdLSPServer::onSync(const NoParams &Params,
+void ClangdLSPServer::onSync(const NoParams &, Callback<std::nullptr_t> Reply) {
-Callback<std::nullptr_t> Reply) {
 if (Server->blockUntilIdleForTest(/*TimeoutSeconds=*/60))
 Reply(nullptr);
 else
-Reply(llvm::createStringError(llvm::inconvertibleErrorCode(),
+Reply(error("Not idle after a minute"));
-"Not idle after a minute"));
 }
 void ClangdLSPServer::onDocumentDidOpen(
 const DidOpenTextDocumentParams &Params) {
 PathRef File = Params.textDocument.uri.file();
 const std::string &Contents = Params.textDocument.text;
-auto Version = DraftMgr.addDraft(File, Params.textDocument.version, Contents);
+Server->addDocument(File, Contents,
-Server->addDocument(File, Contents, encodeVersion(Version),
+encodeVersion(Params.textDocument.version),
 WantDiagnostics::Yes);
 }
 void ClangdLSPServer::onDocumentDidChange(
 const DidChangeTextDocumentParams &Params) {
 if (Params.wantDiagnostics.hasValue())
 WantDiags = Params.wantDiagnostics.getValue() ? WantDiagnostics::Yes
 : WantDiagnostics::No;
 PathRef File = Params.textDocument.uri.file();
-llvm::Expected<DraftStore::Draft> Draft = DraftMgr.updateDraft(
+auto Code = Server->getDraft(File);
-File, Params.textDocument.version, Params.contentChanges);
+if (!Code) {
-if (!Draft) {
+log("Trying to incrementally change non-added document: {0}", File);
-// If this fails, we are most likely going to be not in sync anymore with
-// the client.  It is better to remove the draft and let further operations
-// fail rather than giving wrong results.
-DraftMgr.removeDraft(File);
-Server->removeDocument(File);
-elog("Failed to update {0}: {1}", File, Draft.takeError());
 return;
 }
+std::string NewCode(*Code);
-Server->addDocument(File, Draft->Contents, encodeVersion(Draft->Version),
+for (const auto &Change : Params.contentChanges) {
+if (auto Err = applyChange(NewCode, Change)) {
+// If this fails, we are most likely going to be not in sync anymore with
+// the client.  It is better to remove the draft and let further
+// operations fail rather than giving wrong results.
+Server->removeDocument(File);
+elog("Failed to update {0}: {1}", File, std::move(Err));
+return;
+}
+}
+Server->addDocument(File, NewCode, encodeVersion(Params.textDocument.version),
 WantDiags, Params.forceRebuild);
 }
 void ClangdLSPServer::onDocumentDidSave(
 const DidSaveTextDocumentParams &Params) {
-reparseOpenFilesIfNeeded([](llvm::StringRef) { return true; });
+Server->reparseOpenFilesIfNeeded([](llvm::StringRef) { return true; });
 }
 void ClangdLSPServer::onFileEvent(const DidChangeWatchedFilesParams &Params) {
 // We could also reparse all open files here. However:
 //  - this could be frequent, and revalidating all the preambles isn't free
 //  - this is useful e.g. when switching git branches, but we're likely to see
 //    fresh headers but still have the old-branch main-file content
 Server->onFileEvent(Params);
+// FIXME: observe config files, immediately expire time-based caches, reparse:
+//  - compile_commands.json and compile_flags.txt
+//  - .clang_format and .clang-tidy
+//  - .clangd and clangd/config.yaml
 }
 void ClangdLSPServer::onCommand(const ExecuteCommandParams &Params,
 Callback<llvm::json::Value> Reply) {
-auto ApplyEdit = [this](WorkspaceEdit WE, std::string SuccessMessage,
+auto It = Handlers.CommandHandlers.find(Params.command);
-decltype(Reply) Reply) {
+if (It == Handlers.CommandHandlers.end()) {
-ApplyWorkspaceEditParams Edit;
+return Reply(llvm::make_error<LSPError>(
-Edit.edit = std::move(WE);
-call<ApplyWorkspaceEditResponse>(
-"workspace/applyEdit", std::move(Edit),
-[Reply = std::move(Reply), SuccessMessage = std::move(SuccessMessage)](
-llvm::Expected<ApplyWorkspaceEditResponse> Response) mutable {
-if (!Response)
-return Reply(Response.takeError());
-if (!Response->applied) {
-std::string Reason = Response->failureReason
-? *Response->failureReason
-: "unknown reason";
-return Reply(llvm::createStringError(
-llvm::inconvertibleErrorCode(),
-("edits were not applied: " + Reason).c_str()));
-}
-return Reply(SuccessMessage);
-});
-};
-if (Params.command == ExecuteCommandParams::CLANGD_APPLY_FIX_COMMAND &&
-Params.workspaceEdit) {
-// The flow for "apply-fix" :
-// 1. We publish a diagnostic, including fixits
-// 2. The user clicks on the diagnostic, the editor asks us for code actions
-// 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
-// 7. We unwrap the reply and send a reply to the editor.
-ApplyEdit(*Params.workspaceEdit, "Fix applied.", std::move(Reply));
-} else if (Params.command == ExecuteCommandParams::CLANGD_APPLY_TWEAK &&
-Params.tweakArgs) {
-auto Code = DraftMgr.getDraft(Params.tweakArgs->file.file());
-if (!Code)
-return Reply(llvm::createStringError(
-llvm::inconvertibleErrorCode(),
-"trying to apply a code action for a non-added file"));
-auto Action = [this, ApplyEdit, Reply = std::move(Reply),
-File = Params.tweakArgs->file, Code = std::move(*Code)](
-llvm::Expected<Tweak::Effect> R) mutable {
-if (!R)
-return Reply(R.takeError());
-assert(R->ShowMessage ||
-(!R->ApplyEdits.empty() && "tweak has no effect"));
-if (R->ShowMessage) {
-ShowMessageParams Msg;
-Msg.message = *R->ShowMessage;
-Msg.type = MessageType::Info;
-notify("window/showMessage", Msg);
-}
-// When no edit is specified, make sure we Reply().
-if (R->ApplyEdits.empty())
-return Reply("Tweak applied.");
-if (auto Err = validateEdits(DraftMgr, R->ApplyEdits))
-return Reply(std::move(Err));
-WorkspaceEdit WE;
-WE.changes.emplace();
-for (const auto &It : R->ApplyEdits) {
-(*WE.changes)[URI::createFile(It.first()).toString()] =
-It.second.asTextEdits();
-}
-// ApplyEdit will take care of calling Reply().
-return ApplyEdit(std::move(WE), "Tweak applied.", std::move(Reply));
-};
-Server->applyTweak(Params.tweakArgs->file.file(),
-Params.tweakArgs->selection, Params.tweakArgs->tweakID,
-std::move(Action));
-} 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.
-Reply(llvm::make_error<LSPError>(
 llvm::formatv("Unsupported command \"{0}\".", Params.command).str(),
 ErrorCode::InvalidParams));
 }
+It->second(Params.argument, std::move(Reply));
+}
+void ClangdLSPServer::onCommandApplyEdit(const WorkspaceEdit &WE,
+Callback<llvm::json::Value> Reply) {
+// The flow for "apply-fix" :
+// 1. We publish a diagnostic, including fixits
+// 2. The user clicks on the diagnostic, the editor asks us for code actions
+// 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
+// 7. We unwrap the reply and send a reply to the editor.
+applyEdit(WE, "Fix applied.", std::move(Reply));
+}
+void ClangdLSPServer::onCommandApplyTweak(const TweakArgs &Args,
+Callback<llvm::json::Value> Reply) {
+auto Action = [this, Reply = std::move(Reply)](
+llvm::Expected<Tweak::Effect> R) mutable {
+if (!R)
+return Reply(R.takeError());
+assert(R->ShowMessage || (!R->ApplyEdits.empty() && "tweak has no effect"));
+if (R->ShowMessage) {
+ShowMessageParams Msg;
+Msg.message = *R->ShowMessage;
+Msg.type = MessageType::Info;
+ShowMessage(Msg);
+}
+// When no edit is specified, make sure we Reply().
+if (R->ApplyEdits.empty())
+return Reply("Tweak applied.");
+if (auto Err = validateEdits(*Server, R->ApplyEdits))
+return Reply(std::move(Err));
+WorkspaceEdit WE;
+for (const auto &It : R->ApplyEdits) {
+WE.changes[URI::createFile(It.first()).toString()] =
+It.second.asTextEdits();
+}
+// ApplyEdit will take care of calling Reply().
+return applyEdit(std::move(WE), "Tweak applied.", std::move(Reply));
+};
+Server->applyTweak(Args.file.file(), Args.selection, Args.tweakID,
+std::move(Action));
+}
+void ClangdLSPServer::applyEdit(WorkspaceEdit WE, llvm::json::Value Success,
+Callback<llvm::json::Value> Reply) {
+ApplyWorkspaceEditParams Edit;
+Edit.edit = std::move(WE);
+ApplyWorkspaceEdit(
+Edit, [Reply = std::move(Reply), SuccessMessage = std::move(Success)](
+llvm::Expected<ApplyWorkspaceEditResponse> Response) mutable {
+if (!Response)
+return Reply(Response.takeError());
+if (!Response->applied) {
+std::string Reason = Response->failureReason
+? *Response->failureReason
+: "unknown reason";
+return Reply(error("edits were not applied: {0}", Reason));
+}
+return Reply(SuccessMessage);
+});
 }
 void ClangdLSPServer::onWorkspaceSymbol(
 const WorkspaceSymbolParams &Params,
 Callback<std::vector<SymbolInformation>> Reply) {
 Server->workspaceSymbols(
-Params.query, CCOpts.Limit,
+Params.query, Params.limit.getValueOr(Opts.CodeComplete.Limit),
 [Reply = std::move(Reply),
 this](llvm::Expected<std::vector<SymbolInformation>> Items) mutable {
 if (!Items)
 return Reply(Items.takeError());
 for (auto &Sym : *Items)
 });
 }
 void ClangdLSPServer::onPrepareRename(const TextDocumentPositionParams &Params,
 Callback<llvm::Optional<Range>> Reply) {
-Server->prepareRename(Params.textDocument.uri.file(), Params.position,
+Server->prepareRename(
-RenameOpts, std::move(Reply));
+Params.textDocument.uri.file(), Params.position, /*NewName*/ llvm::None,
+Opts.Rename,
+[Reply = std::move(Reply)](llvm::Expected<RenameResult> Result) mutable {
+if (!Result)
+return Reply(Result.takeError());
+return Reply(std::move(Result->Target));
+});
 }
 void ClangdLSPServer::onRename(const RenameParams &Params,
 Callback<WorkspaceEdit> Reply) {
 Path File = std::string(Params.textDocument.uri.file());
-if (!DraftMgr.getDraft(File))
+if (!Server->getDraft(File))
 return Reply(llvm::make_error<LSPError>(
 "onRename called for non-added file", ErrorCode::InvalidParams));
-Server->rename(
+Server->rename(File, Params.position, Params.newName, Opts.Rename,
-File, Params.position, Params.newName, RenameOpts,
+[File, Params, Reply = std::move(Reply),
-[File, Params, Reply = std::move(Reply),
+this](llvm::Expected<RenameResult> R) mutable {
-this](llvm::Expected<FileEdits> Edits) mutable {
+if (!R)
-if (!Edits)
+return Reply(R.takeError());
-return Reply(Edits.takeError());
+if (auto Err = validateEdits(*Server, R->GlobalChanges))
-if (auto Err = validateEdits(DraftMgr, *Edits))
+return Reply(std::move(Err));
-return Reply(std::move(Err));
+WorkspaceEdit Result;
-WorkspaceEdit Result;
+for (const auto &Rep : R->GlobalChanges) {
-Result.changes.emplace();
+Result.changes[URI::createFile(Rep.first()).toString()] =
-for (const auto &Rep : *Edits) {
+Rep.second.asTextEdits();
-(*Result.changes)[URI::createFile(Rep.first()).toString()] =
+}
-Rep.second.asTextEdits();
+Reply(Result);
-}
+});
-Reply(Result);
-});
 }
 void ClangdLSPServer::onDocumentDidClose(
 const DidCloseTextDocumentParams &Params) {
 PathRef File = Params.textDocument.uri.file();
-DraftMgr.removeDraft(File);
 Server->removeDocument(File);
 {
 std::lock_guard<std::mutex> Lock(FixItsMutex);
 FixItsMap.erase(File);
-}
-{
-std::lock_guard<std::mutex> HLock(HighlightingsMutex);
-FileToHighlightings.erase(File);
 }
 {
 std::lock_guard<std::mutex> HLock(SemanticTokensMutex);
 LastSemanticTokens.erase(File);
 }
 // VSCode). Note that this cannot race with actual diagnostics responses
 // because removeDocument() guarantees no diagnostic callbacks will be
 // executed after it returns.
 PublishDiagnosticsParams Notification;
 Notification.uri = URIForFile::canonicalize(File, /*TUPath=*/File);
-publishDiagnostics(Notification);
+PublishDiagnostics(Notification);
 }
 void ClangdLSPServer::onDocumentOnTypeFormatting(
 const DocumentOnTypeFormattingParams &Params,
 Callback<std::vector<TextEdit>> Reply) {
 auto File = Params.textDocument.uri.file();
-auto Code = DraftMgr.getDraft(File);
+Server->formatOnType(File, Params.position, Params.ch, std::move(Reply));
-if (!Code)
-return Reply(llvm::make_error<LSPError>(
-"onDocumentOnTypeFormatting called for non-added file",
-ErrorCode::InvalidParams));
-Reply(Server->formatOnType(Code->Contents, File, Params.position, Params.ch));
 }
 void ClangdLSPServer::onDocumentRangeFormatting(
 const DocumentRangeFormattingParams &Params,
 Callback<std::vector<TextEdit>> Reply) {
 auto File = Params.textDocument.uri.file();
-auto Code = DraftMgr.getDraft(File);
+auto Code = Server->getDraft(File);
-if (!Code)
+Server->formatFile(File, Params.range,
-return Reply(llvm::make_error<LSPError>(
+[Code = std::move(Code), Reply = std::move(Reply)](
-"onDocumentRangeFormatting called for non-added file",
+llvm::Expected<tooling::Replacements> Result) mutable {
-ErrorCode::InvalidParams));
+if (Result)
+Reply(replacementsToEdits(*Code, Result.get()));
-auto ReplacementsOrError =
+else
-Server->formatRange(Code->Contents, File, Params.range);
+Reply(Result.takeError());
-if (ReplacementsOrError)
+});
-Reply(replacementsToEdits(Code->Contents, ReplacementsOrError.get()));
-else
-Reply(ReplacementsOrError.takeError());
 }
 void ClangdLSPServer::onDocumentFormatting(
 const DocumentFormattingParams &Params,
 Callback<std::vector<TextEdit>> Reply) {
 auto File = Params.textDocument.uri.file();
-auto Code = DraftMgr.getDraft(File);
+auto Code = Server->getDraft(File);
-if (!Code)
+Server->formatFile(File,
-return Reply(llvm::make_error<LSPError>(
+/*Rng=*/llvm::None,
-"onDocumentFormatting called for non-added file",
+[Code = std::move(Code), Reply = std::move(Reply)](
-ErrorCode::InvalidParams));
+llvm::Expected<tooling::Replacements> Result) mutable {
+if (Result)
-auto ReplacementsOrError = Server->formatFile(Code->Contents, File);
+Reply(replacementsToEdits(*Code, Result.get()));
-if (ReplacementsOrError)
+else
-Reply(replacementsToEdits(Code->Contents, ReplacementsOrError.get()));
+Reply(Result.takeError());
-else
+});
-Reply(ReplacementsOrError.takeError());
 }
 /// The functions constructs a flattened view of the DocumentSymbol hierarchy.
 /// Used by the clients that do not support the hierarchical view.
 static std::vector<SymbolInformation>
 flattenSymbolHierarchy(llvm::ArrayRef<DocumentSymbol> Symbols,
 const URIForFile &FileURI) {
 std::vector<SymbolInformation> Results;
 std::function<void(const DocumentSymbol &, llvm::StringRef)> Process =
 [&](const DocumentSymbol &S, llvm::Optional<llvm::StringRef> ParentName) {
 SymbolInformation SI;
 SI.containerName = std::string(ParentName ? "" : *ParentName);
 else
 return Reply(flattenSymbolHierarchy(*Items, FileURI));
 });
 }
+void ClangdLSPServer::onFoldingRange(
+const FoldingRangeParams &Params,
+Callback<std::vector<FoldingRange>> Reply) {
+Server->foldingRanges(Params.textDocument.uri.file(), std::move(Reply));
+}
 static llvm::Optional<Command> asCommand(const CodeAction &Action) {
 Command Cmd;
 if (Action.command && Action.edit)
 return None; // Not representable. (We never emit these anyway).
 if (Action.command) {
 Cmd = *Action.command;
 } else if (Action.edit) {
-Cmd.command = std::string(Command::CLANGD_APPLY_FIX_COMMAND);
+Cmd.command = std::string(APPLY_FIX_COMMAND);
-Cmd.workspaceEdit = *Action.edit;
+Cmd.argument = *Action.edit;
 } else {
 return None;
 }
 Cmd.title = Action.title;
 if (Action.kind && *Action.kind == CodeAction::QUICKFIX_KIND)
 }
 void ClangdLSPServer::onCodeAction(const CodeActionParams &Params,
 Callback<llvm::json::Value> Reply) {
 URIForFile File = Params.textDocument.uri;
-auto Code = DraftMgr.getDraft(File.file());
+// Checks whether a particular CodeActionKind is included in the response.
-if (!Code)
+auto KindAllowed = [Only(Params.context.only)](llvm::StringRef Kind) {
-return Reply(llvm::make_error<LSPError>(
+if (Only.empty())
-"onCodeAction called for non-added file", ErrorCode::InvalidParams));
+return true;
+return llvm::any_of(Only, [&](llvm::StringRef Base) {
+return Kind.consume_front(Base) && (Kind.empty() || Kind.startswith("."));
+});
+};
 // We provide a code action for Fixes on the specified diagnostics.
 std::vector<CodeAction> FixIts;
-for (const Diagnostic &D : Params.context.diagnostics) {
+if (KindAllowed(CodeAction::QUICKFIX_KIND)) {
-for (auto &F : getFixes(File.file(), D)) {
+for (const Diagnostic &D : Params.context.diagnostics) {
-FixIts.push_back(toCodeAction(F, Params.textDocument.uri));
+for (auto &F : getFixes(File.file(), D)) {
-FixIts.back().diagnostics = {D};
+FixIts.push_back(toCodeAction(F, Params.textDocument.uri));
+FixIts.back().diagnostics = {D};
+}
 }
 }
 // Now enumerate the semantic code actions.
 auto ConsumeActions =
-[Reply = std::move(Reply), File, Code = std::move(*Code),
+[Reply = std::move(Reply), File, Selection = Params.range,
-Selection = Params.range, FixIts = std::move(FixIts), this](
+FixIts = std::move(FixIts), this](
 llvm::Expected<std::vector<ClangdServer::TweakRef>> Tweaks) mutable {
 if (!Tweaks)
 return Reply(Tweaks.takeError());
 std::vector<CodeAction> Actions = std::move(FixIts);
 Actions.reserve(Actions.size() + Tweaks->size());
 for (const auto &T : *Tweaks)
 Actions.push_back(toCodeAction(T, File, Selection));
+// If there's exactly one quick-fix, call it "preferred".
+// We never consider refactorings etc as preferred.
+CodeAction *OnlyFix = nullptr;
+for (auto &Action : Actions) {
+if (Action.kind && *Action.kind == CodeAction::QUICKFIX_KIND) {
+if (OnlyFix) {
+OnlyFix->isPreferred = false;
+break;
+}
+Action.isPreferred = true;
+OnlyFix = &Action;
+}
+}
 if (SupportsCodeAction)
 return Reply(llvm::json::Array(Actions));
 std::vector<Command> Commands;
 for (const auto &Action : Actions) {
 if (auto Command = asCommand(Action))
 Commands.push_back(std::move(*Command));
 }
 return Reply(llvm::json::Array(Commands));
 };
+Server->enumerateTweaks(
-Server->enumerateTweaks(File.file(), Params.range, std::move(ConsumeActions));
+File.file(), Params.range,
+[this, KindAllowed(std::move(KindAllowed))](const Tweak &T) {
+return Opts.TweakFilter(T) && KindAllowed(T.kind());
+},
+std::move(ConsumeActions));
 }
 void ClangdLSPServer::onCompletion(const CompletionParams &Params,
 Callback<CompletionList> Reply) {
 if (!shouldRunCompletion(Params)) {
 // Clients sometimes auto-trigger completions in undesired places (e.g.
 // 'a >^ '), we return empty results in those cases.
 vlog("ignored auto-triggered completion, preceding char did not match");
 return Reply(CompletionList());
 }
-Server->codeComplete(Params.textDocument.uri.file(), Params.position, CCOpts,
+auto Opts = this->Opts.CodeComplete;
-[Reply = std::move(Reply),
+if (Params.limit && *Params.limit >= 0)
+Opts.Limit = *Params.limit;
+Server->codeComplete(Params.textDocument.uri.file(), Params.position, Opts,
+[Reply = std::move(Reply), Opts,
 this](llvm::Expected<CodeCompleteResult> List) mutable {
 if (!List)
 return Reply(List.takeError());
 CompletionList LSPList;
 LSPList.isIncomplete = List->HasMore;
 for (const auto &R : List->Completions) {
-CompletionItem C = R.render(CCOpts);
+CompletionItem C = R.render(Opts);
 C.kind = adjustKindToCapability(
 C.kind, SupportedCompletionItemKinds);
 LSPList.items.push_back(std::move(C));
 }
 return Reply(std::move(LSPList));
 Callback<Optional<TypeHierarchyItem>> Reply) {
 Server->resolveTypeHierarchy(Params.item, Params.resolve, Params.direction,
 std::move(Reply));
 }
+void ClangdLSPServer::onPrepareCallHierarchy(
+const CallHierarchyPrepareParams &Params,
+Callback<std::vector<CallHierarchyItem>> Reply) {
+Server->prepareCallHierarchy(Params.textDocument.uri.file(), Params.position,
+std::move(Reply));
+}
+void ClangdLSPServer::onCallHierarchyIncomingCalls(
+const CallHierarchyIncomingCallsParams &Params,
+Callback<std::vector<CallHierarchyIncomingCall>> Reply) {
+Server->incomingCalls(Params.item, std::move(Reply));
+}
+void ClangdLSPServer::onCallHierarchyOutgoingCalls(
+const CallHierarchyOutgoingCallsParams &Params,
+Callback<std::vector<CallHierarchyOutgoingCall>> Reply) {
+// FIXME: To be implemented.
+Reply(std::vector<CallHierarchyOutgoingCall>{});
+}
+void ClangdLSPServer::onInlayHints(const InlayHintsParams &Params,
+Callback<std::vector<InlayHint>> Reply) {
+Server->inlayHints(Params.textDocument.uri.file(), std::move(Reply));
+}
 void ClangdLSPServer::applyConfiguration(
 const ConfigurationSettings &Settings) {
 // Per-file update to the compilation database.
 llvm::StringSet<> ModifiedFiles;
 for (auto &Entry : Settings.compilationDatabaseChanges) {
 CDB->setCompileCommand(File, std::move(New));
 ModifiedFiles.insert(File);
 }
 }
-reparseOpenFilesIfNeeded(
+Server->reparseOpenFilesIfNeeded(
 [&](llvm::StringRef File) { return ModifiedFiles.count(File) != 0; });
 }
-void ClangdLSPServer::publishTheiaSemanticHighlighting(
+void ClangdLSPServer::maybeExportMemoryProfile() {
-const TheiaSemanticHighlightingParams &Params) {
+if (!trace::enabled() || !ShouldProfile())
-notify("textDocument/semanticHighlighting", Params);
+return;
-}
+static constexpr trace::Metric MemoryUsage(
-void ClangdLSPServer::publishDiagnostics(
+"memory_usage", trace::Metric::Value, "component_name");
-const PublishDiagnosticsParams &Params) {
+trace::Span Tracer("ProfileBrief");
-notify("textDocument/publishDiagnostics", Params);
+MemoryTree MT;
+profile(MT);
+record(MT, "clangd_lsp_server", MemoryUsage);
+}
+void ClangdLSPServer::maybeCleanupMemory() {
+if (!Opts.MemoryCleanup || !ShouldCleanupMemory())
+return;
+Opts.MemoryCleanup();
 }
 // FIXME: This function needs to be properly tested.
 void ClangdLSPServer::onChangeConfiguration(
 const DidChangeConfigurationParams &Params) {
 applyConfiguration(Params.settings);
 }
 void ClangdLSPServer::onReference(const ReferenceParams &Params,
 Callback<std::vector<Location>> Reply) {
-Server->findReferences(Params.textDocument.uri.file(), Params.position,
+Server->findReferences(
-CCOpts.Limit,
+Params.textDocument.uri.file(), Params.position, Opts.ReferencesLimit,
-[Reply = std::move(Reply)](
+[Reply = std::move(Reply),
-llvm::Expected<ReferencesResult> Refs) mutable {
+IncludeDecl(Params.context.includeDeclaration)](
-if (!Refs)
+llvm::Expected<ReferencesResult> Refs) mutable {
-return Reply(Refs.takeError());
+if (!Refs)
-return Reply(std::move(Refs->References));
+return Reply(Refs.takeError());
-});
+// Filter out declarations if the client asked.
+std::vector<Location> Result;
+Result.reserve(Refs->References.size());
+for (auto &Ref : Refs->References) {
+bool IsDecl = Ref.Attributes & ReferencesResult::Declaration;
+if (IncludeDecl || !IsDecl)
+Result.push_back(std::move(Ref.Loc));
+}
+return Reply(std::move(Result));
+});
+}
+void ClangdLSPServer::onGoToImplementation(
+const TextDocumentPositionParams &Params,
+Callback<std::vector<Location>> Reply) {
+Server->findImplementations(
+Params.textDocument.uri.file(), Params.position,
+[Reply = std::move(Reply)](
+llvm::Expected<std::vector<LocatedSymbol>> Overrides) mutable {
+if (!Overrides)
+return Reply(Overrides.takeError());
+std::vector<Location> Impls;
+for (const LocatedSymbol &Sym : *Overrides)
+Impls.push_back(Sym.PreferredDeclaration);
+return Reply(std::move(Impls));
+});
 }
 void ClangdLSPServer::onSymbolInfo(const TextDocumentPositionParams &Params,
 Callback<std::vector<SymbolDetails>> Reply) {
 Server->symbolInfo(Params.textDocument.uri.file(), Params.position,
 }
 CB(std::move(Result));
 });
 }
-void ClangdLSPServer::onSemanticTokensEdits(
+void ClangdLSPServer::onSemanticTokensDelta(
-const SemanticTokensEditsParams &Params,
+const SemanticTokensDeltaParams &Params,
-Callback<SemanticTokensOrEdits> CB) {
+Callback<SemanticTokensOrDelta> CB) {
 Server->semanticHighlights(
 Params.textDocument.uri.file(),
 [this, PrevResultID(Params.previousResultId),
 File(Params.textDocument.uri.file().str()), CB(std::move(CB))](
 llvm::Expected<std::vector<HighlightingToken>> HT) mutable {
 if (!HT)
 return CB(HT.takeError());
 std::vector<SemanticToken> Toks = toSemanticTokens(*HT);
-SemanticTokensOrEdits Result;
+SemanticTokensOrDelta Result;
 {
 std::lock_guard<std::mutex> Lock(SemanticTokensMutex);
 auto &Last = LastSemanticTokens[File];
 if (PrevResultID == Last.resultId) {
 Result.edits = diffTokens(Last.tokens, Toks);
 } else {
-vlog("semanticTokens/edits: wanted edits vs {0} but last result "
+vlog("semanticTokens/full/delta: wanted edits vs {0} but last "
-"had ID {1}. Returning full token list.",
+"result had ID {1}. Returning full token list.",
 PrevResultID, Last.resultId);
 Result.tokens = Toks;
 }
 Last.tokens = std::move(Toks);
 CB(std::move(Result));
 });
 }
-ClangdLSPServer::ClangdLSPServer(
+void ClangdLSPServer::onMemoryUsage(const NoParams &,
-class Transport &Transp, const FileSystemProvider &FSProvider,
+Callback<MemoryTree> Reply) {
-const clangd::CodeCompleteOptions &CCOpts,
+llvm::BumpPtrAllocator DetailAlloc;
-const clangd::RenameOptions &RenameOpts,
+MemoryTree MT(&DetailAlloc);
-llvm::Optional<Path> CompileCommandsDir, bool UseDirBasedCDB,
+profile(MT);
-llvm::Optional<OffsetEncoding> ForcedOffsetEncoding,
+Reply(std::move(MT));
-const ClangdServer::Options &Opts)
+}
-: BackgroundContext(Context::current().clone()), Transp(Transp),
-MsgHandler(new MessageHandler(*this)), FSProvider(FSProvider),
+void ClangdLSPServer::onAST(const ASTParams &Params,
-CCOpts(CCOpts), RenameOpts(RenameOpts),
+Callback<llvm::Optional<ASTNode>> CB) {
+Server->getAST(Params.textDocument.uri.file(), Params.range, std::move(CB));
+}
+ClangdLSPServer::ClangdLSPServer(Transport &Transp, const ThreadsafeFS &TFS,
+const ClangdLSPServer::Options &Opts)
+: ShouldProfile(/*Period=*/std::chrono::minutes(5),
+/*Delay=*/std::chrono::minutes(1)),
+ShouldCleanupMemory(/*Period=*/std::chrono::minutes(1),
+/*Delay=*/std::chrono::minutes(1)),
+BackgroundContext(Context::current().clone()), Transp(Transp),
+MsgHandler(new MessageHandler(*this)), TFS(TFS),
 SupportedSymbolKinds(defaultSymbolKinds()),
-SupportedCompletionItemKinds(defaultCompletionItemKinds()),
+SupportedCompletionItemKinds(defaultCompletionItemKinds()), Opts(Opts) {
-UseDirBasedCDB(UseDirBasedCDB),
+if (Opts.ConfigProvider) {
-CompileCommandsDir(std::move(CompileCommandsDir)), ClangdServerOpts(Opts),
+assert(!Opts.ContextProvider &&
-NegotiatedOffsetEncoding(ForcedOffsetEncoding) {
+"Only one of ConfigProvider and ContextProvider allowed!");
+this->Opts.ContextProvider = ClangdServer::createConfiguredContextProvider(
+Opts.ConfigProvider, this);
+}
+LSPBinder Bind(this->Handlers, *this);
+Bind.method("initialize", this, &ClangdLSPServer::onInitialize);
+}
+void ClangdLSPServer::bindMethods(LSPBinder &Bind,
+const ClientCapabilities &Caps) {
 // clang-format off
-MsgHandler->bind("initialize", &ClangdLSPServer::onInitialize);
+Bind.notification("initialized", this, &ClangdLSPServer::onInitialized);
-MsgHandler->bind("initialized", &ClangdLSPServer::onInitialized);
+Bind.method("shutdown", this, &ClangdLSPServer::onShutdown);
-MsgHandler->bind("shutdown", &ClangdLSPServer::onShutdown);
+Bind.method("sync", this, &ClangdLSPServer::onSync);
-MsgHandler->bind("sync", &ClangdLSPServer::onSync);
+Bind.method("textDocument/rangeFormatting", this, &ClangdLSPServer::onDocumentRangeFormatting);
-MsgHandler->bind("textDocument/rangeFormatting", &ClangdLSPServer::onDocumentRangeFormatting);
+Bind.method("textDocument/onTypeFormatting", this, &ClangdLSPServer::onDocumentOnTypeFormatting);
-MsgHandler->bind("textDocument/onTypeFormatting", &ClangdLSPServer::onDocumentOnTypeFormatting);
+Bind.method("textDocument/formatting", this, &ClangdLSPServer::onDocumentFormatting);
-MsgHandler->bind("textDocument/formatting", &ClangdLSPServer::onDocumentFormatting);
+Bind.method("textDocument/codeAction", this, &ClangdLSPServer::onCodeAction);
-MsgHandler->bind("textDocument/codeAction", &ClangdLSPServer::onCodeAction);
+Bind.method("textDocument/completion", this, &ClangdLSPServer::onCompletion);
-MsgHandler->bind("textDocument/completion", &ClangdLSPServer::onCompletion);
+Bind.method("textDocument/signatureHelp", this, &ClangdLSPServer::onSignatureHelp);
-MsgHandler->bind("textDocument/signatureHelp", &ClangdLSPServer::onSignatureHelp);
+Bind.method("textDocument/definition", this, &ClangdLSPServer::onGoToDefinition);
-MsgHandler->bind("textDocument/definition", &ClangdLSPServer::onGoToDefinition);
+Bind.method("textDocument/declaration", this, &ClangdLSPServer::onGoToDeclaration);
-MsgHandler->bind("textDocument/declaration", &ClangdLSPServer::onGoToDeclaration);
+Bind.method("textDocument/implementation", this, &ClangdLSPServer::onGoToImplementation);
-MsgHandler->bind("textDocument/references", &ClangdLSPServer::onReference);
+Bind.method("textDocument/references", this, &ClangdLSPServer::onReference);
-MsgHandler->bind("textDocument/switchSourceHeader", &ClangdLSPServer::onSwitchSourceHeader);
+Bind.method("textDocument/switchSourceHeader", this, &ClangdLSPServer::onSwitchSourceHeader);
-MsgHandler->bind("textDocument/prepareRename", &ClangdLSPServer::onPrepareRename);
+Bind.method("textDocument/prepareRename", this, &ClangdLSPServer::onPrepareRename);
-MsgHandler->bind("textDocument/rename", &ClangdLSPServer::onRename);
+Bind.method("textDocument/rename", this, &ClangdLSPServer::onRename);
-MsgHandler->bind("textDocument/hover", &ClangdLSPServer::onHover);
+Bind.method("textDocument/hover", this, &ClangdLSPServer::onHover);
-MsgHandler->bind("textDocument/documentSymbol", &ClangdLSPServer::onDocumentSymbol);
+Bind.method("textDocument/documentSymbol", this, &ClangdLSPServer::onDocumentSymbol);
-MsgHandler->bind("workspace/executeCommand", &ClangdLSPServer::onCommand);
+Bind.method("workspace/executeCommand", this, &ClangdLSPServer::onCommand);
-MsgHandler->bind("textDocument/documentHighlight", &ClangdLSPServer::onDocumentHighlight);
+Bind.method("textDocument/documentHighlight", this, &ClangdLSPServer::onDocumentHighlight);
-MsgHandler->bind("workspace/symbol", &ClangdLSPServer::onWorkspaceSymbol);
+Bind.method("workspace/symbol", this, &ClangdLSPServer::onWorkspaceSymbol);
-MsgHandler->bind("textDocument/didOpen", &ClangdLSPServer::onDocumentDidOpen);
+Bind.method("textDocument/ast", this, &ClangdLSPServer::onAST);
-MsgHandler->bind("textDocument/didClose", &ClangdLSPServer::onDocumentDidClose);
+Bind.notification("textDocument/didOpen", this, &ClangdLSPServer::onDocumentDidOpen);
-MsgHandler->bind("textDocument/didChange", &ClangdLSPServer::onDocumentDidChange);
+Bind.notification("textDocument/didClose", this, &ClangdLSPServer::onDocumentDidClose);
-MsgHandler->bind("textDocument/didSave", &ClangdLSPServer::onDocumentDidSave);
+Bind.notification("textDocument/didChange", this, &ClangdLSPServer::onDocumentDidChange);
-MsgHandler->bind("workspace/didChangeWatchedFiles", &ClangdLSPServer::onFileEvent);
+Bind.notification("textDocument/didSave", this, &ClangdLSPServer::onDocumentDidSave);
-MsgHandler->bind("workspace/didChangeConfiguration", &ClangdLSPServer::onChangeConfiguration);
+Bind.notification("workspace/didChangeWatchedFiles", this, &ClangdLSPServer::onFileEvent);
-MsgHandler->bind("textDocument/symbolInfo", &ClangdLSPServer::onSymbolInfo);
+Bind.notification("workspace/didChangeConfiguration", this, &ClangdLSPServer::onChangeConfiguration);
-MsgHandler->bind("textDocument/typeHierarchy", &ClangdLSPServer::onTypeHierarchy);
+Bind.method("textDocument/symbolInfo", this, &ClangdLSPServer::onSymbolInfo);
-MsgHandler->bind("typeHierarchy/resolve", &ClangdLSPServer::onResolveTypeHierarchy);
+Bind.method("textDocument/typeHierarchy", this, &ClangdLSPServer::onTypeHierarchy);
-MsgHandler->bind("textDocument/selectionRange", &ClangdLSPServer::onSelectionRange);
+Bind.method("typeHierarchy/resolve", this, &ClangdLSPServer::onResolveTypeHierarchy);
-MsgHandler->bind("textDocument/documentLink", &ClangdLSPServer::onDocumentLink);
+Bind.method("textDocument/prepareCallHierarchy", this, &ClangdLSPServer::onPrepareCallHierarchy);
-MsgHandler->bind("textDocument/semanticTokens", &ClangdLSPServer::onSemanticTokens);
+Bind.method("callHierarchy/incomingCalls", this, &ClangdLSPServer::onCallHierarchyIncomingCalls);
-MsgHandler->bind("textDocument/semanticTokens/edits", &ClangdLSPServer::onSemanticTokensEdits);
+Bind.method("callHierarchy/outgoingCalls", this, &ClangdLSPServer::onCallHierarchyOutgoingCalls);
+Bind.method("textDocument/selectionRange", this, &ClangdLSPServer::onSelectionRange);
+Bind.method("textDocument/documentLink", this, &ClangdLSPServer::onDocumentLink);
+Bind.method("textDocument/semanticTokens/full", this, &ClangdLSPServer::onSemanticTokens);
+Bind.method("textDocument/semanticTokens/full/delta", this, &ClangdLSPServer::onSemanticTokensDelta);
+Bind.method("clangd/inlayHints", this, &ClangdLSPServer::onInlayHints);
+Bind.method("$/memoryUsage", this, &ClangdLSPServer::onMemoryUsage);
+if (Opts.FoldingRanges)
+Bind.method("textDocument/foldingRange", this, &ClangdLSPServer::onFoldingRange);
+Bind.command(APPLY_FIX_COMMAND, this, &ClangdLSPServer::onCommandApplyEdit);
+Bind.command(APPLY_TWEAK_COMMAND, this, &ClangdLSPServer::onCommandApplyTweak);
+ApplyWorkspaceEdit = Bind.outgoingMethod("workspace/applyEdit");
+PublishDiagnostics = Bind.outgoingNotification("textDocument/publishDiagnostics");
+ShowMessage = Bind.outgoingNotification("window/showMessage");
+NotifyFileStatus = Bind.outgoingNotification("textDocument/clangd.fileStatus");
+CreateWorkDoneProgress = Bind.outgoingMethod("window/workDoneProgress/create");
+BeginWorkDoneProgress = Bind.outgoingNotification("$/progress");
+ReportWorkDoneProgress = Bind.outgoingNotification("$/progress");
+EndWorkDoneProgress = Bind.outgoingNotification("$/progress");
+if(Caps.SemanticTokenRefreshSupport)
+SemanticTokensRefresh = Bind.outgoingMethod("workspace/semanticTokens/refresh");
 // clang-format on
 }
 ClangdLSPServer::~ClangdLSPServer() {
 IsBeingDestroyed = true;
 elog("Transport error: {0}", std::move(Err));
 CleanExit = false;
 }
 return CleanExit && ShutdownRequestReceived;
+}
+void ClangdLSPServer::profile(MemoryTree &MT) const {
+if (Server)
+Server->profile(MT.child("clangd_server"));
 }
 std::vector<Fix> ClangdLSPServer::getFixes(llvm::StringRef File,
 const clangd::Diagnostic &D) {
 std::lock_guard<std::mutex> Lock(FixItsMutex);
 // of simplicity here.
 bool ClangdLSPServer::shouldRunCompletion(
 const CompletionParams &Params) const {
 if (Params.context.triggerKind != CompletionTriggerKind::TriggerCharacter)
 return true;
-auto Code = DraftMgr.getDraft(Params.textDocument.uri.file());
+auto Code = Server->getDraft(Params.textDocument.uri.file());
 if (!Code)
 return true; // completion code will log the error for untracked doc.
-auto Offset = positionToOffset(Code->Contents, Params.position,
+auto Offset = positionToOffset(*Code, Params.position,
 /*AllowColumnsBeyondLineLength=*/false);
 if (!Offset) {
 vlog("could not convert position '{0}' to offset for file '{1}'",
 Params.position, Params.textDocument.uri.file());
 return true;
 }
-return allowImplicitCompletion(Code->Contents, *Offset);
+return allowImplicitCompletion(*Code, *Offset);
-}
-void ClangdLSPServer::onHighlightingsReady(
-PathRef File, llvm::StringRef Version,
-std::vector<HighlightingToken> Highlightings) {
-std::vector<HighlightingToken> Old;
-std::vector<HighlightingToken> HighlightingsCopy = Highlightings;
-{
-std::lock_guard<std::mutex> Lock(HighlightingsMutex);
-Old = std::move(FileToHighlightings[File]);
-FileToHighlightings[File] = std::move(HighlightingsCopy);
-}
-// LSP allows us to send incremental edits of highlightings. Also need to diff
-// to remove highlightings from tokens that should no longer have them.
-std::vector<LineHighlightings> Diffed = diffHighlightings(Highlightings, Old);
-TheiaSemanticHighlightingParams Notification;
-Notification.TextDocument.uri =
-URIForFile::canonicalize(File, /*TUPath=*/File);
-Notification.TextDocument.version = decodeVersion(Version);
-Notification.Lines = toTheiaSemanticHighlightingInformation(Diffed);
-publishTheiaSemanticHighlighting(Notification);
 }
 void ClangdLSPServer::onDiagnosticsReady(PathRef File, llvm::StringRef Version,
 std::vector<Diag> Diagnostics) {
 PublishDiagnosticsParams Notification;
 std::lock_guard<std::mutex> Lock(FixItsMutex);
 FixItsMap[File] = LocalFixIts;
 }
 // Send a notification to the LSP client.
-publishDiagnostics(Notification);
+PublishDiagnostics(Notification);
 }
 void ClangdLSPServer::onBackgroundIndexProgress(
 const BackgroundQueue::Stats &Stats) {
 static const char ProgressToken[] = "backgroundIndexProgress";
+// The background index did some work, maybe we need to cleanup
+maybeCleanupMemory();
 std::lock_guard<std::mutex> Lock(BackgroundIndexProgressMutex);
 auto NotifyProgress = [this](const BackgroundQueue::Stats &Stats) {
 if (BackgroundIndexProgressState != BackgroundIndexProgress::Live) {
 WorkDoneProgressBegin Begin;
 Begin.percentage = true;
 Begin.title = "indexing";
-progress(ProgressToken, std::move(Begin));
+BeginWorkDoneProgress({ProgressToken, std::move(Begin)});
 BackgroundIndexProgressState = BackgroundIndexProgress::Live;
 }
 if (Stats.Completed < Stats.Enqueued) {
 assert(Stats.Enqueued > Stats.LastIdle);
 WorkDoneProgressReport Report;
-Report.percentage = 100.0 * (Stats.Completed - Stats.LastIdle) /
+Report.percentage = 100 * (Stats.Completed - Stats.LastIdle) /
 (Stats.Enqueued - Stats.LastIdle);
 Report.message =
 llvm::formatv("{0}/{1}", Stats.Completed - Stats.LastIdle,
 Stats.Enqueued - Stats.LastIdle);
-progress(ProgressToken, std::move(Report));
+ReportWorkDoneProgress({ProgressToken, std::move(Report)});
 } else {
 assert(Stats.Completed == Stats.Enqueued);
-progress(ProgressToken, WorkDoneProgressEnd());
+EndWorkDoneProgress({ProgressToken, WorkDoneProgressEnd()});
 BackgroundIndexProgressState = BackgroundIndexProgress::Empty;
 }
 };
 switch (BackgroundIndexProgressState) {
 // Cache this update for when the progress bar is available.
 PendingBackgroundIndexProgress = Stats;
 BackgroundIndexProgressState = BackgroundIndexProgress::Creating;
 WorkDoneProgressCreateParams CreateRequest;
 CreateRequest.token = ProgressToken;
-call<std::nullptr_t>(
+CreateWorkDoneProgress(
-"window/workDoneProgress/create", CreateRequest,
+CreateRequest,
 [this, NotifyProgress](llvm::Expected<std::nullptr_t> E) {
 std::lock_guard<std::mutex> Lock(BackgroundIndexProgressMutex);
 if (E) {
 NotifyProgress(this->PendingBackgroundIndexProgress);
 } else {
 // reasonable time interval (e.g. 0.5s).
 if (Status.PreambleActivity == PreambleAction::Idle &&
 (Status.ASTActivity.K == ASTAction::Building ||
 Status.ASTActivity.K == ASTAction::RunningAction))
 return;
-notify("textDocument/clangd.fileStatus", Status.render(File));
+NotifyFileStatus(Status.render(File));
 }
-void ClangdLSPServer::reparseOpenFilesIfNeeded(
+void ClangdLSPServer::onSemanticsMaybeChanged(PathRef File) {
-llvm::function_ref<bool(llvm::StringRef File)> Filter) {
+if (SemanticTokensRefresh) {
-// Reparse only opened files that were modified.
+SemanticTokensRefresh(NoParams{}, [](llvm::Expected<std::nullptr_t> E) {
-for (const Path &FilePath : DraftMgr.getActiveFiles())
+if (E)
-if (Filter(FilePath))
+return;
-if (auto Draft = DraftMgr.getDraft(FilePath)) // else disappeared in race?
+elog("Failed to refresh semantic tokens: {0}", E.takeError());
-Server->addDocument(FilePath, std::move(Draft->Contents),
+});
-encodeVersion(Draft->Version),
+}
-WantDiagnostics::Auto);
+}
-}
 } // namespace clangd
 } // namespace clang

Mercurial > hg > CbC > CbC_llvm

comparison clang-tools-extra/clangd/ClangdLSPServer.cpp @ 207:2e18cbf3894f