csh
/
tsl-devkit
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

✨ feat(provider): add compile-time registry

This commit is contained in:
csh 2025-12-21 22:21:46 +08:00
parent f54050bad2
commit 2c1c1d8a88
82 changed files with 751 additions and 1001 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
lsp-server/src/core/server.cppm
View File

@ -18,18 +18,7 @@ import lsp.manager.manager_hub;
import lsp.manager.bootstrap;
import lsp.scheduler.async_executor;
import lsp.provider.base.interface;
import lsp.provider.base.registry;
import lsp.provider.initialize.initialize;
import lsp.provider.initialized.initialized;
import lsp.provider.text_document.did_open;
import lsp.provider.text_document.did_change;
import lsp.provider.text_document.did_close;
import lsp.provider.text_document.completion;
import lsp.provider.trace.set_trace;
import lsp.provider.shutdown.shutdown;
import lsp.provider.cancel_request.cancel_request;
import lsp.provider.exit.exit;
import lsp.provider.completion_item.resolve;
import lsp.provider.manifest;
namespace transform = lsp::codec;
@ -416,20 +405,7 @@ namespace lsp::core
spdlog::info("Registering LSP providers...");
provider::RegisterProvider<provider::Initialize>(dispatcher_);
provider::RegisterProvider<provider::Initialized>(dispatcher_);
provider::RegisterProvider<provider::text_document::DidOpen>(dispatcher_);
provider::RegisterProvider<provider::text_document::DidChange>(dispatcher_);
provider::RegisterProvider<provider::text_document::DidClose>(dispatcher_);
provider::RegisterProvider<provider::text_document::Completion>(dispatcher_);
// provider::RegisterProvider<provider::text_document::SemanticTokensRange>(dispatcher_);
// provider::RegisterProvider<provider::text_document::SemanticTokensFull>(dispatcher_);
// provider::RegisterProvider<provider::text_document::SemanticTokensFullDelta>(dispatcher_);
provider::RegisterProvider<provider::completion_item::Resolve>(dispatcher_);
provider::RegisterProvider<provider::SetTrace>(dispatcher_);
provider::RegisterProvider<provider::Shutdown>(dispatcher_);
provider::RegisterProvider<provider::CancelRequest>(dispatcher_);
provider::RegisterProvider<provider::Exit>(dispatcher_);
provider::RegisterAllProviders(dispatcher_);
spdlog::info("Registered {} LSP providers", dispatcher_.GetAllSupportedMethods().size());
}

29
lsp-server/src/provider/base/interface.cppm
View File

@ -2,6 +2,8 @@ module;
export module lsp.provider.base.interface;
import std;
// Thin bridge to core dispatcher interfaces and aliases for backward compatibility.
export import lsp.core.dispacther;
@ -14,4 +16,31 @@ export namespace lsp::provider
using IRequestProvider = lsp::core::IRequestProvider;
using INotificationProvider = lsp::core::INotificationProvider;
using lsp::core::BuildErrorResponseMessage;
template<typename T>
concept HasMethod = requires {
{ T::kMethod } -> std::convertible_to<std::string_view>;
};
template<typename T>
concept HasProviderName = requires {
{ T::kProviderName } -> std::convertible_to<std::string_view>;
};
template<typename Derived, typename Interface>
class AutoRegisterProvider : public Interface
{
public:
static constexpr bool kAutoRegister = true;
std::string GetMethod() const override
{
return std::string(Derived::kMethod);
}
std::string GetProviderName() const override
{
return std::string(Derived::kProviderName);
}
};
}

72
lsp-server/src/provider/base/registry.cppm
View File

@ -1,34 +1,72 @@
module;
export module lsp.provider.base.registry;
import spdlog;
import std;
import lsp.core.dispacther;
import lsp.core.dispacther;
import lsp.provider.base.interface;
export namespace lsp::provider
{
// 注册请求处理器的模板函数
template<typename ProviderClass>
typename std::enable_if_t<std::is_base_of_v<core::IRequestProvider, ProviderClass>>
RegisterProvider(core::RequestDispatcher& dispatcher)
template<typename T>
concept AutoRegisterableProvider = HasMethod<T> && HasProviderName<T> &&
requires {
{ T::kAutoRegister } -> std::convertible_to<bool>;
} &&
(std::derived_from<T, core::IRequestProvider> ||
std::derived_from<T, core::INotificationProvider>);
template<AutoRegisterableProvider... Providers>
consteval bool HasDuplicateMethods()
{
auto provider = std::make_shared<ProviderClass>();
dispatcher.RegisterRequestProvider(provider);
spdlog::debug("Registered request provider [{}] for [{}]", provider->GetProviderName(), provider->GetMethod());
std::array<std::string_view, sizeof...(Providers)> methods = { Providers::kMethod... };
for (std::size_t i = 0; i < methods.size(); ++i)
{
for (std::size_t j = i + 1; j < methods.size(); ++j)
{
if (methods[i] == methods[j])
{
return true;
}
}
}
return false;
}
// 注册通知处理器的模板函数
template<typename ProviderClass>
typename std::enable_if_t<std::is_base_of_v<core::INotificationProvider, ProviderClass>>
RegisterProvider(core::RequestDispatcher& dispatcher)
template<AutoRegisterableProvider... Providers>
class ProviderRegistry
{
auto provider = std::make_shared<ProviderClass>();
dispatcher.RegisterNotificationProvider(provider);
spdlog::debug("Registered notification provider [{}] for [{}]", provider->GetProviderName(), provider->GetMethod());
}
public:
static constexpr std::size_t kProviderCount = sizeof...(Providers);
using ProviderList = std::tuple<Providers...>;
static void RegisterAll(core::RequestDispatcher& dispatcher)
{
(RegisterProvider<Providers>(dispatcher), ...);
}
private:
static_assert(!HasDuplicateMethods<Providers...>(),
"Duplicate method names detected in providers.");
template<typename Provider>
static void RegisterProvider(core::RequestDispatcher& dispatcher)
{
auto provider = std::make_shared<Provider>();
if constexpr (std::derived_from<Provider, core::IRequestProvider>)
{
dispatcher.RegisterRequestProvider(provider);
}
else if constexpr (std::derived_from<Provider, core::INotificationProvider>)
{
dispatcher.RegisterNotificationProvider(provider);
}
spdlog::debug("Registered provider [{}] for [{}]",
Provider::kProviderName, Provider::kMethod);
}
};
}

16
lsp-server/src/provider/call_hierarchy/incoming_calls.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::call_hierarchy
{
class IncomingCalls : public IRequestProvider
class IncomingCalls : public AutoRegisterProvider<IncomingCalls, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "callHierarchy/incomingCalls";
static constexpr std::string_view kProviderName = "CallHierarchyIncomingCalls";
IncomingCalls() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::call_hierarchy
{
std::string IncomingCalls::GetMethod() const
{
return "callHierarchy/incomingCalls";
}
std::string IncomingCalls::GetProviderName() const
{
return "CallHierarchyIncomingCalls";
}
std::string IncomingCalls::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/call_hierarchy/outgoing_calls.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::call_hierarchy
{
class OutgoingCalls : public IRequestProvider
class OutgoingCalls : public AutoRegisterProvider<OutgoingCalls, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "callHierarchy/outgoingCalls";
static constexpr std::string_view kProviderName = "CallHierarchyOutgoingCalls";
OutgoingCalls() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::call_hierarchy
{
std::string OutgoingCalls::GetMethod() const
{
return "callHierarchy/outgoingCalls";
}
std::string OutgoingCalls::GetProviderName() const
{
return "CallHierarchyOutgoingCalls";
}
std::string OutgoingCalls::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/cancel_request/cancel_request.cppm
View File

@ -14,27 +14,21 @@ namespace transform = lsp::codec;
export namespace lsp::provider
{
class CancelRequest : public INotificationProvider
class CancelRequest : public AutoRegisterProvider<CancelRequest, INotificationProvider>
{
public:
static constexpr std::string_view kMethod = "$/cancelRequest";
static constexpr std::string_view kProviderName = "CancelRequest";
CancelRequest() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
void HandleNotification(const protocol::NotificationMessage& notification, ExecutionContext& context) override;
};
}
namespace lsp::provider
{
std::string CancelRequest::GetMethod() const
{
return "$/cancelRequest";
}
std::string CancelRequest::GetProviderName() const
{
return "CancelRequest";
}
void CancelRequest::HandleNotification(const protocol::NotificationMessage& notification, ExecutionContext& context)
{

18
lsp-server/src/provider/client/register_capability.cppm
View File

@ -14,28 +14,22 @@ namespace transform = lsp::codec;
export namespace lsp::provider::client
{
class RegisterCapability : public IRequestProvider
class RegisterCapability : public AutoRegisterProvider<RegisterCapability, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "client/registerCapability";
static constexpr std::string_view kProviderName = "ClientRegisterCapability";
RegisterCapability() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::client
{
std::string RegisterCapability::GetMethod() const
{
return "client/registerCapability";
}
std::string RegisterCapability::GetProviderName() const
{
return "ClientRegisterCapability";
}
std::string RegisterCapability::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{
@ -45,7 +39,7 @@ namespace lsp::provider::client
protocol::ResponseMessage response;
response.id = request.id;
response.result = std::nullopt; // 成功返回null
response.result = protocol::LSPAny{}; // explicit null result
std::optional<std::string> json = transform::Serialize(response);
if (!json.has_value())

18
lsp-server/src/provider/client/unregister_capability.cppm
View File

@ -14,35 +14,29 @@ namespace transform = lsp::codec;
export namespace lsp::provider::client
{
class UnregisterCapability : public IRequestProvider
class UnregisterCapability : public AutoRegisterProvider<UnregisterCapability, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "client/unregisterCapability";
static constexpr std::string_view kProviderName = "ClientUnregisterCapability";
UnregisterCapability() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::client
{
std::string UnregisterCapability::GetMethod() const
{
return "client/unregisterCapability";
}
std::string UnregisterCapability::GetProviderName() const
{
return "ClientUnregisterCapability";
}
std::string UnregisterCapability::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{
spdlog::debug("UnregisterCapabilityProvider: Providing response for method {}", request.method);
protocol::ResponseMessage response;
response.id = request.id;
response.result = std::nullopt;
response.result = protocol::LSPAny{};
std::optional<std::string> json = transform::Serialize(response);
if (!json.has_value())

16
lsp-server/src/provider/code_action/resolve.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::code_action
{
class Resolve : public IRequestProvider
class Resolve : public AutoRegisterProvider<Resolve, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "codeAction/resolve";
static constexpr std::string_view kProviderName = "CodeActionResolve";
Resolve() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::code_action
{
std::string Resolve::GetMethod() const
{
return "codeAction/resolve";
}
std::string Resolve::GetProviderName() const
{
return "CodeActionResolve";
}
std::string Resolve::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/code_lens/resolve.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::code_lens
{
class Resolve : public IRequestProvider
class Resolve : public AutoRegisterProvider<Resolve, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "codeLens/resolve";
static constexpr std::string_view kProviderName = "CodeLensResolve";
Resolve() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::code_lens
{
std::string Resolve::GetMethod() const
{
return "codeLens/resolve";
}
std::string Resolve::GetProviderName() const
{
return "CodeLensResolve";
}
std::string Resolve::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/completion_item/resolve.cppm
View File

@ -16,13 +16,13 @@ namespace transform = lsp::codec;
export namespace lsp::provider::completion_item
{
class Resolve : public IRequestProvider
class Resolve : public AutoRegisterProvider<Resolve, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "completionItem/resolve";
static constexpr std::string_view kProviderName = "CompletionItemResolve";
Resolve() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& execution_context) override;
};
}
@ -237,15 +237,9 @@ namespace lsp::provider::completion_item
}
}
std::string Resolve::GetMethod() const
{
return "completionItem/resolve";
}
std::string Resolve::GetProviderName() const
{
return "CompletionItemResolve";
}
std::string Resolve::ProvideResponse(const protocol::RequestMessage& request,
ExecutionContext& execution_context)

16
lsp-server/src/provider/document_link/resolve.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::document_link
{
class Resolve : public IRequestProvider
class Resolve : public AutoRegisterProvider<Resolve, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "documentLink/resolve";
static constexpr std::string_view kProviderName = "DocumentLinkResolve";
Resolve() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::document_link
{
std::string Resolve::GetMethod() const
{
return "documentLink/resolve";
}
std::string Resolve::GetProviderName() const
{
return "DocumentLinkResolve";
}
std::string Resolve::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/exit/exit.cppm
View File

@ -11,28 +11,22 @@ import lsp.protocol.types;
export namespace lsp::provider
{
class Exit : public INotificationProvider
class Exit : public AutoRegisterProvider<Exit, INotificationProvider>
{
public:
static constexpr std::string_view kMethod = "exit";
static constexpr std::string_view kProviderName = "Exit";
Exit() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
void HandleNotification(const protocol::NotificationMessage& notification, ExecutionContext& context) override;
};
}
namespace lsp::provider
{
std::string Exit::GetMethod() const
{
return "exit";
}
std::string Exit::GetProviderName() const
{
return "Exit";
}
void Exit::HandleNotification(const protocol::NotificationMessage& notification, ExecutionContext& context)
{

16
lsp-server/src/provider/initialize/initialize.cppm
View File

@ -16,14 +16,14 @@ namespace transform = lsp::codec;
export namespace lsp::provider
{
class Initialize : public IRequestProvider
class Initialize : public AutoRegisterProvider<Initialize, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "initialize";
static constexpr std::string_view kProviderName = "Initialize";
Initialize() = default;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
std::string GetMethod() const override;
std::string GetProviderName() const override;
private:
protocol::InitializeResult BuildInitializeResult();
@ -37,15 +37,9 @@ export namespace lsp::provider
namespace lsp::provider
{
std::string Initialize::GetMethod() const
{
return "initialize";
}
std::string Initialize::GetProviderName() const
{
return "Initialize";
}
std::string Initialize::ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context)
{

16
lsp-server/src/provider/initialized/initialized.cppm
View File

@ -11,13 +11,13 @@ import lsp.protocol;
export namespace lsp::provider
{
class Initialized : public INotificationProvider
class Initialized : public AutoRegisterProvider<Initialized, INotificationProvider>
{
public:
static constexpr std::string_view kMethod = "initialized";
static constexpr std::string_view kProviderName = "Initialized";
Initialized() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
void HandleNotification(const protocol::NotificationMessage& notification, ExecutionContext& context) override;
};
}
@ -25,15 +25,9 @@ export namespace lsp::provider
namespace lsp::provider
{
std::string Initialized::GetMethod() const
{
return "initialized";
}
std::string Initialized::GetProviderName() const
{
return "Initialized";
}
void Initialized::HandleNotification(const protocol::NotificationMessage& notification, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/inlay_hint/resolve.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::inlay_hint
{
class Resolve : public IRequestProvider
class Resolve : public AutoRegisterProvider<Resolve, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "inlayHint/resolve";
static constexpr std::string_view kProviderName = "InlayHintResolve";
Resolve() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::inlay_hint
{
std::string Resolve::GetMethod() const
{
return "inlayHint/resolve";
}
std::string Resolve::GetProviderName() const
{
return "InlayHintResolve";
}
std::string Resolve::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

176
lsp-server/src/provider/manifest.cppm Normal file
View File

@ -0,0 +1,176 @@
module;
export module lsp.provider.manifest;
import lsp.core.dispacther;
import lsp.provider.base.registry;
import lsp.provider.call_hierarchy.incoming_calls;
import lsp.provider.call_hierarchy.outgoing_calls;
import lsp.provider.cancel_request.cancel_request;
import lsp.provider.client.register_capability;
import lsp.provider.client.unregister_capability;
import lsp.provider.code_action.resolve;
import lsp.provider.code_lens.resolve;
import lsp.provider.completion_item.resolve;
import lsp.provider.document_link.resolve;
import lsp.provider.exit.exit;
import lsp.provider.initialize.initialize;
import lsp.provider.initialized.initialized;
import lsp.provider.inlay_hint.resolve;
import lsp.provider.shutdown.shutdown;
import lsp.provider.telemetry.event;
import lsp.provider.text_document.code_action;
import lsp.provider.text_document.code_lens;
import lsp.provider.text_document.color_presentation;
import lsp.provider.text_document.completion;
import lsp.provider.text_document.definition;
import lsp.provider.text_document.diagnostic;
import lsp.provider.text_document.did_change;
import lsp.provider.text_document.did_close;
import lsp.provider.text_document.did_open;
import lsp.provider.text_document.document_color;
import lsp.provider.text_document.document_highlight;
import lsp.provider.text_document.document_link;
import lsp.provider.text_document.document_symbol;
import lsp.provider.text_document.folding_range;
import lsp.provider.text_document.formatting;
import lsp.provider.text_document.hover;
import lsp.provider.text_document.implementation;
import lsp.provider.text_document.inlay_hint;
import lsp.provider.text_document.inline_value;
import lsp.provider.text_document.linked_editing_range;
import lsp.provider.text_document.moniker;
import lsp.provider.text_document.on_type_formatting;
import lsp.provider.text_document.prepare_call_hierarchy;
import lsp.provider.text_document.prepare_rename;
import lsp.provider.text_document.prepare_type_hierarchy;
import lsp.provider.text_document.publish_diagnostics;
import lsp.provider.text_document.range_formatting;
import lsp.provider.text_document.references;
import lsp.provider.text_document.rename;
import lsp.provider.text_document.selection_range;
import lsp.provider.text_document.semantic_tokens;
import lsp.provider.text_document.signature_help;
import lsp.provider.text_document.type_definition;
import lsp.provider.trace.set_trace;
import lsp.provider.type_hierarchy.subtypes;
import lsp.provider.type_hierarchy.supertypes;
import lsp.provider.window.log_message;
import lsp.provider.window.show_document;
import lsp.provider.window.show_message;
import lsp.provider.window.show_message_request;
import lsp.provider.window.work_done_progress_create;
import lsp.provider.workspace.apply_edit;
import lsp.provider.workspace.code_lens_refresh;
import lsp.provider.workspace.configuration;
import lsp.provider.workspace.diagnostic;
import lsp.provider.workspace.diagnostic_refresh;
import lsp.provider.workspace.did_change_configuration;
import lsp.provider.workspace.did_change_watched_files;
import lsp.provider.workspace.did_change_workspace_folders;
import lsp.provider.workspace.did_create_files;
import lsp.provider.workspace.did_delete_files;
import lsp.provider.workspace.did_rename_files;
import lsp.provider.workspace.execute_command;
import lsp.provider.workspace.inlay_hint_refresh;
import lsp.provider.workspace.inline_value_refresh;
import lsp.provider.workspace.semantic_tokens_refresh;
import lsp.provider.workspace.symbol;
import lsp.provider.workspace.will_create_files;
import lsp.provider.workspace.will_delete_files;
import lsp.provider.workspace.will_rename_files;
import lsp.provider.workspace.workspace_folders;
import lsp.provider.workspace_symbol.resolve;
export namespace lsp::provider
{
using AllProviders = ProviderRegistry<
call_hierarchy::IncomingCalls,
call_hierarchy::OutgoingCalls,
CancelRequest,
client::RegisterCapability,
client::UnregisterCapability,
code_action::Resolve,
code_lens::Resolve,
completion_item::Resolve,
document_link::Resolve,
Exit,
Initialize,
Initialized,
inlay_hint::Resolve,
Shutdown,
telemetry::Event,
text_document::CodeAction,
text_document::CodeLens,
text_document::ColorPresentation,
text_document::Completion,
text_document::Definition,
text_document::Diagnostic,
text_document::DidChange,
text_document::DidClose,
text_document::DidOpen,
text_document::DocumentColor,
text_document::DocumentHighlight,
text_document::DocumentLink,
text_document::DocumentSymbol,
text_document::FoldingRange,
text_document::Formatting,
text_document::Hover,
text_document::Implementation,
text_document::InlayHint,
text_document::InlineValue,
text_document::LinkedEditingRange,
text_document::Moniker,
text_document::OnTypeFormatting,
text_document::PrepareCallHierarchy,
text_document::PrepareRename,
text_document::PrepareTypeHierarchy,
text_document::PublishDiagnostics,
text_document::RangeFormatting,
text_document::References,
text_document::Rename,
text_document::SelectionRange,
text_document::SemanticTokensRange,
text_document::SemanticTokensFull,
text_document::SemanticTokensFullDelta,
text_document::SignatureHelp,
text_document::TypeDefinition,
SetTrace,
type_hierarchy::Subtypes,
type_hierarchy::Supertypes,
window::LogMessage,
window::ShowDocument,
window::ShowMessage,
window::ShowMessageRequest,
window::WorkDoneProgressCreate,
workspace::ApplyEdit,
workspace::CodeLensRefresh,
workspace::Configuration,
workspace::Diagnostic,
workspace::DiagnosticRefresh,
workspace::DidChangeConfiguration,
workspace::DidChangeWatchedFiles,
workspace::DidChangeWorkspaceFolders,
workspace::DidCreateFiles,
workspace::DidDeleteFiles,
workspace::DidRenameFiles,
workspace::ExecuteCommand,
workspace::InlayHintRefresh,
workspace::InlineValueRefresh,
workspace::SemanticTokensRefresh,
workspace::Symbol,
workspace::WillCreateFiles,
workspace::WillDeleteFiles,
workspace::WillRenameFiles,
workspace::WorkspaceFolders,
workspace_symbol::Resolve
>;
static_assert(AllProviders::kProviderCount > 0, "No providers registered.");
inline void RegisterAllProviders(core::RequestDispatcher& dispatcher)
{
AllProviders::RegisterAll(dispatcher);
}
}

16
lsp-server/src/provider/shutdown/shutdown.cppm
View File

@ -14,28 +14,22 @@ namespace transform = lsp::codec;
export namespace lsp::provider
{
class Shutdown : public IRequestProvider
class Shutdown : public AutoRegisterProvider<Shutdown, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "shutdown";
static constexpr std::string_view kProviderName = "Shutdown";
Shutdown() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider
{
std::string Shutdown::GetMethod() const
{
return "shutdown";
}
std::string Shutdown::GetProviderName() const
{
return "Shutdown";
}
std::string Shutdown::ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context)
{

16
lsp-server/src/provider/telemetry/event.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::telemetry
{
class Event : public INotificationProvider
class Event : public AutoRegisterProvider<Event, INotificationProvider>
{
public:
static constexpr std::string_view kMethod = "telemetry/event";
static constexpr std::string_view kProviderName = "TelemetryEvent";
Event() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
void HandleNotification(const protocol::NotificationMessage& notification, ExecutionContext& context) override;
};
}
namespace lsp::provider::telemetry
{
std::string Event::GetMethod() const
{
return "telemetry/event";
}
std::string Event::GetProviderName() const
{
return "TelemetryEvent";
}
void Event::HandleNotification(const protocol::NotificationMessage& notification, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/text_document/code_action.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::text_document
{
class CodeAction : public IRequestProvider
class CodeAction : public AutoRegisterProvider<CodeAction, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "textDocument/codeAction";
static constexpr std::string_view kProviderName = "TextDocumentCodeAction";
CodeAction() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::text_document
{
std::string CodeAction::GetMethod() const
{
return "textDocument/codeAction";
}
std::string CodeAction::GetProviderName() const
{
return "TextDocumentCodeAction";
}
std::string CodeAction::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/text_document/code_lens.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::text_document
{
class CodeLens : public IRequestProvider
class CodeLens : public AutoRegisterProvider<CodeLens, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "textDocument/codeLens";
static constexpr std::string_view kProviderName = "TextDocumentCodeLens";
CodeLens() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::text_document
{
std::string CodeLens::GetMethod() const
{
return "textDocument/codeLens";
}
std::string CodeLens::GetProviderName() const
{
return "TextDocumentCodeLens";
}
std::string CodeLens::ProvideResponse(const protocol::RequestMessage& request,
[[maybe_unused]] ExecutionContext& context)

16
lsp-server/src/provider/text_document/color_presentation.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::text_document
{
class ColorPresentation : public IRequestProvider
class ColorPresentation : public AutoRegisterProvider<ColorPresentation, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "textDocument/colorPresentation";
static constexpr std::string_view kProviderName = "TextDocumentColorPresentation";
ColorPresentation() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::text_document
{
std::string ColorPresentation::GetMethod() const
{
return "textDocument/colorPresentation";
}
std::string ColorPresentation::GetProviderName() const
{
return "TextDocumentColorPresentation";
}
std::string ColorPresentation::ProvideResponse(const protocol::RequestMessage& request,
[[maybe_unused]] ExecutionContext& context)

16
lsp-server/src/provider/text_document/completion.cppm
View File

@ -21,11 +21,11 @@ namespace transform = lsp::codec;
export namespace lsp::provider::text_document
{
class Completion : public IRequestProvider
class Completion : public AutoRegisterProvider<Completion, IRequestProvider>
{
public:
std::string GetMethod() const override;
std::string GetProviderName() const override;
static constexpr std::string_view kMethod = "textDocument/completion";
static constexpr std::string_view kProviderName = "TextDocumentCompletion";
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& execution_context) override;
};
}
@ -1510,15 +1510,9 @@ namespace lsp::provider::text_document
}
}
std::string Completion::GetMethod() const
{
return "textDocument/completion";
}
std::string Completion::GetProviderName() const
{
return "TextDocumentCompletion";
}
std::string Completion::ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& execution_context)
{

25
lsp-server/src/provider/text_document/definition.cppm
View File

@ -25,13 +25,13 @@ namespace transform = lsp::codec;
export namespace lsp::provider::text_document
{
class Definition : public IRequestProvider
class Definition : public AutoRegisterProvider<Definition, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "textDocument/definition";
static constexpr std::string_view kProviderName = "TextDocumentDefinition";
Definition() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
private:
@ -51,15 +51,9 @@ export namespace lsp::provider::text_document
namespace lsp::provider::text_document
{
std::string Definition::GetMethod() const
{
return "textDocument/definition";
}
std::string Definition::GetProviderName() const
{
return "TextDocumentDefinition";
}
std::string Definition::ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context)
{
@ -79,14 +73,7 @@ namespace lsp::provider::text_document
protocol::ResponseMessage response;
response.id = request.id;
if (location.has_value())
{
response.result = transform::ToLSPAny(*location);
}
else
{
response.result = std::nullopt;
}
response.result = transform::ToLSPAny(location);
std::optional<std::string> json = transform::Serialize(response);
if (!json.has_value())

16
lsp-server/src/provider/text_document/diagnostic.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::text_document
{
class Diagnostic : public IRequestProvider
class Diagnostic : public AutoRegisterProvider<Diagnostic, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "textDocument/diagnostic";
static constexpr std::string_view kProviderName = "TextDocumentDiagnostic";
Diagnostic() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::text_document
{
std::string Diagnostic::GetMethod() const
{
return "textDocument/diagnostic";
}
std::string Diagnostic::GetProviderName() const
{
return "TextDocumentDiagnostic";
}
std::string Diagnostic::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/text_document/did_change.cppm
View File

@ -14,13 +14,13 @@ namespace transform = lsp::codec;
export namespace lsp::provider::text_document
{
class DidChange : public INotificationProvider
class DidChange : public AutoRegisterProvider<DidChange, INotificationProvider>
{
public:
static constexpr std::string_view kMethod = "textDocument/didChange";
static constexpr std::string_view kProviderName = "TextDocumentDidChange";
DidChange() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
void HandleNotification(const protocol::NotificationMessage& notification, ExecutionContext& context) override;
};
}
@ -28,15 +28,9 @@ export namespace lsp::provider::text_document
namespace lsp::provider::text_document
{
std::string DidChange::GetMethod() const
{
return "textDocument/didChange";
}
std::string DidChange::GetProviderName() const
{
return "TextDocumentDidChange";
}
void DidChange::HandleNotification(const protocol::NotificationMessage& notification, ExecutionContext& context)
{

16
lsp-server/src/provider/text_document/did_close.cppm
View File

@ -14,13 +14,13 @@ namespace transform = lsp::codec;
export namespace lsp::provider::text_document
{
class DidClose : public INotificationProvider
class DidClose : public AutoRegisterProvider<DidClose, INotificationProvider>
{
public:
static constexpr std::string_view kMethod = "textDocument/didClose";
static constexpr std::string_view kProviderName = "TextDocumentDidClose";
DidClose() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
void HandleNotification(const protocol::NotificationMessage& notification, ExecutionContext& context) override;
};
}
@ -28,15 +28,9 @@ export namespace lsp::provider::text_document
namespace lsp::provider::text_document
{
std::string DidClose::GetMethod() const
{
return "textDocument/didClose";
}
std::string DidClose::GetProviderName() const
{
return "TextDocumentDidClose";
}
void DidClose::HandleNotification(const protocol::NotificationMessage& notification, ExecutionContext& context)
{

16
lsp-server/src/provider/text_document/did_open.cppm
View File

@ -14,28 +14,22 @@ namespace transform = lsp::codec;
export namespace lsp::provider::text_document
{
class DidOpen : public INotificationProvider
class DidOpen : public AutoRegisterProvider<DidOpen, INotificationProvider>
{
public:
static constexpr std::string_view kMethod = "textDocument/didOpen";
static constexpr std::string_view kProviderName = "TextDocumentDidOpen";
DidOpen() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
void HandleNotification(const protocol::NotificationMessage& notification, ExecutionContext& context) override;
};
}
namespace lsp::provider::text_document
{
std::string DidOpen::GetMethod() const
{
return "textDocument/didOpen";
}
std::string DidOpen::GetProviderName() const
{
return "TextDocumentDidOpen";
}
void DidOpen::HandleNotification(const protocol::NotificationMessage& notification, ExecutionContext& context)
{

16
lsp-server/src/provider/text_document/document_color.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::text_document
{
class DocumentColor : public IRequestProvider
class DocumentColor : public AutoRegisterProvider<DocumentColor, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "textDocument/documentColor";
static constexpr std::string_view kProviderName = "TextDocumentDocumentColor";
DocumentColor() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::text_document
{
std::string DocumentColor::GetMethod() const
{
return "textDocument/documentColor";
}
std::string DocumentColor::GetProviderName() const
{
return "TextDocumentDocumentColor";
}
std::string DocumentColor::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/text_document/document_highlight.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::text_document
{
class DocumentHighlight : public IRequestProvider
class DocumentHighlight : public AutoRegisterProvider<DocumentHighlight, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "textDocument/documentHighlight";
static constexpr std::string_view kProviderName = "TextDocumentDocumentHighlight";
DocumentHighlight() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::text_document
{
std::string DocumentHighlight::GetMethod() const
{
return "textDocument/documentHighlight";
}
std::string DocumentHighlight::GetProviderName() const
{
return "TextDocumentDocumentHighlight";
}
std::string DocumentHighlight::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/text_document/document_link.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::text_document
{
class DocumentLink : public IRequestProvider
class DocumentLink : public AutoRegisterProvider<DocumentLink, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "textDocument/documentLink";
static constexpr std::string_view kProviderName = "TextDocumentDocumentLink";
DocumentLink() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::text_document
{
std::string DocumentLink::GetMethod() const
{
return "textDocument/documentLink";
}
std::string DocumentLink::GetProviderName() const
{
return "TextDocumentDocumentLink";
}
std::string DocumentLink::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/text_document/document_symbol.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::text_document
{
class DocumentSymbol : public IRequestProvider
class DocumentSymbol : public AutoRegisterProvider<DocumentSymbol, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "textDocument/documentSymbol";
static constexpr std::string_view kProviderName = "TextDocumentDocumentSymbol";
DocumentSymbol() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::text_document
{
std::string DocumentSymbol::GetMethod() const
{
return "textDocument/documentSymbol";
}
std::string DocumentSymbol::GetProviderName() const
{
return "TextDocumentDocumentSymbol";
}
std::string DocumentSymbol::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/text_document/folding_range.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::text_document
{
class FoldingRange : public IRequestProvider
class FoldingRange : public AutoRegisterProvider<FoldingRange, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "textDocument/foldingRange";
static constexpr std::string_view kProviderName = "TextDocumentFoldingRange";
FoldingRange() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::text_document
{
std::string FoldingRange::GetMethod() const
{
return "textDocument/foldingRange";
}
std::string FoldingRange::GetProviderName() const
{
return "TextDocumentFoldingRange";
}
std::string FoldingRange::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/text_document/formatting.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::text_document
{
class Formatting : public IRequestProvider
class Formatting : public AutoRegisterProvider<Formatting, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "textDocument/formatting";
static constexpr std::string_view kProviderName = "TextDocumentFormatting";
Formatting() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::text_document
{
std::string Formatting::GetMethod() const
{
return "textDocument/formatting";
}
std::string Formatting::GetProviderName() const
{
return "TextDocumentFormatting";
}
std::string Formatting::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/text_document/hover.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::text_document
{
class Hover : public IRequestProvider
class Hover : public AutoRegisterProvider<Hover, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "textDocument/hover";
static constexpr std::string_view kProviderName = "TextDocumentHover";
Hover() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::text_document
{
std::string Hover::GetMethod() const
{
return "textDocument/hover";
}
std::string Hover::GetProviderName() const
{
return "TextDocumentHover";
}
std::string Hover::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/text_document/implementation.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::text_document
{
class Implementation : public IRequestProvider
class Implementation : public AutoRegisterProvider<Implementation, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "textDocument/implementation";
static constexpr std::string_view kProviderName = "TextDocumentImplementation";
Implementation() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::text_document
{
std::string Implementation::GetMethod() const
{
return "textDocument/implementation";
}
std::string Implementation::GetProviderName() const
{
return "TextDocumentImplementation";
}
std::string Implementation::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/text_document/inlay_hint.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::text_document
{
class InlayHint : public IRequestProvider
class InlayHint : public AutoRegisterProvider<InlayHint, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "textDocument/inlayHint";
static constexpr std::string_view kProviderName = "TextDocumentInlayHint";
InlayHint() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::text_document
{
std::string InlayHint::GetMethod() const
{
return "textDocument/inlayHint";
}
std::string InlayHint::GetProviderName() const
{
return "TextDocumentInlayHint";
}
std::string InlayHint::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/text_document/inline_value.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::text_document
{
class InlineValue : public IRequestProvider
class InlineValue : public AutoRegisterProvider<InlineValue, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "textDocument/inlineValue";
static constexpr std::string_view kProviderName = "TextDocumentInlineValue";
InlineValue() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::text_document
{
std::string InlineValue::GetMethod() const
{
return "textDocument/inlineValue";
}
std::string InlineValue::GetProviderName() const
{
return "TextDocumentInlineValue";
}
std::string InlineValue::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/text_document/linked_editing_range.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::text_document
{
class LinkedEditingRange : public IRequestProvider
class LinkedEditingRange : public AutoRegisterProvider<LinkedEditingRange, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "textDocument/linkedEditingRange";
static constexpr std::string_view kProviderName = "TextDocumentLinkedEditingRange";
LinkedEditingRange() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::text_document
{
std::string LinkedEditingRange::GetMethod() const
{
return "textDocument/linkedEditingRange";
}
std::string LinkedEditingRange::GetProviderName() const
{
return "TextDocumentLinkedEditingRange";
}
std::string LinkedEditingRange::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/text_document/moniker.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::text_document
{
class Moniker : public IRequestProvider
class Moniker : public AutoRegisterProvider<Moniker, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "textDocument/moniker";
static constexpr std::string_view kProviderName = "TextDocumentMoniker";
Moniker() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::text_document
{
std::string Moniker::GetMethod() const
{
return "textDocument/moniker";
}
std::string Moniker::GetProviderName() const
{
return "TextDocumentMoniker";
}
std::string Moniker::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/text_document/on_type_formatting.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::text_document
{
class OnTypeFormatting : public IRequestProvider
class OnTypeFormatting : public AutoRegisterProvider<OnTypeFormatting, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "textDocument/onTypeFormatting";
static constexpr std::string_view kProviderName = "TextDocumentOnTypeFormatting";
OnTypeFormatting() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::text_document
{
std::string OnTypeFormatting::GetMethod() const
{
return "textDocument/onTypeFormatting";
}
std::string OnTypeFormatting::GetProviderName() const
{
return "TextDocumentOnTypeFormatting";
}
std::string OnTypeFormatting::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/text_document/prepare_call_hierarchy.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::text_document
{
class PrepareCallHierarchy : public IRequestProvider
class PrepareCallHierarchy : public AutoRegisterProvider<PrepareCallHierarchy, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "textDocument/prepareCallHierarchy";
static constexpr std::string_view kProviderName = "TextDocumentPrepareCallHierarchy";
PrepareCallHierarchy() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::text_document
{
std::string PrepareCallHierarchy::GetMethod() const
{
return "textDocument/prepareCallHierarchy";
}
std::string PrepareCallHierarchy::GetProviderName() const
{
return "TextDocumentPrepareCallHierarchy";
}
std::string PrepareCallHierarchy::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/text_document/prepare_rename.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::text_document
{
class PrepareRename : public IRequestProvider
class PrepareRename : public AutoRegisterProvider<PrepareRename, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "textDocument/prepareRename";
static constexpr std::string_view kProviderName = "TextDocumentPrepareRename";
PrepareRename() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::text_document
{
std::string PrepareRename::GetMethod() const
{
return "textDocument/prepareRename";
}
std::string PrepareRename::GetProviderName() const
{
return "TextDocumentPrepareRename";
}
std::string PrepareRename::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/text_document/prepare_type_hierarchy.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::text_document
{
class PrepareTypeHierarchy : public IRequestProvider
class PrepareTypeHierarchy : public AutoRegisterProvider<PrepareTypeHierarchy, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "textDocument/prepareTypeHierarchy";
static constexpr std::string_view kProviderName = "TextDocumentPrepareTypeHierarchy";
PrepareTypeHierarchy() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::text_document
{
std::string PrepareTypeHierarchy::GetMethod() const
{
return "textDocument/prepareTypeHierarchy";
}
std::string PrepareTypeHierarchy::GetProviderName() const
{
return "TextDocumentPrepareTypeHierarchy";
}
std::string PrepareTypeHierarchy::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/text_document/publish_diagnostics.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::text_document
{
class PublishDiagnostics : public INotificationProvider
class PublishDiagnostics : public AutoRegisterProvider<PublishDiagnostics, INotificationProvider>
{
public:
static constexpr std::string_view kMethod = "textDocument/publishDiagnostics";
static constexpr std::string_view kProviderName = "TextDocumentPublishDiagnostics";
PublishDiagnostics() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
void HandleNotification(const protocol::NotificationMessage& notification, ExecutionContext& context) override;
};
}
namespace lsp::provider::text_document
{
std::string PublishDiagnostics::GetMethod() const
{
return "textDocument/publishDiagnostics";
}
std::string PublishDiagnostics::GetProviderName() const
{
return "TextDocumentPublishDiagnostics";
}
void PublishDiagnostics::HandleNotification(const protocol::NotificationMessage& notification, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/text_document/range_formatting.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::text_document
{
class RangeFormatting : public IRequestProvider
class RangeFormatting : public AutoRegisterProvider<RangeFormatting, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "textDocument/rangeFormatting";
static constexpr std::string_view kProviderName = "TextDocumentRangeFormatting";
RangeFormatting() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::text_document
{
std::string RangeFormatting::GetMethod() const
{
return "textDocument/rangeFormatting";
}
std::string RangeFormatting::GetProviderName() const
{
return "TextDocumentRangeFormatting";
}
std::string RangeFormatting::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/text_document/references.cppm
View File

@ -22,13 +22,13 @@ namespace transform = lsp::codec;
export namespace lsp::provider::text_document
{
class References : public IRequestProvider
class References : public AutoRegisterProvider<References, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "textDocument/references";
static constexpr std::string_view kProviderName = "TextDocumentReferences";
References() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
private:
@ -60,15 +60,9 @@ export namespace lsp::provider::text_document
namespace lsp::provider::text_document
{
std::string References::GetMethod() const
{
return "textDocument/references";
}
std::string References::GetProviderName() const
{
return "TextDocumentReferences";
}
std::string References::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

26
lsp-server/src/provider/text_document/rename.cppm
View File

@ -22,13 +22,13 @@ namespace transform = lsp::codec;
export namespace lsp::provider::text_document
{
class Rename : public IRequestProvider
class Rename : public AutoRegisterProvider<Rename, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "textDocument/rename";
static constexpr std::string_view kProviderName = "TextDocumentRename";
Rename() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
private:
@ -160,15 +160,9 @@ export namespace lsp::provider::text_document
namespace lsp::provider::text_document
{
std::string Rename::GetMethod() const
{
return "textDocument/rename";
}
std::string Rename::GetProviderName() const
{
return "TextDocumentRename";
}
std::string Rename::ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context)
{
@ -195,15 +189,7 @@ namespace lsp::provider::text_document
protocol::ResponseMessage response;
response.id = request.id;
if (workspace_edit_opt.has_value())
{
response.result = transform::ToLSPAny(*workspace_edit_opt);
}
else
{
// 返回 null 表示没有需要修改的内容或无法重命名
response.result = std::nullopt;
}
response.result = transform::ToLSPAny(workspace_edit_opt);
std::optional<std::string> json = transform::Serialize(response);
if (!json.has_value())

16
lsp-server/src/provider/text_document/selection_range.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::text_document
{
class SelectionRange : public IRequestProvider
class SelectionRange : public AutoRegisterProvider<SelectionRange, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "textDocument/selectionRange";
static constexpr std::string_view kProviderName = "TextDocumentSelectionRange";
SelectionRange() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::text_document
{
std::string SelectionRange::GetMethod() const
{
return "textDocument/selectionRange";
}
std::string SelectionRange::GetProviderName() const
{
return "TextDocumentSelectionRange";
}
std::string SelectionRange::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

48
lsp-server/src/provider/text_document/semantic_tokens.cppm
View File

@ -13,42 +13,36 @@ import lsp.manager.manager_hub;
export namespace lsp::provider::text_document
{
class SemanticTokensRange : public IRequestProvider
class SemanticTokensRange : public AutoRegisterProvider<SemanticTokensRange, IRequestProvider>
{
public:
std::string GetMethod() const override;
std::string GetProviderName() const override;
static constexpr std::string_view kMethod = "textDocument/semanticTokens/range";
static constexpr std::string_view kProviderName = "TextDocumentSemanticTokensRange";
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
class SemanticTokensFull : public IRequestProvider
class SemanticTokensFull : public AutoRegisterProvider<SemanticTokensFull, IRequestProvider>
{
public:
std::string GetMethod() const override;
std::string GetProviderName() const override;
static constexpr std::string_view kMethod = "textDocument/semanticTokens/full";
static constexpr std::string_view kProviderName = "SemanticTokensFull";
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
class SemanticTokensFullDelta : public IRequestProvider
class SemanticTokensFullDelta : public AutoRegisterProvider<SemanticTokensFullDelta, IRequestProvider>
{
public:
std::string GetMethod() const override;
std::string GetProviderName() const override;
static constexpr std::string_view kMethod = "textDocument/semanticTokens/full/delta";
static constexpr std::string_view kProviderName = "SemanticTokensFullDelta";
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::text_document
{
std::string SemanticTokensRange::GetMethod() const
{
return "textDocument/semanticTokens/range";
}
std::string SemanticTokensRange::GetProviderName() const
{
return "TextDocumentSemanticTokensRange";
}
std::string SemanticTokensRange::ProvideResponse(const protocol::RequestMessage& request,
[[maybe_unused]] ExecutionContext& context)
@ -57,15 +51,9 @@ namespace lsp::provider::text_document
return BuildErrorResponseMessage(request, protocol::ErrorCodes::MethodNotFound, "Semantic tokens range not implemented");
}
std::string SemanticTokensFull::GetMethod() const
{
return "textDocument/semanticTokens/full";
}
std::string SemanticTokensFull::GetProviderName() const
{
return "SemanticTokensFull";
}
std::string SemanticTokensFull::ProvideResponse(const protocol::RequestMessage& request,
[[maybe_unused]] ExecutionContext& context)
@ -74,15 +62,9 @@ namespace lsp::provider::text_document
return BuildErrorResponseMessage(request, protocol::ErrorCodes::MethodNotFound, "Semantic tokens full not implemented");
}
std::string SemanticTokensFullDelta::GetMethod() const
{
return "textDocument/semanticTokens/full/delta";
}
std::string SemanticTokensFullDelta::GetProviderName() const
{
return "SemanticTokensFullDelta";
}
std::string SemanticTokensFullDelta::ProvideResponse(const protocol::RequestMessage& request,
[[maybe_unused]] ExecutionContext& context)

16
lsp-server/src/provider/text_document/signature_help.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::text_document
{
class SignatureHelp : public IRequestProvider
class SignatureHelp : public AutoRegisterProvider<SignatureHelp, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "textDocument/signatureHelp";
static constexpr std::string_view kProviderName = "TextDocumentSignatureHelp";
SignatureHelp() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::text_document
{
std::string SignatureHelp::GetMethod() const
{
return "textDocument/signatureHelp";
}
std::string SignatureHelp::GetProviderName() const
{
return "TextDocumentSignatureHelp";
}
std::string SignatureHelp::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/text_document/type_definition.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::text_document
{
class TypeDefinition : public IRequestProvider
class TypeDefinition : public AutoRegisterProvider<TypeDefinition, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "textDocument/typeDefinition";
static constexpr std::string_view kProviderName = "TextDocumentTypeDefinition";
TypeDefinition() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::text_document
{
std::string TypeDefinition::GetMethod() const
{
return "textDocument/typeDefinition";
}
std::string TypeDefinition::GetProviderName() const
{
return "TextDocumentTypeDefinition";
}
std::string TypeDefinition::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/trace/set_trace.cppm
View File

@ -13,26 +13,20 @@ namespace transform = lsp::codec;
export namespace lsp::provider
{
class SetTrace : public INotificationProvider
class SetTrace : public AutoRegisterProvider<SetTrace, INotificationProvider>
{
public:
std::string GetMethod() const override;
std::string GetProviderName() const override;
static constexpr std::string_view kMethod = "$/setTrace";
static constexpr std::string_view kProviderName = "SetTrace";
void HandleNotification(const protocol::NotificationMessage& notification, ExecutionContext& context) override;
};
}
namespace lsp::provider
{
std::string SetTrace::GetMethod() const
{
return "$/setTrace";
}
std::string SetTrace::GetProviderName() const
{
return "SetTrace";
}
void SetTrace::HandleNotification(const protocol::NotificationMessage& notification, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/type_hierarchy/subtypes.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::type_hierarchy
{
class Subtypes : public IRequestProvider
class Subtypes : public AutoRegisterProvider<Subtypes, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "typeHierarchy/subtypes";
static constexpr std::string_view kProviderName = "WorkspaceSubtypes";
Subtypes() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::type_hierarchy
{
std::string Subtypes::GetMethod() const
{
return "typeHierarchy/subtypes";
}
std::string Subtypes::GetProviderName() const
{
return "WorkspaceSubtypes";
}
std::string Subtypes::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/type_hierarchy/supertypes.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::type_hierarchy
{
class Supertypes : public IRequestProvider
class Supertypes : public AutoRegisterProvider<Supertypes, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "typeHierarchy/supertypes";
static constexpr std::string_view kProviderName = "TypeHierarchySupertypes";
Supertypes() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::type_hierarchy
{
std::string Supertypes::GetMethod() const
{
return "typeHierarchy/supertypes";
}
std::string Supertypes::GetProviderName() const
{
return "TypeHierarchySupertypes";
}
std::string Supertypes::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/window/log_message.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::window
{
class LogMessage : public INotificationProvider
class LogMessage : public AutoRegisterProvider<LogMessage, INotificationProvider>
{
public:
static constexpr std::string_view kMethod = "window/logMessage";
static constexpr std::string_view kProviderName = "WindowLogMessage";
LogMessage() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
void HandleNotification(const protocol::NotificationMessage& notification, ExecutionContext& context) override;
};
}
namespace lsp::provider::window
{
std::string LogMessage::GetMethod() const
{
return "window/logMessage";
}
std::string LogMessage::GetProviderName() const
{
return "WindowLogMessage";
}
void LogMessage::HandleNotification(const protocol::NotificationMessage& notification, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/window/show_document.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::window
{
class ShowDocument : public IRequestProvider
class ShowDocument : public AutoRegisterProvider<ShowDocument, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "window/showDocument";
static constexpr std::string_view kProviderName = "WindowShowDocument";
ShowDocument() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::window
{
std::string ShowDocument::GetMethod() const
{
return "window/showDocument";
}
std::string ShowDocument::GetProviderName() const
{
return "WindowShowDocument";
}
std::string ShowDocument::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/window/show_message.cppm
View File

@ -12,13 +12,13 @@ import lsp.provider.base.interface;
export namespace lsp::provider::window
{
class ShowMessage : public INotificationProvider
class ShowMessage : public AutoRegisterProvider<ShowMessage, INotificationProvider>
{
public:
static constexpr std::string_view kMethod = "window/showMessage";
static constexpr std::string_view kProviderName = "WindowShowMessage";
ShowMessage() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
void HandleNotification(const protocol::NotificationMessage& notification,
[[maybe_unused]] ExecutionContext& context) override;
};
@ -26,15 +26,9 @@ export namespace lsp::provider::window
namespace lsp::provider::window
{
std::string ShowMessage::GetMethod() const
{
return "window/showMessage";
}
std::string ShowMessage::GetProviderName() const
{
return "WindowShowMessage";
}
void ShowMessage::HandleNotification(const protocol::NotificationMessage& notification,
[[maybe_unused]] ExecutionContext& context)

16
lsp-server/src/provider/window/show_message_request.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::window
{
class ShowMessageRequest : public IRequestProvider
class ShowMessageRequest : public AutoRegisterProvider<ShowMessageRequest, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "window/showMessageRequest";
static constexpr std::string_view kProviderName = "WindowShowMessageRequest";
ShowMessageRequest() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::window
{
std::string ShowMessageRequest::GetMethod() const
{
return "window/showMessageRequest";
}
std::string ShowMessageRequest::GetProviderName() const
{
return "WindowShowMessageRequest";
}
std::string ShowMessageRequest::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/window/work_done_progress_create.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::window
{
class WorkDoneProgressCreate : public IRequestProvider
class WorkDoneProgressCreate : public AutoRegisterProvider<WorkDoneProgressCreate, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "window/workDoneProgress/create";
static constexpr std::string_view kProviderName = "WindowWorkDoneProgressCreate";
WorkDoneProgressCreate() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::window
{
std::string WorkDoneProgressCreate::GetMethod() const
{
return "window/workDoneProgress/create";
}
std::string WorkDoneProgressCreate::GetProviderName() const
{
return "WindowWorkDoneProgressCreate";
}
std::string WorkDoneProgressCreate::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/workspace/apply_edit.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::workspace
{
class ApplyEdit : public IRequestProvider
class ApplyEdit : public AutoRegisterProvider<ApplyEdit, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "workspace/applyEdit";
static constexpr std::string_view kProviderName = "WorkspaceApplyEdit";
ApplyEdit() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::workspace
{
std::string ApplyEdit::GetMethod() const
{
return "workspace/applyEdit";
}
std::string ApplyEdit::GetProviderName() const
{
return "WorkspaceApplyEdit";
}
std::string ApplyEdit::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/workspace/code_lens_refresh.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::workspace
{
class CodeLensRefresh : public IRequestProvider
class CodeLensRefresh : public AutoRegisterProvider<CodeLensRefresh, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "workspace/codeLens/refresh";
static constexpr std::string_view kProviderName = "WorkspaceCodeLensRefresh";
CodeLensRefresh() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::workspace
{
std::string CodeLensRefresh::GetMethod() const
{
return "workspace/codeLens/refresh";
}
std::string CodeLensRefresh::GetProviderName() const
{
return "WorkspaceCodeLensRefresh";
}
std::string CodeLensRefresh::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/workspace/configuration.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::workspace
{
class Configuration : public IRequestProvider
class Configuration : public AutoRegisterProvider<Configuration, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "workspace/configuration";
static constexpr std::string_view kProviderName = "WorkspaceConfiguration";
Configuration() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::workspace
{
std::string Configuration::GetMethod() const
{
return "workspace/configuration";
}
std::string Configuration::GetProviderName() const
{
return "WorkspaceConfiguration";
}
std::string Configuration::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/workspace/diagnostic.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::workspace
{
class Diagnostic : public IRequestProvider
class Diagnostic : public AutoRegisterProvider<Diagnostic, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "workspace/diagnostic";
static constexpr std::string_view kProviderName = "WorkspaceDiagnostic";
Diagnostic() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::workspace
{
std::string Diagnostic::GetMethod() const
{
return "workspace/diagnostic";
}
std::string Diagnostic::GetProviderName() const
{
return "WorkspaceDiagnostic";
}
std::string Diagnostic::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/workspace/diagnostic_refresh.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::workspace
{
class DiagnosticRefresh : public IRequestProvider
class DiagnosticRefresh : public AutoRegisterProvider<DiagnosticRefresh, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "workspace/diagnostic/refresh";
static constexpr std::string_view kProviderName = "WorkspaceDiagnosticRefresh";
DiagnosticRefresh() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::workspace
{
std::string DiagnosticRefresh::GetMethod() const
{
return "workspace/diagnostic/refresh";
}
std::string DiagnosticRefresh::GetProviderName() const
{
return "WorkspaceDiagnosticRefresh";
}
std::string DiagnosticRefresh::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/workspace/did_change_configuration.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::workspace
{
class DidChangeConfiguration : public INotificationProvider
class DidChangeConfiguration : public AutoRegisterProvider<DidChangeConfiguration, INotificationProvider>
{
public:
static constexpr std::string_view kMethod = "workspace/didChangeConfiguration";
static constexpr std::string_view kProviderName = "WorkspaceDidChangeConfiguration";
DidChangeConfiguration() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
void HandleNotification(const protocol::NotificationMessage& notification, ExecutionContext& context) override;
};
}
namespace lsp::provider::workspace
{
std::string DidChangeConfiguration::GetMethod() const
{
return "workspace/didChangeConfiguration";
}
std::string DidChangeConfiguration::GetProviderName() const
{
return "WorkspaceDidChangeConfiguration";
}
void DidChangeConfiguration::HandleNotification(const protocol::NotificationMessage& notification, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/workspace/did_change_watched_files.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::workspace
{
class DidChangeWatchedFiles : public INotificationProvider
class DidChangeWatchedFiles : public AutoRegisterProvider<DidChangeWatchedFiles, INotificationProvider>
{
public:
static constexpr std::string_view kMethod = "workspace/didChangeWatchedFiles";
static constexpr std::string_view kProviderName = "WorkspaceDidChangeWatchedFiles";
DidChangeWatchedFiles() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
void HandleNotification(const protocol::NotificationMessage& notification, ExecutionContext& context) override;
};
}
namespace lsp::provider::workspace
{
std::string DidChangeWatchedFiles::GetMethod() const
{
return "workspace/didChangeWatchedFiles";
}
std::string DidChangeWatchedFiles::GetProviderName() const
{
return "WorkspaceDidChangeWatchedFiles";
}
void DidChangeWatchedFiles::HandleNotification(const protocol::NotificationMessage& notification, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/workspace/did_change_workspace_folders.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::workspace
{
class DidChangeWorkspaceFolders : public INotificationProvider
class DidChangeWorkspaceFolders : public AutoRegisterProvider<DidChangeWorkspaceFolders, INotificationProvider>
{
public:
static constexpr std::string_view kMethod = "workspace/didChangeWorkspaceFolders";
static constexpr std::string_view kProviderName = "WorkspaceDidChangeWorkspaceFolders";
DidChangeWorkspaceFolders() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
void HandleNotification(const protocol::NotificationMessage& notification, ExecutionContext& context) override;
};
}
namespace lsp::provider::workspace
{
std::string DidChangeWorkspaceFolders::GetMethod() const
{
return "workspace/didChangeWorkspaceFolders";
}
std::string DidChangeWorkspaceFolders::GetProviderName() const
{
return "WorkspaceDidChangeWorkspaceFolders";
}
void DidChangeWorkspaceFolders::HandleNotification(const protocol::NotificationMessage& notification, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/workspace/did_create_files.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::workspace
{
class DidCreateFiles : public INotificationProvider
class DidCreateFiles : public AutoRegisterProvider<DidCreateFiles, INotificationProvider>
{
public:
static constexpr std::string_view kMethod = "workspace/didCreateFiles";
static constexpr std::string_view kProviderName = "WorkspaceDidCreateFiles";
DidCreateFiles() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
void HandleNotification(const protocol::NotificationMessage& notification, ExecutionContext& context) override;
};
}
namespace lsp::provider::workspace
{
std::string DidCreateFiles::GetMethod() const
{
return "workspace/didCreateFiles";
}
std::string DidCreateFiles::GetProviderName() const
{
return "WorkspaceDidCreateFiles";
}
void DidCreateFiles::HandleNotification(const protocol::NotificationMessage& notification, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/workspace/did_delete_files.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::workspace
{
class DidDeleteFiles : public INotificationProvider
class DidDeleteFiles : public AutoRegisterProvider<DidDeleteFiles, INotificationProvider>
{
public:
static constexpr std::string_view kMethod = "workspace/didDeleteFiles";
static constexpr std::string_view kProviderName = "WorkspaceDidDeleteFiles";
DidDeleteFiles() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
void HandleNotification(const protocol::NotificationMessage& notification, ExecutionContext& context) override;
};
}
namespace lsp::provider::workspace
{
std::string DidDeleteFiles::GetMethod() const
{
return "workspace/didDeleteFiles";
}
std::string DidDeleteFiles::GetProviderName() const
{
return "WorkspaceDidDeleteFiles";
}
void DidDeleteFiles::HandleNotification(const protocol::NotificationMessage& notification, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/workspace/did_rename_files.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::workspace
{
class DidRenameFiles : public INotificationProvider
class DidRenameFiles : public AutoRegisterProvider<DidRenameFiles, INotificationProvider>
{
public:
static constexpr std::string_view kMethod = "workspace/didRenameFiles";
static constexpr std::string_view kProviderName = "WorkspaceDidRenameFiles";
DidRenameFiles() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
void HandleNotification(const protocol::NotificationMessage& notification, ExecutionContext& context) override;
};
}
namespace lsp::provider::workspace
{
std::string DidRenameFiles::GetMethod() const
{
return "workspace/didRenameFiles";
}
std::string DidRenameFiles::GetProviderName() const
{
return "WorkspaceDidRenameFiles";
}
void DidRenameFiles::HandleNotification(const protocol::NotificationMessage& notification, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/workspace/execute_command.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::workspace
{
class ExecuteCommand : public IRequestProvider
class ExecuteCommand : public AutoRegisterProvider<ExecuteCommand, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "workspace/executeCommand";
static constexpr std::string_view kProviderName = "WorkspaceExecuteCommand";
ExecuteCommand() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::workspace
{
std::string ExecuteCommand::GetMethod() const
{
return "workspace/executeCommand";
}
std::string ExecuteCommand::GetProviderName() const
{
return "WorkspaceExecuteCommand";
}
std::string ExecuteCommand::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/workspace/inlay_hint_refresh.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::workspace
{
class InlayHintRefresh : public IRequestProvider
class InlayHintRefresh : public AutoRegisterProvider<InlayHintRefresh, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "workspace/inlayHint/refresh";
static constexpr std::string_view kProviderName = "WorkspaceInlayHintRefresh";
InlayHintRefresh() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::workspace
{
std::string InlayHintRefresh::GetMethod() const
{
return "workspace/inlayHint/refresh";
}
std::string InlayHintRefresh::GetProviderName() const
{
return "WorkspaceInlayHintRefresh";
}
std::string InlayHintRefresh::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/workspace/inline_value_refresh.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::workspace
{
class InlineValueRefresh : public IRequestProvider
class InlineValueRefresh : public AutoRegisterProvider<InlineValueRefresh, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "workspace/inlineValue/refresh";
static constexpr std::string_view kProviderName = "WorkspaceInlineValueRefresh";
InlineValueRefresh() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::workspace
{
std::string InlineValueRefresh::GetMethod() const
{
return "workspace/inlineValue/refresh";
}
std::string InlineValueRefresh::GetProviderName() const
{
return "WorkspaceInlineValueRefresh";
}
std::string InlineValueRefresh::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/workspace/semantic_tokens_refresh.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::workspace
{
class SemanticTokensRefresh : public IRequestProvider
class SemanticTokensRefresh : public AutoRegisterProvider<SemanticTokensRefresh, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "workspace/semanticTokens/refresh";
static constexpr std::string_view kProviderName = "WorkspaceSemanticTokensRefresh";
SemanticTokensRefresh() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::workspace
{
std::string SemanticTokensRefresh::GetMethod() const
{
return "workspace/semanticTokens/refresh";
}
std::string SemanticTokensRefresh::GetProviderName() const
{
return "WorkspaceSemanticTokensRefresh";
}
std::string SemanticTokensRefresh::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

10
lsp-server/src/provider/workspace/symbol.cppm
View File

@ -11,13 +11,13 @@ import lsp.protocol;
export namespace lsp::provider::workspace
{
class Symbol : public IRequestProvider
class Symbol : public AutoRegisterProvider<Symbol, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "workspace/symbol";
static constexpr std::string_view kProviderName = "WorkSpaceSymbol";
Symbol() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request,
[[maybe_unused]] ExecutionContext& context) override;
};
@ -25,9 +25,9 @@ export namespace lsp::provider::workspace
namespace lsp::provider::workspace
{
std::string Symbol::GetMethod() const { return "workspace/symbol"; }
std::string Symbol::GetProviderName() const { return "WorkSpaceSymbol"; }
std::string Symbol::ProvideResponse(const protocol::RequestMessage& request,
[[maybe_unused]] ExecutionContext& context)

16
lsp-server/src/provider/workspace/will_create_files.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::workspace
{
class WillCreateFiles : public IRequestProvider
class WillCreateFiles : public AutoRegisterProvider<WillCreateFiles, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "workspace/willCreateFiles";
static constexpr std::string_view kProviderName = "WorkspaceWillCreateFiles";
WillCreateFiles() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::workspace
{
std::string WillCreateFiles::GetMethod() const
{
return "workspace/willCreateFiles";
}
std::string WillCreateFiles::GetProviderName() const
{
return "WorkspaceWillCreateFiles";
}
std::string WillCreateFiles::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/workspace/will_delete_files.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::workspace
{
class WillDeleteFiles : public IRequestProvider
class WillDeleteFiles : public AutoRegisterProvider<WillDeleteFiles, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "workspace/willDeleteFiles";
static constexpr std::string_view kProviderName = "WorkspaceWillDeleteFiles";
WillDeleteFiles() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::workspace
{
std::string WillDeleteFiles::GetMethod() const
{
return "workspace/willDeleteFiles";
}
std::string WillDeleteFiles::GetProviderName() const
{
return "WorkspaceWillDeleteFiles";
}
std::string WillDeleteFiles::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/workspace/will_rename_files.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::workspace
{
class WillRenameFiles : public IRequestProvider
class WillRenameFiles : public AutoRegisterProvider<WillRenameFiles, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "workspace/willRenameFiles";
static constexpr std::string_view kProviderName = "WorkspaceWillRenameFiles";
WillRenameFiles() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::workspace
{
std::string WillRenameFiles::GetMethod() const
{
return "workspace/willRenameFiles";
}
std::string WillRenameFiles::GetProviderName() const
{
return "WorkspaceWillRenameFiles";
}
std::string WillRenameFiles::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/workspace/workspace_folders.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::workspace
{
class WorkspaceFolders : public IRequestProvider
class WorkspaceFolders : public AutoRegisterProvider<WorkspaceFolders, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "workspace/workspaceFolders";
static constexpr std::string_view kProviderName = "WorkspaceWorkspaceFolders";
WorkspaceFolders() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::workspace
{
std::string WorkspaceFolders::GetMethod() const
{
return "workspace/workspaceFolders";
}
std::string WorkspaceFolders::GetProviderName() const
{
return "WorkspaceWorkspaceFolders";
}
std::string WorkspaceFolders::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

16
lsp-server/src/provider/workspace_symbol/resolve.cppm
View File

@ -12,28 +12,22 @@ import lsp.provider.base.interface;
export namespace lsp::provider::workspace_symbol
{
class Resolve : public IRequestProvider
class Resolve : public AutoRegisterProvider<Resolve, IRequestProvider>
{
public:
static constexpr std::string_view kMethod = "workspaceSymbol/resolve";
static constexpr std::string_view kProviderName = "WorkspaceSymbResolve";
Resolve() = default;
std::string GetMethod() const override;
std::string GetProviderName() const override;
std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& context) override;
};
}
namespace lsp::provider::workspace_symbol
{
std::string Resolve::GetMethod() const
{
return "workspaceSymbol/resolve";
}
std::string Resolve::GetProviderName() const
{
return "WorkspaceSymbResolve";
}
std::string Resolve::ProvideResponse(const protocol::RequestMessage& request, [[maybe_unused]] ExecutionContext& context)
{

20
lsp-server/test/run_lsp_json_tests.py
View File

@ -128,9 +128,23 @@ def validate_responses(by_id: dict[str, dict]) -> None:
else:
assert_error_code(resolved, -32603, "completion resolve response")
assert_error_code(by_id["4"], -32601, "definition response")
assert_error_code(by_id["5"], -32601, "rename response")
assert_error_code(by_id["6"], -32601, "references response")
definition = by_id["4"]
assert_has_key(definition, "result", "definition response")
definition_result = definition["result"]
if definition_result is not None and not isinstance(definition_result, (dict, list)):
raise RuntimeError("definition response should be a location, list of locations, or null")
rename = by_id["5"]
assert_has_key(rename, "result", "rename response")
rename_result = rename["result"]
if rename_result is not None and not isinstance(rename_result, dict):
raise RuntimeError("rename response should be a workspace edit or null")
references = by_id["6"]
assert_has_key(references, "result", "references response")
references_result = references["result"]
if not isinstance(references_result, list):
raise RuntimeError("references response should be a list of locations")
shutdown = by_id["7"]
if "error" in shutdown: