refactor

lsp-server/src/provider/base/provider_interface.cpp

@@ -1,10 +1,9 @@
-#include <spdlog/spdlog.h>
 #include "./provider_interface.hpp"
 
 namespace lsp::providers
 {
 
-    std::string ILspProvider::BuildErrorResponseMessage(const protocol::RequestMessage& request, protocol::ErrorCode code, const std::string& message)
+    std::string IRequestProvider::BuildErrorResponseMessage(const protocol::RequestMessage& request, protocol::ErrorCode code, const std::string& message)
     {
         protocol::ResponseMessage response;
         response.id = request.id;
@@ -23,18 +22,4 @@ namespace lsp::providers
         return json;
     }
 
-    void ILifecycleAwareProvider::SetLifecycleCallback(LifecycleCallback callback)
-    {
-        lifecycle_callback_ = std::move(callback);
-    }
-
-    void ILifecycleAwareProvider::NotifyLifecycleEvent(ServerLifecycleEvent event)
-    {
-        if (lifecycle_callback_)
-        {
-            lifecycle_callback_(event);
-            spdlog::debug("Provider {} triggered event: {}", GetProviderName(), static_cast<int>(event));
-        }
-    }
-
 }

lsp-server/src/provider/base/provider_interface.hpp

@@ -1,6 +1,8 @@
 #pragma once
 #include <string>
+#include <spdlog/spdlog.h>
 #include "../../protocol/protocol.hpp"
+#include "../../scheduler/request_scheduler.hpp"
 
 namespace lsp::providers
 {
@@ -15,37 +17,57 @@ namespace lsp::providers
 
     using LifecycleCallback = std::function<void(ServerLifecycleEvent)>;
 
+    class ProviderContext;
+
     // LSP请求提供者接口基类
-    class ILspProvider
+    class IProvider
     {
     public:
-        virtual ~ILspProvider() = default;
+        virtual ~IProvider() = default;
 
-        // 处理LSP请求
-        virtual std::string ProvideResponse(const protocol::RequestMessage& request) = 0;
         // 获取支持的LSP方法名
         virtual std::string GetMethod() const = 0;
         // 获取提供者名称（用于日志和调试）
         virtual std::string GetProviderName() const = 0;
+    };
 
+    // LSP 请求处理器接口
+    class IRequestProvider : public IProvider
+    {
+    public:
+        virtual ~IRequestProvider() = default;
+
+        // 处理LSP请求
+        virtual std::string ProvideResponse(const protocol::RequestMessage& request, ProviderContext& context) = 0;
         static std::string BuildErrorResponseMessage(const protocol::RequestMessage& request, protocol::ErrorCode code, const std::string& message);
     };
 
-    // 生命周期感知的 Provider 接口
-    class ILifecycleAwareProvider : public ILspProvider
+    // LSP 通知处理器接口
+    class INotificationProvider : public IProvider
     {
     public:
-        virtual ~ILifecycleAwareProvider() = default;
+        virtual ~INotificationProvider() = default;
 
-        // 设置生命周期回调
-        void SetLifecycleCallback(LifecycleCallback callback);
-
-    protected:
-        // 触发生命周期事件
-        void NotifyLifecycleEvent(ServerLifecycleEvent event);
-
-    private:
-        LifecycleCallback lifecycle_callback_;
+        // 处理LSP通知
+        virtual void HandleNotification(const protocol::NotificationMessage& notification, ProviderContext& context) = 0;
     };
 
+    class ProviderContext
+    {
+    public:
+        ProviderContext(scheduler::RequestScheduler* scheduler, LifecycleCallback lifecycle_callback) :
+            scheduler_(scheduler), lifecycle_callback_(lifecycle_callback) {}
+
+        scheduler::RequestScheduler* GetScheduler() const { return scheduler_; }
+
+        void TriggerLifecycleEvent(ServerLifecycleEvent event) const
+        {
+            if (lifecycle_callback_)
+                lifecycle_callback_(event);
+        }
+
+    private:
+        scheduler::RequestScheduler* scheduler_;
+        LifecycleCallback lifecycle_callback_;
+    };
 }

lsp-server/src/provider/base/provider_registry.cpp

@@ -7,11 +7,13 @@
 #include "../text_document/completion_provider.hpp"
 #include "../trace/set_trace_provider.hpp"
 #include "../shutdown/shutdown_provider.hpp"
+#include "../cancel_request/cancel_request_provider.hpp"
+#include "../exit/exit_provider.hpp"
 
 namespace lsp::providers
 {
 
-    void RegisterAllProviders(RequestDispatcher& dispatcher)
+    void RegisterAllProviders(core::RequestDispatcher& dispatcher)
     {
         spdlog::info("Registering LSP providers...");
 
@@ -20,10 +22,12 @@ namespace lsp::providers
         RegisterProvider<text_document::DidOpenProvider>(dispatcher);
         RegisterProvider<text_document::DidChangeProvider>(dispatcher);
         RegisterProvider<text_document::CompletionProvider>(dispatcher);
-        RegisterProvider<trace::SetTraceProvider>(dispatcher);
+        RegisterProvider<set_trace::SetTraceProvider>(dispatcher);
         RegisterProvider<shutdown::ShutdownProvider>(dispatcher);
+        RegisterProvider<cancel_request::CancelRequestProvider>(dispatcher);
+        RegisterProvider<exit::ExitProvider>(dispatcher);
 
-        spdlog::info("Successfully registered {} LSP providers", dispatcher.GetSupportedMethods().size());
+        spdlog::info("Successfully registered {} LSP providers", dispatcher.GetAllSupportedMethods().size());
     }
 
 }

lsp-server/src/provider/base/provider_registry.hpp

@@ -1,24 +1,32 @@
 #pragma once
 #include <spdlog/spdlog.h>
-#include "../../lsp/dispacther.hpp"
+#include <type_traits>
+#include "../../core/dispacther.hpp"
 #include "./provider_interface.hpp"
 
 namespace lsp::providers
 {
-    // 模板函数：注册provider
+    // 注册请求处理器的模板函数
     template<typename ProviderClass>
-    void RegisterProvider(RequestDispatcher& dispatcher)
+    typename std::enable_if_t<std::is_base_of_v<IRequestProvider, ProviderClass>>
+    RegisterProvider(core::RequestDispatcher& dispatcher)
     {
-        static_assert(std::is_base_of_v<ILspProvider, ProviderClass>,
-                      "Provider must inherit from ILspProvider");
-
         auto provider = std::make_shared<ProviderClass>();
-        dispatcher.RegisterProvider(provider);
+        dispatcher.RegisterRequestProvider(provider);
+        spdlog::info("Registered request provider '{}' for method: {}", provider->GetProviderName(), provider->GetMethod());
+    }
 
-        spdlog::info("Registering {} for method: {}", provider->GetProviderName(), provider->GetMethod());
+    // 注册通知处理器的模板函数
+    template<typename ProviderClass>
+    typename std::enable_if_t<std::is_base_of_v<INotificationProvider, ProviderClass>>
+    RegisterProvider(core::RequestDispatcher& dispatcher)
+    {
+        auto provider = std::make_shared<ProviderClass>();
+        dispatcher.RegisterNotificationProvider(provider);
+        spdlog::info("Registered notification provider '{}' for method: {}", provider->GetProviderName(), provider->GetMethod());
     }
 
     // 批量注册provider
-    void RegisterAllProviders(RequestDispatcher& dispatcher);
+    void RegisterAllProviders(core::RequestDispatcher& dispatcher);
 
 }

lsp-server/src/provider/cancel_request/cancel_request_provider.cpp

@@ -0,0 +1,34 @@
+#include "./cancel_request_provider.hpp"
+
+namespace lsp::providers::cancel_request
+{
+    std::string CancelRequestProvider::GetMethod() const
+    {
+        return "$/cancelRequest";
+    }
+
+    std::string CancelRequestProvider::GetProviderName() const
+    {
+        return "CancelRequestProvider";
+    }
+
+    void CancelRequestProvider::HandleNotification(const protocol::NotificationMessage& notification, ProviderContext& context)
+    {
+        try
+        {
+            auto params = transform::As<protocol::CancelParams>(notification.params.value());
+            std::string id_to_cancel = transform::debug::GetIdString(params.id);
+            spdlog::info("Processing cancel request for ID: {}", id_to_cancel);
+
+            if (auto* scheduler = context.GetScheduler())
+            {
+                bool cancelled = scheduler->Cancel(id_to_cancel);
+                spdlog::info("Cancel request {} result: {}", id_to_cancel, cancelled ? "success" : "not found");
+            }
+        }
+        catch (const std::exception& e)
+        {
+            spdlog::error("Error handling cancel request: {}", e.what());
+        }
+    }
+}

lsp-server/src/provider/cancel_request/cancel_request_provider.hpp

@@ -0,0 +1,16 @@
+#pragma once
+#include <spdlog/spdlog.h>
+#include "../base/provider_interface.hpp"
+#include "../../scheduler/request_scheduler.hpp"
+#include "../../protocol/transform/facade.hpp"
+
+namespace lsp::providers::cancel_request
+{
+    class CancelRequestProvider : public INotificationProvider
+    {
+    public:
+        std::string GetMethod() const override;
+        std::string GetProviderName() const override;
+        void HandleNotification(const protocol::NotificationMessage& notification, ProviderContext& context) override;
+    };
+}

lsp-server/src/provider/exit/exit_provider.cpp

@@ -0,0 +1,33 @@
+#include "./exit_provider.hpp"
+
+namespace lsp::providers::exit
+{
+
+    std::string ExitProvider::GetMethod() const
+    {
+        return "exit";
+    }
+
+    std::string ExitProvider::GetProviderName() const
+    {
+        return "ExitProvider";
+    }
+
+    void ExitProvider::HandleNotification(const protocol::NotificationMessage& notification, ProviderContext& context)
+    {
+        // static_cast<void>(context);
+        spdlog::debug("ExitProvider: Providing response for method {}", notification.method);
+        spdlog::info("Exit notification received");
+
+        // 触发生命周期事件
+        context.TriggerLifecycleEvent(ServerLifecycleEvent::kShuttingDown);
+
+        // 给一些时间完成清理
+        std::this_thread::sleep_for(std::chrono::milliseconds(100));
+
+        context.TriggerLifecycleEvent(ServerLifecycleEvent::kShutdown);
+
+        std::exit(0);
+    }
+
+}

lsp-server/src/provider/exit/exit_provider.hpp

@@ -0,0 +1,13 @@
+#pragma once
+#include "../base/provider_interface.hpp"
+
+namespace lsp::providers::exit
+{
+    class ExitProvider : public INotificationProvider
+    {
+    public:
+        std::string GetMethod() const override;
+        std::string GetProviderName() const override;
+        void HandleNotification(const protocol::NotificationMessage& notification, ProviderContext& context) override;
+    };
+}

lsp-server/src/provider/initialize/initialize_provider.cpp

@@ -4,7 +4,17 @@
 
 namespace lsp::providers::initialize
 {
-    std::string InitializeProvider::ProvideResponse(const protocol::RequestMessage& request)
+    std::string InitializeProvider::GetMethod() const
+    {
+        return "initialize";
+    }
+
+    std::string InitializeProvider::GetProviderName() const
+    {
+        return "InitializeProvider";
+    }
+
+    std::string InitializeProvider::ProvideResponse(const protocol::RequestMessage& request, ProviderContext& context)
     {
         spdlog::debug("InitializeProvider: Providing response for method {}", request.method);
         protocol::ResponseMessage response;
@@ -14,23 +24,13 @@ namespace lsp::providers::initialize
         auto ec = glz::write_json(response, json);
         if (ec)
         {
-            NotifyLifecycleEvent(ServerLifecycleEvent::kInitializeFailed);
+            context.TriggerLifecycleEvent(ServerLifecycleEvent::kInitializeFailed);
             return BuildErrorResponseMessage(request, protocol::ErrorCode::kInternalError, "Internal error");
         }
-        NotifyLifecycleEvent(ServerLifecycleEvent::kInitialized);
+        context.TriggerLifecycleEvent(ServerLifecycleEvent::kInitialized);
         return json;
     }
 
-    std::string InitializeProvider::GetMethod() const
-    {
-        return "initialize";
-    }
-
-    std::string InitializeProvider::GetProviderName() const
-    {
-        return "InitializeProvider";
-    }
-
     protocol::InitializeResult InitializeProvider::BuildInitializeResult()
     {
         protocol::InitializeResult result;

lsp-server/src/provider/initialize/initialize_provider.hpp

@@ -4,11 +4,11 @@
 namespace lsp::providers::initialize
 {
     using namespace lsp;
-    class InitializeProvider : public ILifecycleAwareProvider
+    class InitializeProvider : public IRequestProvider
     {
     public:
         InitializeProvider() = default;
-        std::string ProvideResponse(const protocol::RequestMessage& request) override;
+        std::string ProvideResponse(const protocol::RequestMessage& request, ProviderContext& context) override;
         std::string GetMethod() const override;
         std::string GetProviderName() const override;
 

lsp-server/src/provider/initialized/initialized_provider.cpp

@@ -4,15 +4,6 @@
 namespace lsp::providers::initialized
 {
 
-    std::string InitializedProvider::ProvideResponse(const protocol::RequestMessage& request)
-    {
-        spdlog::debug("InitializeProvider: Providing response for method {}", request.method);
-        std::string json;
-        glz::obj empty_obj{}; // glaze的对象类型
-        auto ec = glz::write_json(empty_obj, json);
-        return ec ? BuildErrorResponseMessage(request, protocol::ErrorCode::kInternalError, "Internal error") : json;
-    }
-
     std::string InitializedProvider::GetMethod() const
     {
         return "initialized";
@@ -23,4 +14,10 @@ namespace lsp::providers::initialized
         return "InitializedProvider";
     }
 
+    void InitializedProvider::HandleNotification(const protocol::NotificationMessage& notification, ProviderContext& context)
+    {
+        static_cast<void>(context); // 如果不需要上下文，可以忽略
+        spdlog::debug("InitializeProvider: Providing response for method {}", notification.method);
+    }
+
 }

lsp-server/src/provider/initialized/initialized_provider.hpp

@@ -3,12 +3,12 @@
 
 namespace lsp::providers::initialized
 {
-    class InitializedProvider : public ILifecycleAwareProvider
+    class InitializedProvider : public INotificationProvider
     {
     public:
         InitializedProvider() = default;
-        std::string ProvideResponse(const protocol::RequestMessage& request) override;
         std::string GetMethod() const override;
         std::string GetProviderName() const override;
+        void HandleNotification(const protocol::NotificationMessage& notification, ProviderContext& context) override;
     };
 }

lsp-server/src/provider/shutdown/shutdown_provider.cpp

@@ -4,14 +4,24 @@
 
 namespace lsp::providers::shutdown
 {
-    std::string ShutdownProvider::ProvideResponse(const protocol::RequestMessage& request)
+    std::string ShutdownProvider::GetMethod() const
+    {
+        return "shutdown";
+    }
+
+    std::string ShutdownProvider::GetProviderName() const
+    {
+        return "ShutdownProvider";
+    }
+
+    std::string ShutdownProvider::ProvideResponse(const protocol::RequestMessage& request, ProviderContext& context)
     {
         spdlog::debug("ShutdownProvider: Providing response for method {}", request.method);
 
         try
         {
             // 触发关闭事件
-            NotifyLifecycleEvent(ServerLifecycleEvent::kShuttingDown);
+            context.TriggerLifecycleEvent(ServerLifecycleEvent::kShuttingDown);
 
             // 构建响应 - shutdown 返回 null
             protocol::ResponseMessage response;
@@ -34,13 +44,4 @@ namespace lsp::providers::shutdown
         }
     }
 
-    std::string ShutdownProvider::GetMethod() const
-    {
-        return "shutdown";
-    }
-
-    std::string ShutdownProvider::GetProviderName() const
-    {
-        return "ShutdownProvider";
-    }
 }

lsp-server/src/provider/shutdown/shutdown_provider.hpp

@@ -3,13 +3,13 @@
 
 namespace lsp::providers::shutdown
 {
-    class ShutdownProvider : public ILifecycleAwareProvider
+    class ShutdownProvider : public IRequestProvider
     {
     public:
         ShutdownProvider() = default;
-        
-        std::string ProvideResponse(const protocol::RequestMessage& request) override;
+
         std::string GetMethod() const override;
         std::string GetProviderName() const override;
+        std::string ProvideResponse(const protocol::RequestMessage& request, ProviderContext& context) override;
     };
 }

lsp-server/src/provider/text_document/completion_provider.cpp

@@ -4,13 +4,25 @@
 
 namespace lsp::providers::text_document
 {
-    std::string CompletionProvider::ProvideResponse(const protocol::RequestMessage& request)
+    std::string CompletionProvider::GetMethod() const
     {
+        return "textDocument/completion";
+    }
+
+    std::string CompletionProvider::GetProviderName() const
+    {
+        return "CompletionProvider";
+    }
+
+    std::string CompletionProvider::ProvideResponse(const protocol::RequestMessage& request, ProviderContext& context)
+    {
+        static_cast<void>(context);
         spdlog::debug("CompletionProvider: Providing response for method {}", request.method);
 
         try {
             // 验证请求是否包含参数
-            if (!request.params.has_value()) {
+            if (!request.params.has_value())
+            {
                 spdlog::warn("{}: Missing params in request", GetProviderName());
                 return BuildErrorResponseMessage(request, protocol::ErrorCode::kInvalidParams, "Missing params");
             }
@@ -42,15 +54,6 @@ namespace lsp::providers::text_document
         }
     }
 
-    std::string CompletionProvider::GetMethod() const
-    {
-        return "textDocument/completion";
-    }
-
-    std::string CompletionProvider::GetProviderName() const
-    {
-        return "CompletionProvider";
-    }
 
     protocol::CompletionList CompletionProvider::BuildCompletionResponse(const protocol::CompletionParams& params)
     {

lsp-server/src/provider/text_document/completion_provider.hpp

@@ -7,14 +7,14 @@
 
 namespace lsp::providers::text_document
 {
-    class CompletionProvider : public ILspProvider
+    class CompletionProvider : public IRequestProvider
     {
     public:
         CompletionProvider() = default;
 
-        std::string ProvideResponse(const protocol::RequestMessage& request) override;
         std::string GetMethod() const override;
         std::string GetProviderName() const override;
+        std::string ProvideResponse(const protocol::RequestMessage& request, ProviderContext& context) override;
 
     private:
         // 构建完整的补全响应

lsp-server/src/provider/text_document/did_change_provider.cpp

@@ -1,19 +1,9 @@
 #include <spdlog/spdlog.h>
 #include "./did_change_provider.hpp"
-#include "./did_open_provider.hpp"
 
 namespace lsp::providers::text_document
 {
 
-    std::string DidChangeProvider::ProvideResponse(const protocol::RequestMessage& request)
-    {
-        spdlog::debug("DidChangeProvider: Providing response for method {}", request.method);
-        std::string json;
-        glz::obj empty_obj{}; // glaze的对象类型
-        auto ec = glz::write_json(empty_obj, json);
-        return ec ? BuildErrorResponseMessage(request, protocol::ErrorCode::kInternalError, "Internal error") : json;
-    }
-
     std::string DidChangeProvider::GetMethod() const
     {
         return "textDocument/didChange";
@@ -24,4 +14,10 @@ namespace lsp::providers::text_document
         return "DidChangeProvider";
     }
 
+    void DidChangeProvider::HandleNotification(const protocol::NotificationMessage& notification, ProviderContext& context)
+    {
+        static_cast<void>(context);
+        spdlog::debug("DidChangeProvider: Providing response for method {}", notification.method);
+    }
+
 }

lsp-server/src/provider/text_document/did_change_provider.hpp

@@ -3,12 +3,12 @@
 
 namespace lsp::providers::text_document
 {
-    class DidChangeProvider : public ILspProvider
+    class DidChangeProvider : public INotificationProvider
     {
     public:
         DidChangeProvider() = default;
-        std::string ProvideResponse(const protocol::RequestMessage& request) override;
         std::string GetMethod() const override;
         std::string GetProviderName() const override;
+        void HandleNotification(const protocol::NotificationMessage& notification, ProviderContext& context) override;
     };
 }

lsp-server/src/provider/text_document/did_open_provider.cpp

@@ -3,15 +3,6 @@
 
 namespace lsp::providers::text_document
 {
-    std::string DidOpenProvider::ProvideResponse(const protocol::RequestMessage& request)
-    {
-        spdlog::debug("DidOpenProvider: Providing response for method {}", request.method);
-        std::string json;
-        glz::obj empty_obj{}; // glaze的对象类型
-        auto ec = glz::write_json(empty_obj, json);
-        return ec ? BuildErrorResponseMessage(request, protocol::ErrorCode::kInternalError, "Internal error") : json;
-    }
-
     std::string DidOpenProvider::GetMethod() const
     {
         return "textDocument/didOpen";
@@ -22,4 +13,10 @@ namespace lsp::providers::text_document
         return "DidOpenProvider";
     }
 
+    void DidOpenProvider::HandleNotification(const protocol::NotificationMessage& notification, ProviderContext& context)
+    {
+        static_cast<void>(context);
+        spdlog::debug("DidOpenProvider: Providing response for method {}", notification.method);
+    }
+
 }

lsp-server/src/provider/text_document/did_open_provider.hpp

@@ -4,12 +4,12 @@
 
 namespace lsp::providers::text_document
 {
-    class DidOpenProvider : public ILspProvider
+    class DidOpenProvider : public INotificationProvider
     {
     public:
         DidOpenProvider() = default;
-        std::string ProvideResponse(const protocol::RequestMessage& request) override;
         std::string GetMethod() const override;
         std::string GetProviderName() const override;
+        void HandleNotification(const protocol::NotificationMessage& notification, ProviderContext& context) override;
     };
 }

lsp-server/src/provider/trace/set_trace_provider.cpp

@@ -1,18 +1,8 @@
 #include <spdlog/spdlog.h>
 #include "./set_trace_provider.hpp"
 
-namespace lsp::providers::trace
+namespace lsp::providers::set_trace
 {
-
-    std::string SetTraceProvider::ProvideResponse(const protocol::RequestMessage& request)
-    {
-        spdlog::debug("SetTraceProvider: Providing response for method {}", request.method);
-        std::string json;
-        glz::obj empty_obj{}; // glaze的对象类型
-        auto ec = glz::write_json(empty_obj, json);
-        return ec ? BuildErrorResponseMessage(request, protocol::ErrorCode::kInternalError, "Internal error") : json;
-    }
-
     std::string SetTraceProvider::GetMethod() const
     {
         return "$/setTrace";
@@ -23,4 +13,10 @@ namespace lsp::providers::trace
         return "SetTraceProvider";
     }
 
+    void SetTraceProvider::HandleNotification(const protocol::NotificationMessage& notification, ProviderContext& context)
+    {
+        static_cast<void>(context);
+        spdlog::debug("SetTraceProvider: Providing response for method {}", notification.method);
+    }
+
 }

lsp-server/src/provider/trace/set_trace_provider.hpp

@@ -1,14 +1,14 @@
 #pragma once
 #include "../base/provider_interface.hpp"
 
-namespace lsp::providers::trace
+namespace lsp::providers::set_trace
 {
-    class SetTraceProvider : public ILspProvider
+    class SetTraceProvider : public INotificationProvider
     {
     public:
         SetTraceProvider() = default;
-        std::string ProvideResponse(const protocol::RequestMessage& request) override;
         std::string GetMethod() const override;
         std::string GetProviderName() const override;
+        void HandleNotification(const protocol::NotificationMessage& notification, ProviderContext& context) override;
     };
 }