lsp-server first commit

2025-06-23 20:29:48 +08:00
parent cbcff7d1b4
commit 4f5bf9d781
43 changed files with 1851 additions and 11 deletions
@@ -0,0 +1,23 @@
+
+#pragma once
+#include <string>
+#include "../../lsp/lsp_types.hpp"
+
+namespace lsp::providers
+{
+
+    // LSP请求提供者接口基类
+    class ILspProvider
+    {
+    public:
+        virtual ~ILspProvider() = default;
+
+        // 处理LSP请求
+        virtual nlohmann::json ProvideResponse(const LspRequest& request) = 0;
+        // 获取支持的LSP方法名
+        virtual std::string GetMethod() const = 0;
+        // 获取提供者名称（用于日志和调试）
+        virtual std::string GetProviderName() const = 0;
+    };
+
+}
@@ -0,0 +1,27 @@
+#include "./provider_registry.hpp"
+#include "../initialize/initialize_provider.hpp"
+#include "../initialized/initialized_provider.hpp"
+#include "../text_document/did_open_provider.hpp"
+#include "../text_document/did_change_provider.hpp"
+#include "../text_document/completion_provider.hpp"
+#include "../trace/set_trace_provider.hpp"
+#include "../../lsp/logger.hpp"
+
+namespace lsp::providers
+{
+
+    void RegisterAllProviders(RequestDispatcher& dispatcher)
+    {
+        log::Info("Registering LSP providers...");
+
+        RegisterProvider<initialize::InitializeProvider>(dispatcher);
+        RegisterProvider<initialized::InitializedProvider>(dispatcher);
+        RegisterProvider<text_document::DidOpenProvider>(dispatcher);
+        RegisterProvider<text_document::DidChangeProvider>(dispatcher);
+        RegisterProvider<text_document::CompletionProvider>(dispatcher);
+        RegisterProvider<trace::SetTraceProvider>(dispatcher);
+
+        log::Info("Successfully registered ", dispatcher.GetSupportedMethods().size(), " LSP providers");
+    }
+
+}
@@ -0,0 +1,30 @@
+#pragma once
+#include "../../lsp/dispacther.hpp"
+#include "./provider_interface.hpp"
+#include "../../lsp/logger.hpp"
+
+namespace lsp::providers
+{
+
+    // 模板函数：注册provider
+    template<typename ProviderClass>
+    void RegisterProvider(RequestDispatcher& dispatcher)
+    {
+        static_assert(std::is_base_of_v<ILspProvider, ProviderClass>,
+                      "Provider must inherit from ILspProvider");
+
+        auto provider = std::make_shared<ProviderClass>();
+
+        log::Info("Registering ", provider->GetProviderName(), " for method: ", provider->GetMethod());
+
+        dispatcher.RegisterProvider(
+            provider->GetMethod(),
+            [provider](const LspRequest& request) -> nlohmann::json {
+                return provider->ProvideResponse(request);
+            });
+    }
+
+    // 批量注册provider
+    void RegisterAllProviders(RequestDispatcher& dispatcher);
+
+}
@@ -0,0 +1,55 @@
+#include "./initialize_provider.hpp"
+#include "../../lsp/logger.hpp"
+
+namespace lsp::providers::initialize
+{
+
+    nlohmann::json InitializeProvider::ProvideResponse(const LspRequest& request)
+    {
+        nlohmann::json response;
+        response["jsonrpc"] = "2.0";
+        response["id"] = request.id;
+        response["result"] = BuildInitializeResult();
+        log::Debug("InitializeProvider: Providing response for method '", request.method, "' with id ", request.id);
+        return response;
+    }
+
+    inline std::string InitializeProvider::GetMethod() const
+    {
+        return "initialize";
+    }
+
+    inline std::string InitializeProvider::GetProviderName() const
+    {
+        return "InitializeProvider";
+    }
+
+    nlohmann::json InitializeProvider::BuildInitializeResult()
+    {
+        nlohmann::json result;
+        result["capabilities"] = BuildServerCapabilities();
+        result["serverInfo"] = BuildServerInfo();
+        return result;
+    }
+
+    nlohmann::json InitializeProvider::BuildServerCapabilities()
+    {
+        nlohmann::json capabilities;
+        capabilities["textDocumentSync"] = nlohmann::json();
+        capabilities["textDocumentSync"]["change"] = 2;
+        capabilities["textDocumentSync"]["openClose"] = true;
+        capabilities["textDocumentSync"]["save"] = true;
+        capabilities["completionProvider"] = nlohmann::json();
+        capabilities["completionProvider"]["resolveProvider"] = false;
+        return capabilities;
+    }
+
+    nlohmann::json InitializeProvider::BuildServerInfo()
+    {
+        nlohmann::json serverInfo;
+        serverInfo["name"] = "TSL Language Server";
+        serverInfo["version"] = "1.0.0";
+        return serverInfo;
+    }
+
+}
@@ -0,0 +1,20 @@
+#pragma once
+#include "../base/provider_interface.hpp"
+#include <nlohmann/json.hpp>
+
+namespace lsp::providers::initialize
+{
+    class InitializeProvider : public ILspProvider
+    {
+    public:
+        InitializeProvider() = default;
+        nlohmann::json ProvideResponse(const LspRequest& request) override;
+        std::string GetMethod() const override;
+        std::string GetProviderName() const override;
+
+    private:
+        nlohmann::json BuildServerCapabilities();
+        nlohmann::json BuildServerInfo();
+        nlohmann::json BuildInitializeResult();
+    };
+}
@@ -0,0 +1,23 @@
+#include "./initialized_provider.hpp"
+#include "../../lsp/logger.hpp"
+
+namespace lsp::providers::initialized
+{
+
+    nlohmann::json InitializedProvider::ProvideResponse(const LspRequest& request)
+    {
+        log::Debug("InitializedProvider: Providing response for method '", request.method, "' with id ", request.id);
+        return nlohmann::json();
+    }
+
+    inline std::string InitializedProvider::GetMethod() const
+    {
+        return "initialized";
+    }
+
+    inline std::string InitializedProvider::GetProviderName() const
+    {
+        return "InitializedProvider";
+    }
+
+}
@@ -0,0 +1,14 @@
+#pragma once
+#include "../base/provider_interface.hpp"
+
+namespace lsp::providers::initialized
+{
+    class InitializedProvider : public ILspProvider
+    {
+    public:
+        InitializedProvider() = default;
+        nlohmann::json ProvideResponse(const LspRequest& request) override;
+        std::string GetMethod() const override;
+        std::string GetProviderName() const override;
+    };
+}
@@ -0,0 +1,212 @@
+#include "./completion_provider.hpp"
+#include "../../lsp/logger.hpp"
+
+namespace lsp::providers::text_document
+{
+    nlohmann::json CompletionProvider::ProvideResponse(const LspRequest& request)
+    {
+        log::Debug("CompletionProvider: Providing response for method '", request.method, "' with id ", request.id);
+        try
+        {
+            nlohmann::json response = BuildCompletionResponse(request);
+            return response;
+        }
+        catch (const std::exception& e)
+        {
+            log::Error(GetProviderName(), ": Error - ", e.what());
+            nlohmann::json errorResponse = CreateErrorResponse(request.id, -32603, e.what());
+            return errorResponse;
+        }
+    }
+
+    inline std::string CompletionProvider::GetMethod() const
+    {
+        return "textDocument/completion";
+    }
+
+    inline std::string CompletionProvider::GetProviderName() const
+    {
+        return "CompletionProvider";
+    }
+
+    nlohmann::json CompletionProvider::BuildCompletionResponse(const LspRequest& request)
+    {
+        nlohmann::json response;
+        response["jsonrpc"] = "2.0";
+        response["id"] = request.id;
+
+        // 验证必要参数
+        if (!request.params.contains("textDocument") || !request.params.contains("position"))
+        {
+            log::Warn(GetProviderName(), ": Missing required parameters in request");
+            // 返回空补全列表而非错误
+            response["result"] = BuildCompletionResult({});
+            return response;
+        }
+
+        // 提取参数
+        std::string uri = ExtractDocumentUri(request.params);
+        nlohmann::json position = ExtractPosition(request.params);
+        std::string prefix = ExtractPrefix(request.params);
+
+        log::Verbose(
+            GetProviderName(), ": Processing completion request for URI='", uri, "', Position=", position.dump(), ", Prefix='", prefix, "'");
+
+        // 收集所有补全项
+        std::vector<CompletionItem> allItems;
+
+        // 添加关键字补全
+        auto keywordItems = ProvideKeywordCompletions(prefix);
+        allItems.insert(allItems.end(), keywordItems.begin(), keywordItems.end());
+
+        // 添加上下文相关补全
+        auto contextualItems = ProvideContextualCompletions(uri, position, prefix);
+        allItems.insert(allItems.end(), contextualItems.begin(), contextualItems.end());
+
+        // 构建响应
+        response["result"] = BuildCompletionResult(allItems);
+
+        log::Info(GetProviderName(), ": Provided ", allItems.size(), " completion items");
+
+        return response;
+    }
+
+    nlohmann::json CompletionProvider::BuildCompletionResult(const std::vector<CompletionItem>& items)
+    {
+        nlohmann::json result;
+        result["isIncomplete"] = false; // 表示这是完整的补全列表
+        result["items"] = nlohmann::json::array();
+
+        for (const auto& item : items)
+            result["items"].push_back(CompletionItemToJson(item));
+
+        return result;
+    }
+
+    std::string CompletionProvider::ExtractDocumentUri(const nlohmann::json& params)
+    {
+        if (params.contains("textDocument") && params["textDocument"].contains("uri"))
+        {
+            std::string uri = params["textDocument"]["uri"].get<std::string>();
+            log::Verbose("ExtractDocumentUri: Found URI: ", uri);
+            return uri;
+        }
+        log::Warn("ExtractDocumentUri: No URI found in parameters");
+        return "";
+    }
+
+    nlohmann::json CompletionProvider::ExtractPosition(const nlohmann::json& params)
+    {
+        if (params.contains("position"))
+        {
+            nlohmann::json pos = params["position"];
+            log::Verbose("ExtractPosition: Found position: ", pos.dump());
+            return pos;
+        }
+        // 返回默认位置
+        nlohmann::json defaultPos;
+        defaultPos["line"] = 0;
+        defaultPos["character"] = 0;
+        log::Warn("ExtractPosition: No position found in parameters, using default (0, 0)");
+        return defaultPos;
+    }
+
+    std::string CompletionProvider::ExtractPrefix(const nlohmann::json& params)
+    {
+        // 方法1: 直接从参数中获取prefix
+        if (params.contains("prefix"))
+        {
+            std::string prefix = params["prefix"].get<std::string>();
+            log::Verbose("ExtractPrefix: Found prefix form params: '", prefix, "'");
+            return prefix;
+        }
+
+        // 方法2: 从context中获取prefix
+        if (params.contains("context") && params["context"].contains("prefix"))
+        {
+            std::string prefix = params["context"]["prefix"].get<std::string>();
+            log::Verbose("ExtractPrefix: Found prefix form params: '", prefix, "'");
+            return prefix;
+        }
+
+        // TODO: 理想情况下，应该从文档内容和位置计算前缀
+        // 这需要维护文档内容的状态
+        log::Verbose("ExtractPrefix: No prefix found, returning empty string");
+        return "";
+    }
+
+    std::vector<CompletionItem> CompletionProvider::ProvideKeywordCompletions(const std::string& prefix)
+    {
+        std::vector<CompletionItem> items;
+
+        // 从tsl_keywords_获取补全项
+        auto tslItems = tsl_keywords_.GetCompletionItems(prefix);
+
+        for (const auto& tslItem : tslItems)
+        {
+            CompletionItem item;
+            item.label = tslItem.label;
+            item.kind = CompletionItemKind::kKeyword; // LSP CompletionItemKind.Keyword
+            item.detail = "TSL Keyword";
+            item.documentation = "TSL language keyword";
+            item.insert_text = tslItem.label;
+
+            items.push_back(item);
+        }
+        log::Debug("ProvideKeywordCompletions: Found ", items.size(), " keyword completions");
+        return items;
+    }
+
+    std::vector<CompletionItem> CompletionProvider::ProvideContextualCompletions(
+        const std::string& uri,
+        const nlohmann::json& position,
+        const std::string& prefix)
+    {
+        log::Debug("ProvideContextualCompletions: Processing contextual completions for URI: ", uri);
+        std::vector<CompletionItem> items;
+
+        // TODO: 基于上下文提供补全
+        // 这里可以添加：
+        // - 变量名补全
+        // - 函数名补全
+        // - 类型补全
+        // - 属性补全等
+        log::Debug("ProvideContextualCompletions: Found ", items.size(), " contextual completions");
+        return items;
+    }
+
+    nlohmann::json CompletionProvider::CompletionItemToJson(const CompletionItem& item)
+    {
+        nlohmann::json json;
+
+        json["label"] = item.label;
+        json["kind"] = item.kind;
+
+        if (!item.detail)
+            json["detail"] = item.detail;
+
+        if (!item.documentation)
+            json["documentation"] = item.documentation;
+
+        if (!item.insert_text)
+            json["insertText"] = item.insert_text;
+
+        return json;
+    }
+
+    nlohmann::json CompletionProvider::CreateErrorResponse(const nlohmann::json& id, int code, const std::string& message)
+    {
+        nlohmann::json response;
+        response["jsonrpc"] = "2.0";
+        response["id"] = id;
+
+        nlohmann::json error;
+        error["code"] = code;
+        error["message"] = GetProviderName() + ": " + message;
+
+        response["error"] = error;
+        log::Error("CreateErrorResponse: Created error response with code ", code, " and message: ", message);
+        return response;
+    }
+
+}
@@ -0,0 +1,49 @@
+#pragma once
+#include <string>
+#include <vector>
+#include "../base/provider_interface.hpp"
+#include "../../lsp/lsp_types.hpp"
+#include "../../language/tsl_keywords.hpp"
+
+namespace lsp::providers::text_document
+{
+    class CompletionProvider : public ILspProvider
+    {
+    public:
+        CompletionProvider() = default;
+
+        nlohmann::json ProvideResponse(const LspRequest& request) override;
+        std::string GetMethod() const override;
+        std::string GetProviderName() const override;
+
+    private:
+        // 构建完整的补全响应
+        nlohmann::json BuildCompletionResponse(const LspRequest& request);
+
+        // 构建补全结果
+        nlohmann::json BuildCompletionResult(const std::vector<CompletionItem>& items);
+
+        // 从请求中提取文档信息
+        std::string ExtractDocumentUri(const nlohmann::json& params);
+        nlohmann::json ExtractPosition(const nlohmann::json& params);
+
+        // 获取补全前缀
+        std::string ExtractPrefix(const nlohmann::json& params);
+
+        // 提供不同类型的补全
+        std::vector<CompletionItem> ProvideKeywordCompletions(const std::string& prefix);
+        std::vector<CompletionItem> ProvideContextualCompletions(
+            const std::string& uri,
+            const nlohmann::json& position,
+            const std::string& prefix);
+
+        // 将CompletionItem转换为JSON
+        nlohmann::json CompletionItemToJson(const CompletionItem& item);
+
+        // 创建错误响应
+        nlohmann::json CreateErrorResponse(const nlohmann::json& id, int code, const std::string& message);
+
+    private:
+        tsl::TslKeywords tsl_keywords_;
+    };
+}
@@ -0,0 +1,63 @@
+#include "./did_change_provider.hpp"
+#include "./did_open_provider.hpp"
+#include "../../lsp/logger.hpp"
+
+namespace lsp::providers::text_document
+{
+
+    nlohmann::json DidChangeProvider::ProvideResponse(const LspRequest& request)
+    {
+        log::Debug("DidChangeProvider: Providing response for method '", request.method, "' with id ", request.id);
+        try
+        {
+            auto params = request.params;
+            if (params.contains("textDocument") && params.contains("contentChanges"))
+            {
+                auto textDoc = params["textDocument"];
+                std::string uri = textDoc["uri"];
+                auto changes = params["contentChanges"];
+
+                ApplyContentChanges(uri, changes);
+            }
+        }
+        catch (const std::exception& e)
+        {
+            // 处理错误，但不返回错误响应，因为这是通知
+        }
+
+        // 通知不需要响应
+        return nlohmann::json();
+    }
+
+    inline std::string DidChangeProvider::GetMethod() const
+    {
+        return "textDocument/didChange";
+    }
+
+    inline std::string DidChangeProvider::GetProviderName() const
+    {
+        return "DidChangeProvider";
+    }
+
+    void DidChangeProvider::ApplyContentChanges(const std::string& uri, const nlohmann::json& changes)
+    {
+        // 简化实现：假设是全文替换
+        for (const auto& change : changes)
+        {
+            if (change.contains("text"))
+            {
+                // 如果没有range，表示全文替换
+                if (!change.contains("range"))
+                {
+                    DidOpenProvider::document_store[uri] = change["text"];
+                }
+                else
+                {
+                    // 这里可以实现增量更新，现在简化为全文替换
+                    DidOpenProvider::document_store[uri] = change["text"];
+                }
+            }
+        }
+    }
+
+}
@@ -0,0 +1,17 @@
+#pragma once
+#include "../base/provider_interface.hpp"
+
+namespace lsp::providers::text_document
+{
+    class DidChangeProvider : public ILspProvider
+    {
+    public:
+        DidChangeProvider() = default;
+        nlohmann::json ProvideResponse(const LspRequest& request) override;
+        std::string GetMethod() const override;
+        std::string GetProviderName() const override;
+
+    private:
+        void ApplyContentChanges(const std::string& uri, const nlohmann::json& changes);
+    };
+}
@@ -0,0 +1,48 @@
+#include "./did_open_provider.hpp"
+#include "../../lsp/logger.hpp"
+
+namespace lsp::providers::text_document
+{
+    std::unordered_map<std::string, std::string> DidOpenProvider::document_store;
+
+    nlohmann::json DidOpenProvider::ProvideResponse(const LspRequest& request)
+    {
+        log::Debug("DidOpenProvider: Providing response for method '", request.method, "' with id ", request.id);
+        try
+        {
+            auto params = request.params;
+            if (params.contains("textDocument"))
+            {
+                auto textDoc = params["textDocument"];
+                std::string uri = textDoc["uri"];
+                std::string text = textDoc["text"];
+
+                // 存储文档内容
+                document_store[uri] = text;
+            }
+        }
+        catch (const std::exception& e)
+        {
+            // 处理错误，但不返回错误响应，因为这是通知
+        }
+        // 通知不需要响应
+        return nlohmann::json();
+    }
+
+    inline std::string DidOpenProvider::GetMethod() const
+    {
+        return "textDocument/didOpen";
+    }
+
+    inline std::string DidOpenProvider::GetProviderName() const
+    {
+        return "DidOpenProvider";
+    }
+
+    std::string DidOpenProvider::GetDocumentContent(const std::string& uri)
+    {
+        auto it = document_store.find(uri);
+        return (it != document_store.end()) ? it->second : "";
+    }
+
+}
@@ -0,0 +1,21 @@
+#pragma once
+#include <unordered_map>
+#include "../base/provider_interface.hpp"
+
+namespace lsp::providers::text_document
+{
+    class DidOpenProvider : public ILspProvider
+    {
+    public:
+        DidOpenProvider() = default;
+        nlohmann::json ProvideResponse(const LspRequest& request) override;
+        std::string GetMethod() const override;
+        std::string GetProviderName() const override;
+
+        // 静态方法用于获取文档内容
+        static std::string GetDocumentContent(const std::string& uri);
+
+    public:
+        static std::unordered_map<std::string, std::string> document_store;
+    };
+}
@@ -0,0 +1,37 @@
+#include "./set_trace_provider.hpp"
+
+namespace lsp::providers::trace
+{
+
+    nlohmann::json SetTraceProvider::ProvideResponse(const LspRequest& request)
+    {
+        try
+        {
+            auto params = request.params;
+            if (params.contains("value"))
+            {
+                std::string trace_value = params["value"];
+                // 这里可以设置跟踪级别
+                // 例如：设置全局跟踪变量
+            }
+        }
+        catch (const std::exception& e)
+        {
+            // 处理错误
+        }
+
+        // 通知不需要响应
+        return nlohmann::json();
+    }
+
+    inline std::string SetTraceProvider::GetMethod() const
+    {
+        return "$/setTrace";
+    }
+
+    inline std::string SetTraceProvider::GetProviderName() const
+    {
+        return "SetTraceProvider";
+    }
+
+}
@@ -0,0 +1,14 @@
+#pragma once
+#include "../base/provider_interface.hpp"
+
+namespace lsp::providers::trace
+{
+    class SetTraceProvider : public ILspProvider
+    {
+    public:
+        SetTraceProvider() = default;
+        nlohmann::json ProvideResponse(const LspRequest& request) override;
+        std::string GetMethod() const override;
+        std::string GetProviderName() const override;
+    };
+}