✨ feat(provider): add compile-time registry

lsp-server/src/core/server.cppm

@@ -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.manifest;
-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;
 
 namespace transform = lsp::codec;
 
@@ -416,20 +405,7 @@ namespace lsp::core
 
         spdlog::info("Registering LSP providers...");
 
-        provider::RegisterProvider<provider::Initialize>(dispatcher_);
+        provider::RegisterAllProviders(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_);
 
         spdlog::info("Registered {} LSP providers", dispatcher_.GetAllSupportedMethods().size());
     }

lsp-server/src/provider/base/interface.cppm

@@ -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);
+        }
+    };
 }

lsp-server/src/provider/base/registry.cppm

@@ -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 T>
-    template<typename ProviderClass>
+    concept AutoRegisterableProvider = HasMethod<T> && HasProviderName<T> &&
-    typename std::enable_if_t<std::is_base_of_v<core::IRequestProvider, ProviderClass>>
+                                       requires {
-    RegisterProvider(core::RequestDispatcher& dispatcher)
+                                           { T::kAutoRegister } -> std::convertible_to<bool>;
+                                       } &&
+                                       (std::derived_from<T, core::IRequestProvider> ||
+                                        std::derived_from<T, core::INotificationProvider>);
+
+    template<AutoRegisterableProvider... Providers>
+    consteval bool HasDuplicateMethods()
+    {
+        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<AutoRegisterableProvider... Providers>
+    class ProviderRegistry
+    {
+    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>)
             {
-        auto provider = std::make_shared<ProviderClass>();
                 dispatcher.RegisterRequestProvider(provider);
-        spdlog::debug("Registered request provider [{}] for [{}]", provider->GetProviderName(), provider->GetMethod());
             }
-
+            else if constexpr (std::derived_from<Provider, core::INotificationProvider>)
-    // 注册通知处理器的模板函数
-    template<typename ProviderClass>
-    typename std::enable_if_t<std::is_base_of_v<core::INotificationProvider, ProviderClass>>
-    RegisterProvider(core::RequestDispatcher& dispatcher)
             {
-        auto provider = std::make_shared<ProviderClass>();
                 dispatcher.RegisterNotificationProvider(provider);
-        spdlog::debug("Registered notification provider [{}] for [{}]", provider->GetProviderName(), provider->GetMethod());
             }
 
+            spdlog::debug("Registered provider [{}] for [{}]",
+                          Provider::kProviderName, Provider::kMethod);
+        }
+    };
 }

lsp-server/src/provider/call_hierarchy/incoming_calls.cppm

@@ -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)
     {

lsp-server/src/provider/call_hierarchy/outgoing_calls.cppm

@@ -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)
     {

lsp-server/src/provider/cancel_request/cancel_request.cppm

@@ -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)
     {

lsp-server/src/provider/client/register_capability.cppm

@@ -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())

lsp-server/src/provider/client/unregister_capability.cppm

@@ -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())

lsp-server/src/provider/code_action/resolve.cppm

@@ -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)
     {

lsp-server/src/provider/code_lens/resolve.cppm

@@ -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)
     {

lsp-server/src/provider/completion_item/resolve.cppm

@@ -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)

lsp-server/src/provider/document_link/resolve.cppm

@@ -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)
     {

lsp-server/src/provider/exit/exit.cppm

@@ -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)
     {

lsp-server/src/provider/initialize/initialize.cppm

@@ -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)
     {

lsp-server/src/provider/initialized/initialized.cppm

@@ -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)
     {

lsp-server/src/provider/inlay_hint/resolve.cppm

@@ -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)
     {

lsp-server/src/provider/manifest.cppm

@@ -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);
+    }
+}

lsp-server/src/provider/shutdown/shutdown.cppm

@@ -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)
     {

lsp-server/src/provider/telemetry/event.cppm

@@ -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)
     {

lsp-server/src/provider/text_document/code_action.cppm

@@ -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)
     {

lsp-server/src/provider/text_document/code_lens.cppm

@@ -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)

lsp-server/src/provider/text_document/color_presentation.cppm

@@ -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)

lsp-server/src/provider/text_document/completion.cppm

@@ -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;
+        static constexpr std::string_view kMethod = "textDocument/completion";
-        std::string GetProviderName() const override;
+        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)
     {

lsp-server/src/provider/text_document/definition.cppm

@@ -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);
-        {
-            response.result = transform::ToLSPAny(*location);
-        }
-        else
-        {
-            response.result = std::nullopt;
-        }
 
         std::optional<std::string> json = transform::Serialize(response);
         if (!json.has_value())

lsp-server/src/provider/text_document/diagnostic.cppm

@@ -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)
     {

lsp-server/src/provider/text_document/did_change.cppm

@@ -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)
     {

lsp-server/src/provider/text_document/did_close.cppm

@@ -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)
     {

lsp-server/src/provider/text_document/did_open.cppm

@@ -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)
     {

lsp-server/src/provider/text_document/document_color.cppm

@@ -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)
     {

lsp-server/src/provider/text_document/document_highlight.cppm

@@ -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)
     {

lsp-server/src/provider/text_document/document_link.cppm

@@ -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)
     {

lsp-server/src/provider/text_document/document_symbol.cppm

@@ -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)
     {

lsp-server/src/provider/text_document/folding_range.cppm

@@ -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)
     {

lsp-server/src/provider/text_document/formatting.cppm

@@ -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)
     {

lsp-server/src/provider/text_document/hover.cppm

@@ -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)
     {

lsp-server/src/provider/text_document/implementation.cppm

@@ -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)
     {

lsp-server/src/provider/text_document/inlay_hint.cppm

@@ -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)
     {

lsp-server/src/provider/text_document/inline_value.cppm

@@ -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)
     {

lsp-server/src/provider/text_document/linked_editing_range.cppm

@@ -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)
     {

lsp-server/src/provider/text_document/moniker.cppm

@@ -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)
     {

lsp-server/src/provider/text_document/on_type_formatting.cppm

@@ -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)
     {

lsp-server/src/provider/text_document/prepare_call_hierarchy.cppm

@@ -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)
     {

lsp-server/src/provider/text_document/prepare_rename.cppm

@@ -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)
     {

lsp-server/src/provider/text_document/prepare_type_hierarchy.cppm

@@ -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)
     {

lsp-server/src/provider/text_document/publish_diagnostics.cppm

@@ -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)
     {

lsp-server/src/provider/text_document/range_formatting.cppm

@@ -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)
     {

lsp-server/src/provider/text_document/references.cppm

@@ -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)
     {

lsp-server/src/provider/text_document/rename.cppm

@@ -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);
-        {
-            response.result = transform::ToLSPAny(*workspace_edit_opt);
-        }
-        else
-        {
-            // 返回 null 表示没有需要修改的内容或无法重命名
-            response.result = std::nullopt;
-        }
 
         std::optional<std::string> json = transform::Serialize(response);
         if (!json.has_value())

lsp-server/src/provider/text_document/selection_range.cppm

@@ -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)
     {

lsp-server/src/provider/text_document/semantic_tokens.cppm

@@ -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;
+        static constexpr std::string_view kMethod = "textDocument/semanticTokens/range";
-        std::string GetProviderName() const override;
+        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;
+        static constexpr std::string_view kMethod = "textDocument/semanticTokens/full";
-        std::string GetProviderName() const override;
+        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;
+        static constexpr std::string_view kMethod = "textDocument/semanticTokens/full/delta";
-        std::string GetProviderName() const override;
+        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)

lsp-server/src/provider/text_document/signature_help.cppm

@@ -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)
     {

lsp-server/src/provider/text_document/type_definition.cppm

@@ -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)
     {

lsp-server/src/provider/trace/set_trace.cppm

@@ -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;
+        static constexpr std::string_view kMethod = "$/setTrace";
-        std::string GetProviderName() const override;
+        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)
     {

lsp-server/src/provider/type_hierarchy/subtypes.cppm

@@ -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)
     {

lsp-server/src/provider/type_hierarchy/supertypes.cppm

@@ -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)
     {

lsp-server/src/provider/window/log_message.cppm

@@ -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)
     {

lsp-server/src/provider/window/show_document.cppm

@@ -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)
     {

lsp-server/src/provider/window/show_message.cppm

@@ -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)

lsp-server/src/provider/window/show_message_request.cppm

@@ -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)
     {

lsp-server/src/provider/window/work_done_progress_create.cppm

@@ -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)
     {

lsp-server/src/provider/workspace/apply_edit.cppm

@@ -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)
     {

lsp-server/src/provider/workspace/code_lens_refresh.cppm

@@ -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)
     {

lsp-server/src/provider/workspace/configuration.cppm

@@ -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)
     {

lsp-server/src/provider/workspace/diagnostic.cppm

@@ -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)
     {

lsp-server/src/provider/workspace/diagnostic_refresh.cppm

@@ -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)
     {

lsp-server/src/provider/workspace/did_change_configuration.cppm

@@ -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)
     {

lsp-server/src/provider/workspace/did_change_watched_files.cppm

@@ -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)
     {

lsp-server/src/provider/workspace/did_change_workspace_folders.cppm

@@ -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)
     {

lsp-server/src/provider/workspace/did_create_files.cppm

@@ -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)
     {

lsp-server/src/provider/workspace/did_delete_files.cppm

@@ -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)
     {

lsp-server/src/provider/workspace/did_rename_files.cppm

@@ -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)
     {

lsp-server/src/provider/workspace/execute_command.cppm

@@ -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)
     {

lsp-server/src/provider/workspace/inlay_hint_refresh.cppm

@@ -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)
     {

lsp-server/src/provider/workspace/inline_value_refresh.cppm

@@ -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)
     {

lsp-server/src/provider/workspace/semantic_tokens_refresh.cppm

@@ -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)
     {

lsp-server/src/provider/workspace/symbol.cppm

@@ -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)

lsp-server/src/provider/workspace/will_create_files.cppm

@@ -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)
     {

lsp-server/src/provider/workspace/will_delete_files.cppm

@@ -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)
     {

lsp-server/src/provider/workspace/will_rename_files.cppm

@@ -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)
     {

lsp-server/src/provider/workspace/workspace_folders.cppm

@@ -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)
     {

lsp-server/src/provider/workspace_symbol/resolve.cppm

@@ -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)
     {

lsp-server/test/run_lsp_json_tests.py

@@ -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")
+    definition = by_id["4"]
-    assert_error_code(by_id["5"], -32601, "rename response")
+    assert_has_key(definition, "result", "definition response")
-    assert_error_code(by_id["6"], -32601, "references 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: