remove lsp-server from master
This commit is contained in:
parent
696618ff1d
commit
1344255977
|
|
@ -1,102 +0,0 @@
|
|||
cmake_minimum_required(VERSION 4.0)
|
||||
project(tsl-server)
|
||||
|
||||
set(CMAKE_CXX_STANDARD 23)
|
||||
set(CMAKE_CXX_STANDARD_REQUIRED ON)
|
||||
|
||||
message(STATUS "CMAKE_CXX_COMPILER_ID: ${CMAKE_CXX_COMPILER_ID}")
|
||||
message(STATUS "CMAKE_SYSTEM_NAME: ${CMAKE_SYSTEM_NAME}")
|
||||
message(STATUS "CMAKE_BUILD_TYPE: ${CMAKE_BUILD_TYPE}")
|
||||
|
||||
# 设置默认构建类型
|
||||
if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
|
||||
set(CMAKE_BUILD_TYPE
|
||||
"Release"
|
||||
CACHE STRING "Build type" FORCE)
|
||||
set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release"
|
||||
"MinSizeRel" "RelWithDebInfo")
|
||||
endif()
|
||||
|
||||
if(MSVC)
|
||||
add_compile_options(/W4 /permissive- /Zc:__cplusplus /utf-8)
|
||||
set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
|
||||
else()
|
||||
add_compile_options(-Wall -Wextra -Wpedantic)
|
||||
endif()
|
||||
|
||||
# MinGW/MSYS2 静态链接
|
||||
if(MINGW)
|
||||
add_link_options(-static -static-libgcc -static-libstdc++)
|
||||
endif()
|
||||
|
||||
# Linux 静态链接
|
||||
if(UNIX AND NOT APPLE)
|
||||
add_link_options(-static-libgcc -static-libstdc++)
|
||||
find_package(Threads REQUIRED)
|
||||
endif()
|
||||
|
||||
if(DEFINED VCPKG_DIR)
|
||||
if(NOT DEFINED CMAKE_TOOLCHAIN_FILE)
|
||||
set(CMAKE_TOOLCHAIN_FILE
|
||||
${VCPKG_DIR}/scripts/buildsystems/vcpkg.cmake
|
||||
CACHE PATH "")
|
||||
endif()
|
||||
message(STATUS ">>> Vcpkg: ${CMAKE_TOOLCHAIN_FILE}")
|
||||
|
||||
if(NOT DEFINED VCPKG_TARGET_TRIPLET)
|
||||
set(VCPKG_TARGET_TRIPLET
|
||||
"x64-windows-static"
|
||||
CACHE STRING "")
|
||||
endif()
|
||||
|
||||
list(APPEND CMAKE_INCLUDE_PATH
|
||||
${VCPKG_DIR}/installed/x64-windows-static/include)
|
||||
list(APPEND CMAKE_PREFIX_PATH ${VCPKG_DIR}/installed/x64-windows-static)
|
||||
endif()
|
||||
|
||||
set(CMAKE_FIND_LIBRARY_SUFFIXES ".a" ".lib" ".so")
|
||||
|
||||
find_package(glaze CONFIG REQUIRED)
|
||||
find_package(spdlog CONFIG REQUIRED)
|
||||
find_package(fmt CONFIG REQUIRED)
|
||||
|
||||
if(NOT TARGET spdlog::spdlog_header_only)
|
||||
message(WARNING "spdlog header-only target not found, using shared library")
|
||||
endif()
|
||||
if(NOT TARGET fmt::fmt-header-only)
|
||||
message(WARNING "fmt header-only target not found, using shared library")
|
||||
endif()
|
||||
|
||||
if(UNIX AND NOT APPLE)
|
||||
find_package(Threads REQUIRED)
|
||||
endif()
|
||||
|
||||
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/src)
|
||||
set(SOURCES
|
||||
src/main.cpp
|
||||
src/language/tsl_keywords.cpp
|
||||
src/lsp/dispacther.cpp
|
||||
src/lsp/server.cpp
|
||||
src/provider/base/provider_registry.cpp
|
||||
src/provider/base/provider_interface.cpp
|
||||
src/provider/initialize/initialize_provider.cpp
|
||||
src/provider/initialized/initialized_provider.cpp
|
||||
src/provider/text_document/did_open_provider.cpp
|
||||
src/provider/text_document/did_change_provider.cpp
|
||||
src/provider/text_document/completion_provider.cpp
|
||||
src/provider/trace/set_trace_provider.cpp)
|
||||
|
||||
add_executable(${PROJECT_NAME} ${SOURCES})
|
||||
target_include_directories(${PROJECT_NAME} PRIVATE src)
|
||||
|
||||
target_compile_definitions(${PROJECT_NAME} PRIVATE SPDLOG_HEADER_ONLY
|
||||
FMT_HEADER_ONLY)
|
||||
|
||||
target_link_libraries(
|
||||
${PROJECT_NAME} PRIVATE glaze::glaze spdlog::spdlog_header_only
|
||||
fmt::fmt-header-only)
|
||||
|
||||
# Linux 需要链接 pthread
|
||||
if(UNIX AND NOT APPLE)
|
||||
target_link_libraries(${PROJECT_NAME} PRIVATE Threads::Threads)
|
||||
endif()
|
||||
|
|
@ -1,7 +0,0 @@
|
|||
# Third-party Notices
|
||||
|
||||
This project uses the following libraries under the MIT license:
|
||||
|
||||
- [stephenberry/glaze](https://github.com/stephenberry/glaze)
|
||||
- [gabime/spdlog](https://github.com/gabime/spdlog)
|
||||
- [fmtlib/fmt](https://github.com/fmtlib/fmt)
|
||||
|
|
@ -1,3 +0,0 @@
|
|||
# TSL Server
|
||||
|
||||
This project depends on third-party libraries licensed under MIT (see [NOTICE.md](./NOTICE.md)).
|
||||
|
|
@ -1,281 +0,0 @@
|
|||
#include <vector>
|
||||
#include <cctype>
|
||||
#include <algorithm>
|
||||
#include "./tsl_keywords.hpp"
|
||||
|
||||
namespace tsl
|
||||
{
|
||||
std::vector<KeywordInfo> TslKeywords::keywords_;
|
||||
std::unordered_set<std::string> TslKeywords::keyword_set_;
|
||||
bool TslKeywords::initialized_ = false;
|
||||
|
||||
const std::vector<KeywordInfo>& TslKeywords::GetAllKeywords()
|
||||
{
|
||||
InitKeywords();
|
||||
return keywords_;
|
||||
}
|
||||
|
||||
std::vector<KeywordInfo> TslKeywords::GetKeywordsByCategory(KeywordCategory category)
|
||||
{
|
||||
InitKeywords();
|
||||
std::vector<KeywordInfo> result;
|
||||
|
||||
for (const auto& keyword : keywords_)
|
||||
if (keyword.category == category)
|
||||
result.push_back(keyword);
|
||||
return result;
|
||||
}
|
||||
|
||||
std::vector<lsp::protocol::CompletionItem> TslKeywords::GetCompletionItems(const std::string& prefix)
|
||||
{
|
||||
InitKeywords();
|
||||
std::vector<lsp::protocol::CompletionItem> result;
|
||||
std::string lower_prefix = ToLowerCase(prefix);
|
||||
|
||||
for (const auto& keyword : keywords_)
|
||||
{
|
||||
if (prefix.empty() || StartsWith(ToLowerCase(keyword.keyword), lower_prefix))
|
||||
{
|
||||
lsp::protocol::CompletionItem item;
|
||||
item.label = keyword.keyword;
|
||||
item.kind = keyword.completion_kind;
|
||||
item.detail = keyword.description;
|
||||
item.insertText = keyword.keyword;
|
||||
result.push_back(item);
|
||||
}
|
||||
}
|
||||
// 按字母顺序排序
|
||||
std::sort(result.begin(), result.end(),
|
||||
[](const lsp::protocol::CompletionItem& a, const lsp::protocol::CompletionItem& b) {
|
||||
return a.label < b.label;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
KeywordCategory TslKeywords::GetKeywordCategory(const std::string& word)
|
||||
{
|
||||
InitKeywords();
|
||||
std::string lower_word = ToLowerCase(word);
|
||||
|
||||
for (const auto& keyword : keywords_)
|
||||
{
|
||||
if (ToLowerCase(keyword.keyword) == lower_word) {
|
||||
return keyword.category;
|
||||
}
|
||||
}
|
||||
|
||||
// 如果没找到，返回一个默认值（可以考虑抛出异常）
|
||||
return KeywordCategory::kProgramStructure;
|
||||
}
|
||||
|
||||
void TslKeywords::InitKeywords()
|
||||
{
|
||||
if (initialized_)
|
||||
return;
|
||||
keywords_ = {
|
||||
// Program Structure
|
||||
{ "program", KeywordCategory::kProgramStructure, "Program declaration", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "function", KeywordCategory::kProgramStructure, "Function declaration", lsp::protocol::CompletionItemKind::kFunction },
|
||||
{ "procedure", KeywordCategory::kProgramStructure, "Procedure declaration", lsp::protocol::CompletionItemKind::kFunction },
|
||||
{ "unit", KeywordCategory::kProgramStructure, "Unit declaration", lsp::protocol::CompletionItemKind::kModule },
|
||||
{ "uses", KeywordCategory::kProgramStructure, "Uses clause", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "implementation", KeywordCategory::kProgramStructure, "Implementation section", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "interface", KeywordCategory::kProgramStructure, "Interface section", lsp::protocol::CompletionItemKind::kInterface },
|
||||
{ "initialization", KeywordCategory::kProgramStructure, "Initialization section", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "finalization", KeywordCategory::kProgramStructure, "Finalization section", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
|
||||
// Data Types
|
||||
{ "string", KeywordCategory::kDataTypes, "String data type", lsp::protocol::CompletionItemKind::kClass },
|
||||
{ "integer", KeywordCategory::kDataTypes, "Integer data type", lsp::protocol::CompletionItemKind::kClass },
|
||||
{ "boolean", KeywordCategory::kDataTypes, "Boolean data type", lsp::protocol::CompletionItemKind::kClass },
|
||||
{ "int64", KeywordCategory::kDataTypes, "64-bit integer data type", lsp::protocol::CompletionItemKind::kClass },
|
||||
{ "real", KeywordCategory::kDataTypes, "Real number data type", lsp::protocol::CompletionItemKind::kClass },
|
||||
{ "array", KeywordCategory::kDataTypes, "Array data type", lsp::protocol::CompletionItemKind::kClass },
|
||||
|
||||
// Class Types
|
||||
{ "type", KeywordCategory::kClassTypes, "Type declaration", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "class", KeywordCategory::kClassTypes, "Class declaration", lsp::protocol::CompletionItemKind::kClass },
|
||||
{ "fakeclass", KeywordCategory::kClassTypes, "Fake class declaration", lsp::protocol::CompletionItemKind::kClass },
|
||||
{ "new", KeywordCategory::kClassTypes, "Object instantiation", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
|
||||
// Class Modifiers
|
||||
{ "override", KeywordCategory::kClassModifiers, "Override method", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "overload", KeywordCategory::kClassModifiers, "Overload method", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "virtual", KeywordCategory::kClassModifiers, "Virtual method", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "property", KeywordCategory::kClassModifiers, "Property declaration", lsp::protocol::CompletionItemKind::kProperty },
|
||||
{ "self", KeywordCategory::kClassModifiers, "Self reference", lsp::protocol::CompletionItemKind::kVariable },
|
||||
{ "inherited", KeywordCategory::kClassModifiers, "Inherited method call", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
|
||||
// Access Modifiers
|
||||
{ "public", KeywordCategory::kAccessModifiers, "Public access modifier", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "protected", KeywordCategory::kAccessModifiers, "Protected access modifier", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "private", KeywordCategory::kAccessModifiers, "Private access modifier", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "published", KeywordCategory::kAccessModifiers, "Published access modifier", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
|
||||
// Property Accessors
|
||||
{ "read", KeywordCategory::kPropertyAccessors, "Property read accessor", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "write", KeywordCategory::kPropertyAccessors, "Property write accessor", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
|
||||
// Constructors
|
||||
{ "create", KeywordCategory::kConstructors, "Constructor method", lsp::protocol::CompletionItemKind::kConstructor },
|
||||
{ "destroy", KeywordCategory::kConstructors, "Destructor method", lsp::protocol::CompletionItemKind::kMethod },
|
||||
{ "operator", KeywordCategory::kConstructors, "Operator overload", lsp::protocol::CompletionItemKind::kOperator },
|
||||
|
||||
// Variable Modifiers
|
||||
{ "external", KeywordCategory::kVariableModifiers, "External declaration", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "const", KeywordCategory::kVariableModifiers, "Constant declaration", lsp::protocol::CompletionItemKind::kConstant },
|
||||
{ "out", KeywordCategory::kVariableModifiers, "Output parameter", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "var", KeywordCategory::kVariableModifiers, "Variable declaration", lsp::protocol::CompletionItemKind::kVariable },
|
||||
{ "global", KeywordCategory::kVariableModifiers, "Global variable", lsp::protocol::CompletionItemKind::kVariable },
|
||||
{ "static", KeywordCategory::kVariableModifiers, "Static variable", lsp::protocol::CompletionItemKind::kVariable },
|
||||
|
||||
// Conditionals
|
||||
{ "if", KeywordCategory::kConditionals, "If statement", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "else", KeywordCategory::kConditionals, "Else clause", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "then", KeywordCategory::kConditionals, "Then clause", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "case", KeywordCategory::kConditionals, "Case statement", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "of", KeywordCategory::kConditionals, "Of clause", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
|
||||
// Loops
|
||||
{ "for", KeywordCategory::kLoops, "For loop", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "while", KeywordCategory::kLoops, "While loop", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "do", KeywordCategory::kLoops, "Do clause", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "downto", KeywordCategory::kLoops, "Downto clause", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "step", KeywordCategory::kLoops, "Step clause", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "until", KeywordCategory::kLoops, "Until clause", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "repeat", KeywordCategory::kLoops, "Repeat loop", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "to", KeywordCategory::kLoops, "To clause", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
|
||||
// Branch Control
|
||||
{ "break", KeywordCategory::kBranchControl, "Break statement", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "continue", KeywordCategory::kBranchControl, "Continue statement", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "goto", KeywordCategory::kBranchControl, "Goto statement", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "label", KeywordCategory::kBranchControl, "Label declaration", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "exit", KeywordCategory::kBranchControl, "Exit statement", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
|
||||
// Return Control
|
||||
{ "return", KeywordCategory::kReturnControl, "Return statement", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "debugreturn", KeywordCategory::kReturnControl, "Debug return statement", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "debugrunenv", KeywordCategory::kReturnControl, "Debug run environment", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "debugrunenvdo", KeywordCategory::kReturnControl, "Debug run environment do", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
|
||||
// Block Control
|
||||
{ "begin", KeywordCategory::kBlockControl, "Begin block", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "end", KeywordCategory::kBlockControl, "End block", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "with", KeywordCategory::kBlockControl, "With statement", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
|
||||
// References
|
||||
{ "weakref", KeywordCategory::kReferences, "Weak reference", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "autoref", KeywordCategory::kReferences, "Auto reference", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
|
||||
// Namespace
|
||||
{ "namespace", KeywordCategory::kNamespace, "Namespace declaration", lsp::protocol::CompletionItemKind::kModule },
|
||||
|
||||
// Exceptions
|
||||
{ "except", KeywordCategory::kExceptions, "Exception handling", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "raise", KeywordCategory::kExceptions, "Raise exception", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "try", KeywordCategory::kExceptions, "Try block", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "finally", KeywordCategory::kExceptions, "Finally block", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "exceptobject", KeywordCategory::kExceptions, "Exception object", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
|
||||
// Logical Operators
|
||||
{ "and", KeywordCategory::kLogicalOperators, "Logical AND", lsp::protocol::CompletionItemKind::kOperator },
|
||||
{ "in", KeywordCategory::kLogicalOperators, "In operator", lsp::protocol::CompletionItemKind::kOperator },
|
||||
{ "is", KeywordCategory::kLogicalOperators, "Is operator", lsp::protocol::CompletionItemKind::kOperator },
|
||||
{ "not", KeywordCategory::kLogicalOperators, "Logical NOT", lsp::protocol::CompletionItemKind::kOperator },
|
||||
{ "or", KeywordCategory::kLogicalOperators, "Logical OR", lsp::protocol::CompletionItemKind::kOperator },
|
||||
|
||||
// Arithmetic Operators
|
||||
{ "div", KeywordCategory::kArithmeticOperators, "Integer division", lsp::protocol::CompletionItemKind::kOperator },
|
||||
{ "mod", KeywordCategory::kArithmeticOperators, "Modulo operation", lsp::protocol::CompletionItemKind::kOperator },
|
||||
|
||||
// Bitwise Operators
|
||||
{ "ror", KeywordCategory::kBitwiseOperators, "Rotate right", lsp::protocol::CompletionItemKind::kOperator },
|
||||
{ "rol", KeywordCategory::kBitwiseOperators, "Rotate left", lsp::protocol::CompletionItemKind::kOperator },
|
||||
{ "shr", KeywordCategory::kBitwiseOperators, "Shift right", lsp::protocol::CompletionItemKind::kOperator },
|
||||
{ "shl", KeywordCategory::kBitwiseOperators, "Shift left", lsp::protocol::CompletionItemKind::kOperator },
|
||||
|
||||
// Set Operators
|
||||
{ "union", KeywordCategory::kSetOperators, "Set union", lsp::protocol::CompletionItemKind::kOperator },
|
||||
{ "minus", KeywordCategory::kSetOperators, "Set difference", lsp::protocol::CompletionItemKind::kOperator },
|
||||
{ "union2", KeywordCategory::kSetOperators, "Set union (alternative)", lsp::protocol::CompletionItemKind::kOperator },
|
||||
|
||||
// SQL Control
|
||||
{ "select", KeywordCategory::kSqlControl, "SQL SELECT", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "vselect", KeywordCategory::kSqlControl, "Virtual SELECT", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "sselect", KeywordCategory::kSqlControl, "Special SELECT", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "update", KeywordCategory::kSqlControl, "SQL UPDATE", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "delete", KeywordCategory::kSqlControl, "SQL DELETE", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "mselect", KeywordCategory::kSqlControl, "Multiple SELECT", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
|
||||
// SQL Keywords
|
||||
{ "sqlin", KeywordCategory::kSqlKeywords, "SQL IN", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "from", KeywordCategory::kSqlKeywords, "SQL FROM", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "where", KeywordCategory::kSqlKeywords, "SQL WHERE", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "group", KeywordCategory::kSqlKeywords, "SQL GROUP", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "by", KeywordCategory::kSqlKeywords, "SQL BY", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "order", KeywordCategory::kSqlKeywords, "SQL ORDER", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "distinct", KeywordCategory::kSqlKeywords, "SQL DISTINCT", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "join", KeywordCategory::kSqlKeywords, "SQL JOIN", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
|
||||
// SQL Operators (note: some overlap with logical operators)
|
||||
{ "on", KeywordCategory::kSqlOperators, "SQL ON", lsp::protocol::CompletionItemKind::kOperator },
|
||||
{ "like", KeywordCategory::kSqlOperators, "SQL LIKE", lsp::protocol::CompletionItemKind::kOperator },
|
||||
|
||||
// Calling Conventions
|
||||
{ "cdecl", KeywordCategory::kCallingConventions, "C calling convention", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "pascal", KeywordCategory::kCallingConventions, "Pascal calling convention", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "stdcall", KeywordCategory::kCallingConventions, "Standard calling convention", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "safecall", KeywordCategory::kCallingConventions, "Safe calling convention", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "fastcall", KeywordCategory::kCallingConventions, "Fast calling convention", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "register", KeywordCategory::kCallingConventions, "Register calling convention", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
|
||||
// System Keywords
|
||||
{ "setuid", KeywordCategory::kSystemKeywords, "Set user ID", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
{ "sudo", KeywordCategory::kSystemKeywords, "Super user do", lsp::protocol::CompletionItemKind::kKeyword },
|
||||
|
||||
// Builtin Variables
|
||||
{ "paramcount", KeywordCategory::kBuiltinVariables, "Parameter count", lsp::protocol::CompletionItemKind::kVariable },
|
||||
{ "realparamcount", KeywordCategory::kBuiltinVariables, "Real parameter count", lsp::protocol::CompletionItemKind::kVariable },
|
||||
{ "params", KeywordCategory::kBuiltinVariables, "Parameters array", lsp::protocol::CompletionItemKind::kVariable },
|
||||
{ "system", KeywordCategory::kBuiltinVariables, "System variable", lsp::protocol::CompletionItemKind::kVariable },
|
||||
{ "tslassigning", KeywordCategory::kBuiltinVariables, "TSL assigning", lsp::protocol::CompletionItemKind::kVariable },
|
||||
{ "likeeps", KeywordCategory::kBuiltinVariables, "Like EPS", lsp::protocol::CompletionItemKind::kVariable },
|
||||
{ "likeepsrate", KeywordCategory::kBuiltinVariables, "Like EPS rate", lsp::protocol::CompletionItemKind::kVariable },
|
||||
|
||||
// Builtin Functions
|
||||
{ "echo", KeywordCategory::kBuiltinFunctions, "Echo function", lsp::protocol::CompletionItemKind::kFunction },
|
||||
{ "mtic", KeywordCategory::kBuiltinFunctions, "MTIC function", lsp::protocol::CompletionItemKind::kFunction },
|
||||
{ "mtoc", KeywordCategory::kBuiltinFunctions, "MTOC function", lsp::protocol::CompletionItemKind::kFunction },
|
||||
|
||||
// Boolean Constants
|
||||
{ "false", KeywordCategory::kBooleanConstants, "Boolean false", lsp::protocol::CompletionItemKind::kConstant },
|
||||
{ "true", KeywordCategory::kBooleanConstants, "Boolean true", lsp::protocol::CompletionItemKind::kConstant },
|
||||
|
||||
// Math Constants
|
||||
{ "inf", KeywordCategory::kMathConstants, "Infinity", lsp::protocol::CompletionItemKind::kConstant },
|
||||
{ "nan", KeywordCategory::kMathConstants, "Not a Number", lsp::protocol::CompletionItemKind::kConstant },
|
||||
|
||||
// Null Constants
|
||||
{ "nil", KeywordCategory::kNullConstants, "Null value", lsp::protocol::CompletionItemKind::kConstant }
|
||||
};
|
||||
keyword_set_.clear();
|
||||
for (const auto& keyword : keywords_)
|
||||
keyword_set_.insert(ToLowerCase(keyword.keyword));
|
||||
initialized_ = true;
|
||||
}
|
||||
|
||||
std::string TslKeywords::ToLowerCase(const std::string& str)
|
||||
{
|
||||
std::string result = str;
|
||||
std::transform(result.begin(), result.end(), result.begin(), ::tolower);
|
||||
return result;
|
||||
}
|
||||
|
||||
bool TslKeywords::StartsWith(const std::string& str, const std::string& prefix)
|
||||
{
|
||||
if (prefix.length() > str.length())
|
||||
return false;
|
||||
return str.compare(0, prefix.length(), prefix) == 0;
|
||||
}
|
||||
}
|
||||
|
|
@ -1,71 +0,0 @@
|
|||
#pragma once
|
||||
#include <vector>
|
||||
#include <string>
|
||||
#include <unordered_set>
|
||||
#include "../protocol/protocol.hpp"
|
||||
|
||||
namespace tsl
|
||||
{
|
||||
enum class KeywordCategory
|
||||
{
|
||||
kProgramStructure, // program, function, procedure, unit, uses, implementation, interface, initialization, finalization
|
||||
kDataTypes, // string, integer, boolean, int64, real, array
|
||||
kClassTypes, // type, class, fakeclass, new
|
||||
kClassModifiers, // override, overload, virtual, property, self, inherited
|
||||
kAccessModifiers, // public, protected, private, published
|
||||
kPropertyAccessors, // read, write
|
||||
kConstructors, // create, destroy, operator
|
||||
kVariableModifiers, // external, const, out, var, global, static
|
||||
kConditionals, // if, else, then, case, of
|
||||
kLoops, // for, while, do, downto, step, until, repeat, to
|
||||
kBranchControl, // break, continue, goto, label, exit
|
||||
kReturnControl, // return, debugreturn, debugrunenv, debugrunenvdo
|
||||
kBlockControl, // begin, end, with
|
||||
kReferences, // weakref, autoref
|
||||
kNamespace, // namespace
|
||||
kExceptions, // except, raise, try, finally, exceptobject
|
||||
kLogicalOperators, // and, in, is, not, or
|
||||
kArithmeticOperators, // div, mod
|
||||
kBitwiseOperators, // ror, rol, shr, shl
|
||||
kSetOperators, // union, minus, union2
|
||||
kSqlControl, // select, vselect, sselect, update, delete, mselect
|
||||
kSqlOperators, // on, like, in (SQL context)
|
||||
kSqlKeywords, // sqlin, from, where, group, by, order, distinct, join
|
||||
kCallingConventions, // cdecl, pascal, stdcall, safecall, fastcall, register
|
||||
kSystemKeywords, // setuid, sudo
|
||||
kBuiltinVariables, // paramcount, realparamcount, params, system, tslassigning, likeeps, likeepsrate
|
||||
kBuiltinFunctions, // echo, mtic, mtoc
|
||||
kBooleanConstants, // false, true
|
||||
kMathConstants, // inf, nan
|
||||
kNullConstants // nil
|
||||
};
|
||||
|
||||
// 关键字信息
|
||||
struct KeywordInfo
|
||||
{
|
||||
std::string keyword;
|
||||
KeywordCategory category;
|
||||
std::string description;
|
||||
lsp::protocol::CompletionItemKind completion_kind;
|
||||
};
|
||||
|
||||
class TslKeywords
|
||||
{
|
||||
public:
|
||||
static const std::vector<KeywordInfo>& GetAllKeywords();
|
||||
static std::vector<KeywordInfo> GetKeywordsByCategory(KeywordCategory category);
|
||||
static std::vector<lsp::protocol::CompletionItem> GetCompletionItems(const std::string& prefix = "");
|
||||
static bool IsKeyword(const std::string& word);
|
||||
static KeywordCategory GetKeywordCategory(const std::string& word);
|
||||
|
||||
private:
|
||||
static void InitKeywords();
|
||||
static std::string ToLowerCase(const std::string& str);
|
||||
static bool StartsWith(const std::string& str, const std::string& prefix);
|
||||
|
||||
private:
|
||||
static std::vector<KeywordInfo> keywords_;
|
||||
static std::unordered_set<std::string> keyword_set_;
|
||||
static bool initialized_;
|
||||
};
|
||||
}
|
||||
|
|
@ -1,86 +0,0 @@
|
|||
#include <spdlog/spdlog.h>
|
||||
#include <mutex>
|
||||
#include "./dispacther.hpp"
|
||||
#include "../protocol/transform/facade.hpp"
|
||||
|
||||
namespace lsp
|
||||
{
|
||||
void RequestDispatcher::RegisterProvider(const std::string& method, RequestProvider handler)
|
||||
{
|
||||
std::unique_lock<std::shared_mutex> lock(providers_mutex_);
|
||||
providers_[method] = std::move(handler);
|
||||
spdlog::debug("Registered provider for method: {}", method);
|
||||
}
|
||||
|
||||
std::string RequestDispatcher::Dispatch(const protocol::RequestMessage& request)
|
||||
{
|
||||
std::shared_lock<std::shared_mutex> lock(providers_mutex_);
|
||||
auto it = providers_.find(request.method);
|
||||
if (it != providers_.end())
|
||||
{
|
||||
RequestProvider provider = it->second;
|
||||
lock.unlock();
|
||||
try
|
||||
{
|
||||
return provider(request);
|
||||
}
|
||||
catch (const std::exception& e)
|
||||
{
|
||||
spdlog::error("Provider error for method {}: {}", request.method, e.what());
|
||||
return HandleException(request, e.what());
|
||||
}
|
||||
}
|
||||
return HandleUnknownMethod(request);
|
||||
}
|
||||
|
||||
bool RequestDispatcher::SupportsMethod(const std::string& method) const
|
||||
{
|
||||
std::shared_lock<std::shared_mutex> lock(providers_mutex_);
|
||||
return providers_.find(method) != providers_.end();
|
||||
}
|
||||
|
||||
std::vector<std::string> RequestDispatcher::GetSupportedMethods() const
|
||||
{
|
||||
std::shared_lock<std::shared_mutex> lock(providers_mutex_);
|
||||
std::vector<std::string> methods;
|
||||
methods.reserve(providers_.size());
|
||||
for (const auto& [method, _] : providers_)
|
||||
{
|
||||
methods.push_back(method);
|
||||
}
|
||||
return methods;
|
||||
}
|
||||
|
||||
std::string RequestDispatcher::HandleUnknownMethod(const protocol::RequestMessage& request)
|
||||
{
|
||||
return BuildErrorResponse(request, protocol::ErrorCode::kMethodNotFound, "Method not found: " + request.method);
|
||||
}
|
||||
|
||||
std::string RequestDispatcher::HandleException(const protocol::RequestMessage& request, const std::string& error_message)
|
||||
{
|
||||
return BuildErrorResponse(request, protocol::ErrorCode::kInternalError, "Internal error: " + error_message);
|
||||
}
|
||||
|
||||
std::string RequestDispatcher::BuildErrorResponse(const protocol::RequestMessage& request, protocol::ErrorCode code, const std::string& message)
|
||||
{
|
||||
protocol::ResponseMessage response;
|
||||
response.jsonrpc = "2.0";
|
||||
response.id = request.id;
|
||||
|
||||
protocol::ResponseError error;
|
||||
error.code = code;
|
||||
error.message = message;
|
||||
response.error = error;
|
||||
|
||||
std::string json;
|
||||
auto ec = glz::write_json(response, json);
|
||||
if (ec)
|
||||
{
|
||||
spdlog::error("Failed to serialize error response: {}", glz::format_error(ec, json));
|
||||
// 返回一个硬编码的错误响应作为后备
|
||||
return R"({"jsonrpc":"2.0","id":null,"error":{"code":-32603,"message":"Failed to serialize error response"}})";
|
||||
}
|
||||
|
||||
return json;
|
||||
}
|
||||
}
|
||||
|
|
@ -1,32 +0,0 @@
|
|||
#pragma once
|
||||
#include <functional>
|
||||
#include <unordered_map>
|
||||
#include <vector>
|
||||
#include <shared_mutex>
|
||||
#include "../protocol/protocol.hpp"
|
||||
|
||||
namespace lsp
|
||||
{
|
||||
// 请求处理函数类型 - 返回序列化后的 JSON 字符串
|
||||
using RequestProvider = std::function<std::string(const protocol::RequestMessage&)>;
|
||||
|
||||
class RequestDispatcher
|
||||
{
|
||||
public:
|
||||
RequestDispatcher() = default;
|
||||
|
||||
void RegisterProvider(const std::string& method, RequestProvider provider);
|
||||
std::string Dispatch(const protocol::RequestMessage& request);
|
||||
bool SupportsMethod(const std::string& method) const;
|
||||
std::vector<std::string> GetSupportedMethods() const;
|
||||
|
||||
private:
|
||||
std::string HandleUnknownMethod(const protocol::RequestMessage& request);
|
||||
std::string HandleException(const protocol::RequestMessage& request, const std::string& error_message);
|
||||
std::string BuildErrorResponse(const protocol::RequestMessage& request, protocol::ErrorCode code, const std::string& message);
|
||||
|
||||
private:
|
||||
mutable std::shared_mutex providers_mutex_;
|
||||
std::unordered_map<std::string, RequestProvider> providers_;
|
||||
};
|
||||
}
|
||||
|
|
@ -1,56 +0,0 @@
|
|||
#include <mutex>
|
||||
#include <spdlog/spdlog.h>
|
||||
#include "./request_scheduler.hpp"
|
||||
|
||||
namespace lsp
|
||||
{
|
||||
|
||||
RequestScheduler::RequestScheduler(size_t concurrency) :
|
||||
executor_(concurrency)
|
||||
{
|
||||
spdlog::info("RequestScheduler initialized with {} threads", concurrency);
|
||||
}
|
||||
RequestScheduler::~RequestScheduler() = default;
|
||||
|
||||
void RequestScheduler::Sumbit(const std::string& request_id, TaskFunc task)
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(task_mutex_);
|
||||
auto future = executor_.silent_async([this, request_id, task = std::move(task)] {
|
||||
try
|
||||
{
|
||||
auto result = task();
|
||||
if (result)
|
||||
SendResponse(*result);
|
||||
}
|
||||
catch (const std::exception& e)
|
||||
{
|
||||
spdlog::error("Task {} failed: {}", request_id, e.what());
|
||||
}
|
||||
std::lock_guard<std::mutex> lock(cancel_mutex_);
|
||||
running_tasks_.erase(request_id);
|
||||
});
|
||||
running_tasks_[request_id] = std::move(future);
|
||||
}
|
||||
|
||||
void RequestScheduler::Cancel(const std::string& request_id)
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(cancel_mutex_);
|
||||
// Taskflow doesn't support preemptive cancel yet; you can set a flag here for cooperative cancel
|
||||
spdlog::warn("Cancel not implemented for request_id = {} (requires cooperative cancel)", request_id);
|
||||
}
|
||||
|
||||
void RequestScheduler::SetOutputFallback(std::function<void(const std::string&)> callback)
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(output_mutex_);
|
||||
send_response_ = std::move(callback);
|
||||
}
|
||||
|
||||
void RequestScheduler::SendResponse(const std::string& response)
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(output_mutex_);
|
||||
if (send_response_)
|
||||
send_response_(response);
|
||||
else
|
||||
spdlog::error("No response callback set! Unable to send: {}", response);
|
||||
}
|
||||
}
|
||||
|
|
@ -1,34 +0,0 @@
|
|||
#pragma once
|
||||
#include <mutex>
|
||||
#include <functional>
|
||||
#include <string>
|
||||
#include <optional>
|
||||
#include <unordered_map>
|
||||
#include <taskflow/taskflow.hpp>
|
||||
|
||||
namespace lsp
|
||||
{
|
||||
class RequestScheduler
|
||||
{
|
||||
public:
|
||||
using TaskFunc = std::function<std::optional<std::string>()>;
|
||||
explicit RequestScheduler(size_t concurrency);
|
||||
~RequestScheduler();
|
||||
|
||||
void Sumbit(const std::string& request_id, TaskFunc task);
|
||||
void Cancel(const std::string& request_id);
|
||||
void SetOutputFallback(std::function<void(const std::string&)> callback);
|
||||
|
||||
private:
|
||||
void SendResponse(const std::string& response);
|
||||
|
||||
private:
|
||||
tf::Executor executor_;
|
||||
std::mutex task_mutex_;
|
||||
std::mutex cancel_mutex_;
|
||||
std::mutex output_mutex_;
|
||||
|
||||
std::unordered_map<std::string, tf::Future<void>> running_tasks_;
|
||||
std::function<void(const std::string&)> send_response_;
|
||||
};
|
||||
}
|
||||
|
|
@ -1,245 +0,0 @@
|
|||
#include <exception>
|
||||
#include <iostream>
|
||||
#include <spdlog/spdlog.h>
|
||||
#ifdef _WIN32
|
||||
#include <io.h>
|
||||
#include <fcntl.h>
|
||||
#endif
|
||||
#include "../provider/base/provider_registry.hpp"
|
||||
#include "../protocol/transform/facade.hpp"
|
||||
#include "./server.hpp"
|
||||
|
||||
namespace lsp
|
||||
{
|
||||
LspServer::LspServer()
|
||||
{
|
||||
providers::RegisterAllProviders(dispatcher_);
|
||||
spdlog::debug("LSP server initialized with {} providers.", dispatcher_.GetSupportedMethods().size());
|
||||
}
|
||||
|
||||
LspServer::~LspServer() = default;
|
||||
|
||||
void LspServer::Run()
|
||||
{
|
||||
spdlog::info("LSP server starting main loop...");
|
||||
|
||||
// 设置二进制模式
|
||||
#ifdef _WIN32
|
||||
_setmode(_fileno(stdout), _O_BINARY);
|
||||
_setmode(_fileno(stdin), _O_BINARY);
|
||||
#endif
|
||||
|
||||
while (true)
|
||||
{
|
||||
try
|
||||
{
|
||||
std::optional<std::string> message = ReadMessage();
|
||||
if (!message)
|
||||
{
|
||||
spdlog::debug("No message received, continuing...");
|
||||
continue;
|
||||
}
|
||||
|
||||
std::string response = HandleMessage(*message);
|
||||
if (!response.empty())
|
||||
{
|
||||
SendResponse(response);
|
||||
}
|
||||
}
|
||||
catch (const std::exception& e)
|
||||
{
|
||||
spdlog::error("Error in main loop: {}", e.what());
|
||||
}
|
||||
}
|
||||
spdlog::info("LSP server main loop ended");
|
||||
}
|
||||
|
||||
std::optional<std::string> LspServer::ReadMessage()
|
||||
{
|
||||
std::string line;
|
||||
size_t content_length = 0;
|
||||
|
||||
// 读取 LSP Header
|
||||
while (std::getline(std::cin, line))
|
||||
{
|
||||
// 去掉尾部 \r
|
||||
if (!line.empty() && line.back() == '\r')
|
||||
{
|
||||
line.pop_back();
|
||||
}
|
||||
|
||||
if (line.empty())
|
||||
{
|
||||
break; // 空行表示 header 结束
|
||||
}
|
||||
|
||||
if (line.find("Content-Length:") == 0)
|
||||
{
|
||||
std::string length_str = line.substr(15); // 跳过 "Content-Length:"
|
||||
size_t start = length_str.find_first_not_of(" ");
|
||||
if (start != std::string::npos)
|
||||
{
|
||||
length_str = length_str.substr(start);
|
||||
try
|
||||
{
|
||||
content_length = std::stoul(length_str);
|
||||
spdlog::trace("Content-Length: {}", content_length);
|
||||
}
|
||||
catch (const std::exception& e)
|
||||
{
|
||||
spdlog::error("Failed to parse Content-Length: {}", e.what());
|
||||
return std::nullopt;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (content_length == 0)
|
||||
{
|
||||
spdlog::debug("No Content-Length found in header");
|
||||
return std::nullopt;
|
||||
}
|
||||
|
||||
// 读取内容体
|
||||
std::string body(content_length, '\0');
|
||||
std::cin.read(&body[0], content_length);
|
||||
|
||||
if (std::cin.gcount() != static_cast<std::streamsize>(content_length))
|
||||
{
|
||||
spdlog::error("Read incomplete message body, expected: {}, got: {}",
|
||||
content_length,
|
||||
std::cin.gcount());
|
||||
return std::nullopt;
|
||||
}
|
||||
|
||||
spdlog::trace("Received message: {}", body);
|
||||
return body;
|
||||
}
|
||||
|
||||
std::string LspServer::HandleMessage(const std::string& raw_message)
|
||||
{
|
||||
try
|
||||
{
|
||||
// 首先尝试解析为通用的 JSON 来判断消息类型
|
||||
glz::json_t doc;
|
||||
auto error = glz::read_json(doc, raw_message);
|
||||
if (error)
|
||||
{
|
||||
spdlog::error("Failed to parse message as JSON: {}",
|
||||
glz::format_error(error, raw_message));
|
||||
return "";
|
||||
}
|
||||
|
||||
auto& obj = doc.get<glz::json_t::object_t>();
|
||||
|
||||
// 判断消息类型
|
||||
bool has_id = obj.contains("id");
|
||||
bool has_method = obj.contains("method");
|
||||
bool has_result = obj.contains("result");
|
||||
bool has_error = obj.contains("error");
|
||||
|
||||
if (has_method && has_id)
|
||||
{
|
||||
// Request
|
||||
protocol::RequestMessage request;
|
||||
error = glz::read_json(request, raw_message);
|
||||
if (error)
|
||||
{
|
||||
spdlog::error("Failed to parse request: {}",
|
||||
glz::format_error(error, raw_message));
|
||||
return "";
|
||||
}
|
||||
return HandleRequest(request);
|
||||
}
|
||||
else if (has_method && !has_id)
|
||||
{
|
||||
// Notification
|
||||
protocol::NotificationMessage notification;
|
||||
error = glz::read_json(notification, raw_message);
|
||||
if (error)
|
||||
{
|
||||
spdlog::error("Failed to parse notification: {}",
|
||||
glz::format_error(error, raw_message));
|
||||
return "";
|
||||
}
|
||||
return HandleNotification(notification);
|
||||
}
|
||||
else if (has_id && (has_result || has_error))
|
||||
{
|
||||
// Response
|
||||
protocol::ResponseMessage response;
|
||||
error = glz::read_json(response, raw_message);
|
||||
if (error)
|
||||
{
|
||||
spdlog::error("Failed to parse response: {}",
|
||||
glz::format_error(error, raw_message));
|
||||
return "";
|
||||
}
|
||||
HandleResponse(response);
|
||||
return ""; // 响应不需要回复
|
||||
}
|
||||
else
|
||||
{
|
||||
spdlog::error("Unknown message type");
|
||||
return "";
|
||||
}
|
||||
}
|
||||
catch (const std::exception& e)
|
||||
{
|
||||
spdlog::error("Failed to handle message: {}", e.what());
|
||||
return "";
|
||||
}
|
||||
}
|
||||
|
||||
std::string LspServer::HandleRequest(const protocol::RequestMessage& request)
|
||||
{
|
||||
spdlog::debug("Processing request method: {}", request.method);
|
||||
|
||||
// 特殊处理 initialize 请求
|
||||
if (request.method == "initialize")
|
||||
{
|
||||
is_initialized_ = true;
|
||||
}
|
||||
|
||||
return dispatcher_.Dispatch(request);
|
||||
}
|
||||
|
||||
std::string LspServer::HandleNotification(const protocol::NotificationMessage& notification)
|
||||
{
|
||||
spdlog::debug("Processing notification - method: {}", notification.method);
|
||||
|
||||
// 特殊处理某些通知
|
||||
if (notification.method == "initialized")
|
||||
{
|
||||
spdlog::info("Client initialized");
|
||||
}
|
||||
else if (notification.method == "exit")
|
||||
{
|
||||
spdlog::info("Exit notification received");
|
||||
std::exit(0);
|
||||
}
|
||||
|
||||
// 通知不需要响应
|
||||
return "";
|
||||
}
|
||||
|
||||
void LspServer::HandleResponse(const protocol::ResponseMessage& response)
|
||||
{
|
||||
}
|
||||
|
||||
void LspServer::SendResponse(const std::string& response)
|
||||
{
|
||||
size_t byte_length = response.length();
|
||||
|
||||
// 构建完整消息
|
||||
std::string header = "Content-Length: " + std::to_string(byte_length) + "\r\n\r\n";
|
||||
|
||||
// 发送 header 和 body
|
||||
std::cout.write(header.c_str(), header.length());
|
||||
std::cout.write(response.c_str(), response.length());
|
||||
std::cout.flush();
|
||||
|
||||
spdlog::trace("Response sent - length: {}", byte_length);
|
||||
spdlog::trace("Response sent - body: {}", response);
|
||||
}
|
||||
}
|
||||
|
|
@ -1,34 +0,0 @@
|
|||
#pragma once
|
||||
#include <optional>
|
||||
#include <string>
|
||||
#include "./dispacther.hpp"
|
||||
|
||||
namespace lsp
|
||||
{
|
||||
class LspServer
|
||||
{
|
||||
public:
|
||||
LspServer();
|
||||
~LspServer();
|
||||
void Run();
|
||||
|
||||
private:
|
||||
// 读取LSP消息
|
||||
std::optional<std::string> ReadMessage();
|
||||
|
||||
// 处理LSP请求 - 返回序列化的响应或空字符串（对于通知）
|
||||
std::string HandleMessage(const std::string& raw_message);
|
||||
|
||||
// 发送LSP响应
|
||||
void SendResponse(const std::string& response);
|
||||
|
||||
// 处理不同类型的消息
|
||||
std::string HandleRequest(const protocol::RequestMessage& request);
|
||||
std::string HandleNotification(const protocol::NotificationMessage& notification);
|
||||
void HandleResponse(const protocol::ResponseMessage& response);
|
||||
|
||||
private:
|
||||
RequestDispatcher dispatcher_;
|
||||
bool is_initialized_ = false;
|
||||
};
|
||||
}
|
||||
|
|
@ -1,90 +0,0 @@
|
|||
#include <iostream>
|
||||
#include <exception>
|
||||
#include <memory>
|
||||
#include <vector>
|
||||
#include <spdlog/spdlog.h>
|
||||
#include <spdlog/sinks/stdout_sinks.h>
|
||||
#include <spdlog/sinks/basic_file_sink.h>
|
||||
#include "./lsp/server.hpp"
|
||||
|
||||
void ParseArgs(int argc, char* argv[])
|
||||
{
|
||||
std::vector<spdlog::sink_ptr> sinks;
|
||||
|
||||
bool use_stderr = false;
|
||||
std::string log_file;
|
||||
spdlog::level::level_enum log_level = spdlog::level::info;
|
||||
|
||||
for (int i = 1; i < argc; ++i)
|
||||
{
|
||||
std::string arg = argv[i];
|
||||
if (arg == "--log=trace")
|
||||
log_level = spdlog::level::trace;
|
||||
else if (arg == "--log=debug")
|
||||
log_level = spdlog::level::debug;
|
||||
else if (arg == "--log=info")
|
||||
log_level = spdlog::level::info;
|
||||
else if (arg == "--log=warn")
|
||||
log_level = spdlog::level::warn;
|
||||
else if (arg == "--log=error")
|
||||
log_level = spdlog::level::err;
|
||||
else if (arg == "--log=off")
|
||||
log_level = spdlog::level::off;
|
||||
else if (arg.find("--log-file=") == 0)
|
||||
log_file = arg.substr(11); // 跳过 "--log-file="
|
||||
else if (arg == "--log-stderr")
|
||||
use_stderr = true;
|
||||
}
|
||||
|
||||
sinks.clear();
|
||||
|
||||
if (use_stderr)
|
||||
sinks.push_back(std::make_shared<spdlog::sinks::stderr_sink_mt>());
|
||||
// 如果指定了日志文件，添加文件 sink
|
||||
if (!log_file.empty())
|
||||
{
|
||||
try
|
||||
{
|
||||
sinks.push_back(std::make_shared<spdlog::sinks::basic_file_sink_mt>(log_file, true));
|
||||
}
|
||||
catch (const std::exception& e)
|
||||
{
|
||||
std::cerr << "[TSL-LSP] Failed to create log file: " << e.what() << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
std::shared_ptr<spdlog::logger> logger = std::make_shared<spdlog::logger>("tsl_lsp", sinks.begin(), sinks.end());
|
||||
logger->set_level(log_level);
|
||||
logger->set_pattern("[%Y-%m-%d %H:%M:%S] [%^%l%$] %v");
|
||||
|
||||
// 设置为默认日志器
|
||||
spdlog::set_default_logger(logger);
|
||||
spdlog::flush_on(spdlog::level::warn);
|
||||
}
|
||||
|
||||
int main(int argc, char* argv[])
|
||||
{
|
||||
ParseArgs(argc, argv);
|
||||
try
|
||||
{
|
||||
spdlog::info("TSL-LSP server starting...");
|
||||
lsp::LspServer server;
|
||||
server.Run();
|
||||
}
|
||||
catch (const std::exception& e)
|
||||
{
|
||||
std::cerr << "[TSL-LSP] Server fatal error: " << e.what() << std::endl;
|
||||
spdlog::error("Server fatal error: ", e.what());
|
||||
return 1;
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
std::cerr << "[TSL-LSP] Server unknown fatal error" << std::endl;
|
||||
spdlog::error("Server unknown fatal error");
|
||||
return 1;
|
||||
}
|
||||
|
||||
spdlog::info("TSL-LSP server stopped normally");
|
||||
spdlog::shutdown();
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,244 +0,0 @@
|
|||
#pragma once
|
||||
#include <cstdint>
|
||||
#include <optional>
|
||||
#include <string>
|
||||
#include <map>
|
||||
#include <variant>
|
||||
#include <vector>
|
||||
|
||||
namespace lsp::protocol
|
||||
{
|
||||
|
||||
using integer = std::int32_t;
|
||||
using uinteger = std::uint32_t;
|
||||
using decimal = double;
|
||||
using boolean = bool;
|
||||
using string = std::string;
|
||||
|
||||
// LSPAny 这样设计是为了glaz序列化
|
||||
struct LSPAny;
|
||||
using LSPObject = std::map<string, LSPAny>;
|
||||
using LSPArray = std::vector<LSPAny>;
|
||||
|
||||
struct LSPAny
|
||||
{
|
||||
using LSPAnyVariant = std::variant<
|
||||
LSPObject,
|
||||
LSPArray,
|
||||
string,
|
||||
decimal, // 放在前面，优先匹配数字
|
||||
boolean,
|
||||
std::nullptr_t>;
|
||||
|
||||
LSPAnyVariant value;
|
||||
|
||||
// 默认构造函数
|
||||
LSPAny();
|
||||
// 拷贝和移动构造函数
|
||||
LSPAny(const LSPAny& other);
|
||||
LSPAny(LSPAny&& other) noexcept;
|
||||
// 针对每种支持的类型的构造函数
|
||||
LSPAny(const std::map<string, LSPAny>& val);
|
||||
LSPAny(std::map<string, LSPAny>&& val);
|
||||
LSPAny(const std::vector<LSPAny>& val);
|
||||
LSPAny(std::vector<LSPAny>&& val);
|
||||
LSPAny(const string& val);
|
||||
LSPAny(string&& val);
|
||||
LSPAny(const char* val);
|
||||
|
||||
// 所有数字类型都转换为 decimal
|
||||
LSPAny(int val);
|
||||
LSPAny(long val);
|
||||
LSPAny(long long val);
|
||||
LSPAny(unsigned int val);
|
||||
LSPAny(unsigned long val);
|
||||
LSPAny(unsigned long long val);
|
||||
LSPAny(float val);
|
||||
LSPAny(double val);
|
||||
LSPAny(long double val);
|
||||
LSPAny(boolean val);
|
||||
LSPAny(std::nullptr_t);
|
||||
|
||||
// 赋值操作符
|
||||
LSPAny& operator=(const LSPAny& other);
|
||||
LSPAny& operator=(LSPAny&& other) noexcept;
|
||||
LSPAny& operator=(const std::map<string, LSPAny>& val);
|
||||
LSPAny& operator=(std::map<string, LSPAny>&& val);
|
||||
LSPAny& operator=(const std::vector<LSPAny>& val);
|
||||
LSPAny& operator=(std::vector<LSPAny>&& val);
|
||||
LSPAny& operator=(const string& val);
|
||||
LSPAny& operator=(string&& val);
|
||||
LSPAny& operator=(const char* val);
|
||||
LSPAny& operator=(int val);
|
||||
LSPAny& operator=(long val);
|
||||
LSPAny& operator=(long long val);
|
||||
LSPAny& operator=(unsigned int val);
|
||||
LSPAny& operator=(unsigned long val);
|
||||
LSPAny& operator=(unsigned long long val);
|
||||
LSPAny& operator=(float val);
|
||||
LSPAny& operator=(double val);
|
||||
LSPAny& operator=(long double val);
|
||||
LSPAny& operator=(boolean val);
|
||||
LSPAny& operator=(std::nullptr_t);
|
||||
|
||||
// 类型检查辅助函数
|
||||
template<typename T>
|
||||
bool is() const;
|
||||
|
||||
template<typename T>
|
||||
T& get();
|
||||
|
||||
template<typename T>
|
||||
const T& get() const;
|
||||
|
||||
// 访问操作符
|
||||
template<typename Visitor>
|
||||
auto visit(Visitor&& visitor) const;
|
||||
|
||||
template<typename Visitor>
|
||||
auto visit(Visitor&& visitor);
|
||||
};
|
||||
|
||||
using ProgressToken = std::variant<integer, string>;
|
||||
|
||||
template<typename T>
|
||||
struct ProgressParams
|
||||
{
|
||||
ProgressToken token;
|
||||
T value;
|
||||
};
|
||||
|
||||
using DocumentUri = string;
|
||||
using URI = string;
|
||||
|
||||
struct Position
|
||||
{
|
||||
uinteger line;
|
||||
uinteger character;
|
||||
};
|
||||
|
||||
using PositionEncodingKind = std::string_view;
|
||||
namespace PositionEncodingKindLiterals
|
||||
{
|
||||
inline constexpr PositionEncodingKind UTF8 = "utf-8";
|
||||
inline constexpr PositionEncodingKind UTF16 = "utf-16";
|
||||
inline constexpr PositionEncodingKind UTF32 = "utf-32";
|
||||
}
|
||||
|
||||
struct Range
|
||||
{
|
||||
Position start;
|
||||
Position end;
|
||||
};
|
||||
|
||||
struct DocumentFilter
|
||||
{
|
||||
string language;
|
||||
string scheme;
|
||||
std::optional<string> pattern;
|
||||
};
|
||||
|
||||
using DocumentSelector = std::vector<DocumentFilter>;
|
||||
|
||||
struct TextEdit
|
||||
{
|
||||
Range range;
|
||||
string newText;
|
||||
};
|
||||
|
||||
struct ChangeAnnotation
|
||||
{
|
||||
string label;
|
||||
boolean needsConfirmation;
|
||||
string description;
|
||||
};
|
||||
|
||||
using ChangeAnnotationIdentifier = string;
|
||||
|
||||
struct AnnotatedTextEdit : TextEdit
|
||||
{
|
||||
ChangeAnnotationIdentifier annotationId;
|
||||
};
|
||||
|
||||
struct Location
|
||||
{
|
||||
DocumentUri uri;
|
||||
Range range;
|
||||
};
|
||||
|
||||
struct LocationLink
|
||||
{
|
||||
Range originSelectionRange;
|
||||
DocumentUri targetUri;
|
||||
Range targetRange;
|
||||
Range targetSelectionRange;
|
||||
};
|
||||
|
||||
struct Command
|
||||
{
|
||||
string title;
|
||||
string command;
|
||||
std::optional<LSPAny> arguments;
|
||||
};
|
||||
|
||||
using MarkupKind = std::string_view;
|
||||
namespace MarkupKindLiterals
|
||||
{
|
||||
inline constexpr MarkupKind PlainText = "plaintext";
|
||||
inline constexpr MarkupKind Markdown = "markdown";
|
||||
};
|
||||
|
||||
struct MarkupContent
|
||||
{
|
||||
MarkupKind kind;
|
||||
string value;
|
||||
};
|
||||
|
||||
struct RegularExpressionsClientCapabilities
|
||||
{
|
||||
string engine;
|
||||
std::optional<string> version;
|
||||
};
|
||||
|
||||
struct MarkdownClientCapabilities
|
||||
{
|
||||
string parser;
|
||||
std::optional<string> version;
|
||||
std::optional<std::vector<string>> allowedTags;
|
||||
};
|
||||
|
||||
// LSP模板方法
|
||||
template<typename T>
|
||||
bool LSPAny::is() const
|
||||
{
|
||||
return std::holds_alternative<T>(value);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
T& LSPAny::get()
|
||||
{
|
||||
return std::get<T>(value);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
const T& LSPAny::get() const
|
||||
{
|
||||
return std::get<T>(value);
|
||||
}
|
||||
|
||||
// 访问操作符
|
||||
template<typename Visitor>
|
||||
auto LSPAny::visit(Visitor&& visitor) const
|
||||
{
|
||||
return std::visit(std::forward<Visitor>(visitor), value);
|
||||
}
|
||||
|
||||
template<typename Visitor>
|
||||
auto LSPAny::visit(Visitor&& visitor)
|
||||
{
|
||||
return std::visit(std::forward<Visitor>(visitor), value);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#include "./lsp_any.inl"
|
||||
|
|
@ -1,212 +0,0 @@
|
|||
#pragma once
|
||||
#include "./basic_types.hpp"
|
||||
#include "./progress.hpp"
|
||||
#include "./diagnostics.hpp"
|
||||
#include "./workspace.hpp"
|
||||
#include "./document_sync.hpp"
|
||||
#include "./completion.hpp"
|
||||
#include "./document_features.hpp"
|
||||
#include "./symbols.hpp"
|
||||
#include "./navigation.hpp"
|
||||
#include "./code_actions.hpp"
|
||||
#include "./formatting.hpp"
|
||||
#include "./rename.hpp"
|
||||
#include "./semantic_tokens.hpp"
|
||||
#include "./inline_features.hpp"
|
||||
#include "./signature_help.hpp"
|
||||
#include "./notebook.hpp"
|
||||
#include "./file_operations.hpp"
|
||||
#include "./configuration.hpp"
|
||||
|
||||
namespace lsp::protocol
|
||||
{
|
||||
struct TextDocumentClientCapabilities
|
||||
{
|
||||
std::optional<TextDocumentSyncClientCapabilities> synchronization;
|
||||
std::optional<CompletionClientCapabilities> completion;
|
||||
std::optional<HoverClientCapabilities> hover;
|
||||
std::optional<SignatureHelpClientCapabilities> singatureHelp;
|
||||
std::optional<DeclarationClientCapabilities> declatration;
|
||||
std::optional<DefinitionClientCapabilities> definition;
|
||||
std::optional<TypeDefinitionClientCapabilities> typeDefinition;
|
||||
std::optional<ImplementationClientCapabilities> implementation;
|
||||
std::optional<ReferenceClientCapabilities> reference;
|
||||
std::optional<DocumentHighlightClientCapabilities> documentHighlight;
|
||||
std::optional<DocumentSymbolClientCapabilities> documentSymbol;
|
||||
std::optional<CodeActionClientCapabilities> codeAction;
|
||||
std::optional<CodeLensClientCapabilities> codeLens;
|
||||
std::optional<DocumentLinkClientCapabilities> documentLink;
|
||||
std::optional<DocumentColorClientCapabilities> colorProvider;
|
||||
std::optional<DocumentFormattingClientCapabilities> formatting;
|
||||
std::optional<DocumentRangeFormattingClientCapabilities> rangeFormatting;
|
||||
std::optional<DocumentOnTypeFormattingClientCapabilities> onTypeFormatting;
|
||||
std::optional<RenameClientCapabilities> rename;
|
||||
std::optional<PublishDiagnosticsClientCapabilities> publishDiagnostics;
|
||||
std::optional<FoldingRangeClientCapabilities> foldingRange;
|
||||
std::optional<SelectionRangeClientCapabilities> selectionRange;
|
||||
std::optional<LinkedEditingRangeClientCapabilities> linkedEditingRange;
|
||||
std::optional<CallHierarchyClientCapabilities> callHierarchy;
|
||||
std::optional<SemanticTokensClientCapabilities> semanticTokens;
|
||||
std::optional<MonikerClientCapabilities> moniker;
|
||||
std::optional<TypeHierarchyClientCapabilities> typeHierarchy;
|
||||
std::optional<InlineValueClientCapabilities> inlineValue;
|
||||
std::optional<InlayHintClientCapabilities> inlayHint;
|
||||
std::optional<DiagnosticClientCapabilities> diagnostic;
|
||||
};
|
||||
|
||||
struct ClientCapabilities
|
||||
{
|
||||
struct Workspace
|
||||
{
|
||||
struct FileOperations
|
||||
{
|
||||
std::optional<boolean> dynamicRegistration;
|
||||
std::optional<boolean> didCreate;
|
||||
std::optional<boolean> willCreate;
|
||||
std::optional<boolean> didRename;
|
||||
std::optional<boolean> willRename;
|
||||
std::optional<boolean> didDelete;
|
||||
std::optional<boolean> willDelete;
|
||||
};
|
||||
|
||||
std::optional<boolean> applyEdit;
|
||||
std::optional<WorkspaceEditClientCapabilities> workspaceEdit;
|
||||
std::optional<DidChangeConfigurationClientCapabilities> didChangeConfiguration;
|
||||
std::optional<DidChangeWatchedFilesClientCapabilities> didChangeWatchedFiles;
|
||||
std::optional<WorkspaceSymbolClientCapabilities> symbol;
|
||||
std::optional<ExecuteCommandClientCapabilities> executeCommand;
|
||||
std::optional<boolean> workspaceFolders;
|
||||
std::optional<boolean> configuration;
|
||||
std::optional<SemanticTokensWorkspaceClientCapabilities> semanticTokens;
|
||||
std::optional<CodeLensWorkspaceClientCapabilities> codeLens;
|
||||
std::optional<FileOperations> fileOperations;
|
||||
std::optional<InlineValueClientCapabilities> inlineValue;
|
||||
std::optional<InlayHintClientCapabilities> inlayHint;
|
||||
std::optional<DiagnosticClientCapabilities> diagnostic;
|
||||
};
|
||||
struct Window
|
||||
{
|
||||
std::optional<boolean> workDoneProgress;
|
||||
std::optional<ShowMessageRequestClientCapabilities> showMessage;
|
||||
std::optional<ShowDocumentClientCapabilities> showDocument;
|
||||
};
|
||||
struct General
|
||||
{
|
||||
struct StaleRequestSupport
|
||||
{
|
||||
boolean cancel;
|
||||
std::vector<string> retryOnContentModified;
|
||||
};
|
||||
|
||||
std::optional<StaleRequestSupport> staleRequestSupport;
|
||||
std::optional<RegularExpressionsClientCapabilities> regularExpression;
|
||||
std::optional<MarkdownClientCapabilities> markdown;
|
||||
std::optional<std::vector<PositionEncodingKind>> positionEncodings;
|
||||
};
|
||||
|
||||
std::optional<Workspace> workspace;
|
||||
std::optional<TextDocumentClientCapabilities> textDocument;
|
||||
std::optional<NotebookDocumentClientCapabilities> notebookDocument;
|
||||
std::optional<Window> window;
|
||||
std::optional<General> general;
|
||||
std::optional<LSPAny> experimental;
|
||||
};
|
||||
|
||||
struct ServerCapabilities
|
||||
{
|
||||
struct Workspace
|
||||
{
|
||||
struct FileOperations
|
||||
{
|
||||
std::optional<boolean> dynamicRegistration;
|
||||
std::optional<boolean> didCreate;
|
||||
std::optional<boolean> willCreate;
|
||||
std::optional<boolean> didRename;
|
||||
std::optional<boolean> willRename;
|
||||
std::optional<boolean> didDelete;
|
||||
std::optional<boolean> willDelete;
|
||||
};
|
||||
|
||||
std::optional<WorkspaceFolderServerCapabilities> workspaceFolders;
|
||||
std::optional<FileOperations> fileOperations;
|
||||
};
|
||||
|
||||
std::optional<PositionEncodingKind> positionEncoding;
|
||||
std::optional<std::variant<TextDocumentSyncOptions, TextDocumentSyncKind>> textDocumentSync;
|
||||
std::optional<std::variant<NotebookDocumentSyncOptions, NotebookDocumentSyncRegistrationOptions>> notebookDocumentSync;
|
||||
std::optional<CompletionOptions> completionProvider;
|
||||
std::optional<std::variant<boolean, HoverOptions>> hoverProvider;
|
||||
std::optional<SignatureHelpOptions> signatureHelpProvider;
|
||||
std::optional<std::variant<boolean, DeclarationOptions, DeclarationRegistrationOptions>> declarationProvider;
|
||||
std::optional<std::variant<boolean, DefinitionOptions>> definitionProvider;
|
||||
std::optional<std::variant<boolean, TypeDefinitionOptions, TypeDefinitionRegistrationOptions>> typeDefinitionProvider;
|
||||
std::optional<std::variant<boolean, ImplementationOptions, ImplementationRegistrationOptions>> implementationProvider;
|
||||
std::optional<std::variant<boolean, ReferenceOptions>> referencesProvider;
|
||||
std::optional<std::variant<boolean, DocumentHighlightOptions>> documentHighlightProvider;
|
||||
std::optional<std::variant<boolean, DocumentSymbolOptions>> documentSymbolProvider;
|
||||
std::optional<std::variant<boolean, CodeActionOptions>> codeActionProvider;
|
||||
std::optional<CodeLensOptions> codeLensProvider;
|
||||
std::optional<DocumentLinkOptions> documentLinkProvider;
|
||||
std::optional<std::variant<boolean, DocumentColorOptions, DocumentColorRegistrationOptions>> colorProvider;
|
||||
std::optional<std::variant<boolean, DocumentFormattingOptions>> documentFormattingProvider;
|
||||
std::optional<std::variant<boolean, DocumentRangeFormattingOptions>> documentRangeFormattingProvider;
|
||||
std::optional<DocumentOnTypeFormattingOptions> documentOnTypeFormattingProvider;
|
||||
std::optional<std::variant<boolean, RenameOptions>> renameProvider;
|
||||
std::optional<std::variant<boolean, FoldingRangeOptions, FoldingRangeRegistrationOptions>> foldingRangeProvider;
|
||||
std::optional<ExecuteCommandOptions> executeCommandProvider;
|
||||
std::optional<std::variant<boolean, SelectionRangeOptions, SelectionRangeRegistrationOptions>> selectionRangeProvider;
|
||||
std::optional<std::variant<boolean, LinkedEditingRangeOptions, LinkedEditingRangeRegistrationOptions>> linkedEditingRangeProvider;
|
||||
std::optional<std::variant<boolean, CallHierarchyOptions, CallHierarchyRegistrationOptions>> callHierarchyProvider;
|
||||
std::optional<std::variant<SemanticTokensOptions, SemanticTokensRegistrationOptions>> semanticTokensProvider;
|
||||
std::optional<std::variant<boolean, MonikerOptions, MonikerRegistrationOptions>> monikerProvider;
|
||||
std::optional<std::variant<boolean, TypeHierarchyOptions, TypeHierarchyRegistrationOptions>> typeHierarchyProvider;
|
||||
std::optional<std::variant<boolean, InlineValueOptions, InlineValueRegistrationOptions>> inlineValueProvider;
|
||||
std::optional<std::variant<boolean, InlayHintOptions, InlayHintRegistrationOptions>> inlayHintProvider;
|
||||
std::optional<std::variant<DiagnosticOptions, DiagnosticRegistrationOptions>> diagnosticProvider;
|
||||
std::optional<std::variant<boolean, WorkspaceSymbolOptions>> workspaceSymbolProvider;
|
||||
std::optional<Workspace> workspace;
|
||||
std::optional<LSPAny> experimental;
|
||||
};
|
||||
|
||||
struct InitializeResult
|
||||
{
|
||||
struct ServerInfo
|
||||
{
|
||||
string name;
|
||||
std::optional<string> version;
|
||||
};
|
||||
|
||||
ServerCapabilities capabilities;
|
||||
ServerInfo serverInfo;
|
||||
};
|
||||
|
||||
enum class InitializeErrorCodes
|
||||
{
|
||||
kUnknownProtocolVersion = 1
|
||||
};
|
||||
|
||||
struct InitializeError
|
||||
{
|
||||
boolean retry;
|
||||
};
|
||||
|
||||
struct InitializeParams : WorkDoneProgressParams
|
||||
{
|
||||
struct ClientInfo
|
||||
{
|
||||
string name;
|
||||
std::optional<string> version;
|
||||
};
|
||||
|
||||
std::optional<integer> processId;
|
||||
std::optional<ClientInfo> clientInfo;
|
||||
std::optional<string> locale;
|
||||
std::optional<string> rootPath;
|
||||
std::optional<DocumentUri> rootUri;
|
||||
std::optional<LSPAny> initializationOptions;
|
||||
std::optional<ClientCapabilities> capabilities;
|
||||
TraceValue trace;
|
||||
std::optional<std::vector<WorkspaceFolder>> workspaceFolders;
|
||||
};
|
||||
|
||||
}
|
||||
|
|
@ -1,141 +0,0 @@
|
|||
#pragma once
|
||||
#include "./basic_types.hpp"
|
||||
#include "./document_sync.hpp"
|
||||
#include "./progress.hpp"
|
||||
#include "./workspace.hpp"
|
||||
|
||||
namespace lsp::protocol
|
||||
{
|
||||
using CodeActionKind = std::string_view;
|
||||
namespace CodeActionKindLiterals
|
||||
{
|
||||
inline constexpr CodeActionKind Empty = "";
|
||||
inline constexpr CodeActionKind QuickFix = "quickfix";
|
||||
inline constexpr CodeActionKind Refactor = "refactor";
|
||||
inline constexpr CodeActionKind RefactorExtract = "refactor.extract";
|
||||
inline constexpr CodeActionKind RefactorInline = "refactor.inline";
|
||||
inline constexpr CodeActionKind RefactorRewrite = "refactor.rewrite";
|
||||
inline constexpr CodeActionKind Source = "source";
|
||||
inline constexpr CodeActionKind SourceOrganizeImports = "source.organizeImports";
|
||||
inline constexpr CodeActionKind SourceFixAll = "source.fixAll";
|
||||
}
|
||||
|
||||
struct CodeActionClientCapabilities
|
||||
{
|
||||
struct CodeActionLiteralSupport
|
||||
{
|
||||
struct CodeActionKinds
|
||||
{
|
||||
std::vector<CodeActionKind> valueSet;
|
||||
};
|
||||
};
|
||||
|
||||
struct ResolveSupport
|
||||
{
|
||||
std::vector<string> properties;
|
||||
};
|
||||
|
||||
std::optional<boolean> dynamicRegistration;
|
||||
std::optional<CodeActionLiteralSupport> codeActionLiteralSupport;
|
||||
std::optional<boolean> isPreferredSupport;
|
||||
std::optional<boolean> disabledSupport;
|
||||
std::optional<ResolveSupport> resolveSupport;
|
||||
std::optional<boolean> honorsChangeAnnotations;
|
||||
};
|
||||
|
||||
struct CodeActionOptions : WorkDoneProgressOptions
|
||||
{
|
||||
std::optional<std::vector<CodeActionKind>> codeActionKinds;
|
||||
std::optional<boolean> resolveProvider;
|
||||
};
|
||||
|
||||
struct CodeActionRegistrationOptions : TextDocumentRegistrationOptions, CodeActionOptions
|
||||
{
|
||||
};
|
||||
|
||||
enum class CodeActionTriggerKind
|
||||
{
|
||||
kInvoked = 1,
|
||||
kAutomatic = 2
|
||||
};
|
||||
|
||||
struct CodeActionContext
|
||||
{
|
||||
std::vector<Diagnostic> diagnostics;
|
||||
std::optional<std::vector<CodeActionKind>> only;
|
||||
std::optional<CodeActionTriggerKind> triggerKind;
|
||||
};
|
||||
|
||||
struct CodeActionParams : TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams
|
||||
{
|
||||
TextDocumentIdentifier textDocument;
|
||||
Range range;
|
||||
CodeActionContext context;
|
||||
};
|
||||
|
||||
struct CodeAction
|
||||
{
|
||||
struct Disabled
|
||||
{
|
||||
string reason;
|
||||
};
|
||||
|
||||
string title;
|
||||
std::optional<CodeActionKind> kind;
|
||||
std::optional<std::vector<Diagnostic>> diagnostics;
|
||||
std::optional<boolean> isPreferred;
|
||||
std::optional<Disabled> disabled;
|
||||
std::optional<WorkspaceEdit> edit;
|
||||
std::optional<Command> command;
|
||||
std::optional<LSPAny> data;
|
||||
};
|
||||
|
||||
// Color
|
||||
struct DocumentColorClientCapabilities
|
||||
{
|
||||
std::optional<boolean> dynamicRegistration;
|
||||
};
|
||||
|
||||
struct DocumentColorOptions : WorkDoneProgressOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct DocumentColorRegistrationOptions : TextDocumentRegistrationOptions, DocumentColorOptions, StaticRegistrationOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct DocumentColorParams : WorkDoneProgressParams, PartialResultParams
|
||||
{
|
||||
TextDocumentIdentifier textDocument;
|
||||
};
|
||||
|
||||
struct Color
|
||||
{
|
||||
decimal red;
|
||||
decimal green;
|
||||
decimal blue;
|
||||
decimal alpha;
|
||||
};
|
||||
|
||||
struct ColorInformation
|
||||
{
|
||||
Range range;
|
||||
Color color;
|
||||
};
|
||||
|
||||
struct ColorPresentationParams : WorkDoneProgressParams, PartialResultParams
|
||||
{
|
||||
TextDocumentIdentifier textDocument;
|
||||
Color color;
|
||||
Range range;
|
||||
};
|
||||
|
||||
struct ColorPresentation
|
||||
{
|
||||
string label;
|
||||
std::optional<TextEdit> textEdit;
|
||||
std::optional<std::vector<TextEdit>> additionalTextEdits;
|
||||
};
|
||||
|
||||
|
||||
}
|
||||
|
|
@ -1,185 +0,0 @@
|
|||
#pragma once
|
||||
#include "./basic_types.hpp"
|
||||
#include "./document_sync.hpp"
|
||||
#include "./progress.hpp"
|
||||
|
||||
namespace lsp::protocol
|
||||
{
|
||||
enum class CompletionItemTag
|
||||
{
|
||||
kDeprecated = 1
|
||||
};
|
||||
|
||||
enum class InsertTextMode
|
||||
{
|
||||
kAsIs = 1,
|
||||
kAdjustIndentation = 2
|
||||
};
|
||||
|
||||
enum class CompletionItemKind
|
||||
{
|
||||
kText = 1,
|
||||
kMethod = 2,
|
||||
kFunction = 3,
|
||||
kConstructor = 4,
|
||||
kField = 5,
|
||||
kVariable = 6,
|
||||
kClass = 7,
|
||||
kInterface = 8,
|
||||
kModule = 9,
|
||||
kProperty = 10,
|
||||
kUnit = 11,
|
||||
kValue = 12,
|
||||
kEnum = 13,
|
||||
kKeyword = 14,
|
||||
kSnippet = 15,
|
||||
kColor = 16,
|
||||
kFile = 17,
|
||||
kReference = 18,
|
||||
kFolder = 19,
|
||||
kEnumMember = 20,
|
||||
kConstant = 21,
|
||||
kStruct = 22,
|
||||
kEvent = 23,
|
||||
kOperator = 24,
|
||||
kTypeParameter = 25
|
||||
};
|
||||
|
||||
enum class InsertTextFormat
|
||||
{
|
||||
kPlainText = 1,
|
||||
kSnippet = 2
|
||||
};
|
||||
|
||||
enum CompletionTriggerKind
|
||||
{
|
||||
kInvoked = 1,
|
||||
kTriggerCharacter = 2,
|
||||
kTriggerForIncompleteCompletions = 3
|
||||
};
|
||||
|
||||
struct CompletionContext
|
||||
{
|
||||
CompletionTriggerKind triggerKind;
|
||||
std::optional<string> triggerCharacter;
|
||||
};
|
||||
|
||||
struct InsertReplaceEdit
|
||||
{
|
||||
string newText;
|
||||
Range insert;
|
||||
Range replace;
|
||||
};
|
||||
|
||||
struct CompletionItemLabelDetails
|
||||
{
|
||||
std::optional<std::string> detail;
|
||||
std::optional<std::string> description;
|
||||
};
|
||||
|
||||
struct CompletionItem
|
||||
{
|
||||
string label;
|
||||
std::optional<CompletionItemLabelDetails> labelDetails;
|
||||
std::optional<CompletionItemKind> kind;
|
||||
std::optional<string> detail;
|
||||
std::optional<std::variant<string, MarkupContent>> documentation;
|
||||
std::optional<boolean> preselect;
|
||||
std::optional<string> sortText;
|
||||
std::optional<string> filterText;
|
||||
std::optional<string> insertText;
|
||||
std::optional<InsertTextFormat> insertTextFormat;
|
||||
std::optional<InsertTextMode> insertTextMode;
|
||||
std::optional<std::variant<TextEdit, InsertReplaceEdit>> textEdit;
|
||||
std::optional<string> textEditText;
|
||||
std::optional<std::vector<TextEdit>> additionalTextEdits;
|
||||
std::optional<std::vector<string>> commitCharacters;
|
||||
std::optional<Command> command;
|
||||
std::optional<LSPAny> data;
|
||||
};
|
||||
|
||||
struct CompletionList
|
||||
{
|
||||
struct ItemDefaults
|
||||
{
|
||||
struct EditRange
|
||||
{
|
||||
Range insert;
|
||||
Range replace;
|
||||
};
|
||||
std::optional<std::vector<string>> commitCharacters;
|
||||
std::optional<std::variant<Range, EditRange>> editRange;
|
||||
std::optional<InsertTextFormat> insertTextFormat;
|
||||
std::optional<InsertTextMode> insertTextMode;
|
||||
std::optional<LSPAny> data;
|
||||
};
|
||||
boolean isIncomplete;
|
||||
ItemDefaults itemDefaults;
|
||||
std::vector<CompletionItem> items;
|
||||
};
|
||||
|
||||
struct CompletionClientCapabilities
|
||||
{
|
||||
struct CompletionItem
|
||||
{
|
||||
struct TagSupport
|
||||
{
|
||||
std::optional<std::vector<CompletionItemTag>> valueSet;
|
||||
};
|
||||
struct ResolveSupport
|
||||
{
|
||||
std::vector<string> properties;
|
||||
};
|
||||
struct InsertTextModeSupport
|
||||
{
|
||||
std::optional<std::vector<InsertTextMode>> valueSet;
|
||||
};
|
||||
|
||||
boolean snippetSupport;
|
||||
std::optional<boolean> commitCharactersSupport;
|
||||
std::optional<std::vector<MarkupKind>> documentationFormat;
|
||||
std::optional<boolean> deprecatedSupport;
|
||||
std::optional<boolean> preselectSupport;
|
||||
std::optional<TagSupport> tagSupport;
|
||||
boolean insertReplaceSupport;
|
||||
ResolveSupport resolveSupport;
|
||||
std::optional<InsertTextModeSupport> insertTextModeSupport;
|
||||
boolean labelDetailsSupport;
|
||||
};
|
||||
struct CompletionItemKinds
|
||||
{
|
||||
std::optional<std::vector<string>> valueSet;
|
||||
};
|
||||
struct CompletionList
|
||||
{
|
||||
std::vector<string> itemDefault;
|
||||
};
|
||||
|
||||
boolean dynamicRegistration;
|
||||
std::optional<CompletionItem> completionItem;
|
||||
std::optional<CompletionItemKinds> completionItemKind;
|
||||
std::optional<boolean> contextSupport;
|
||||
std::optional<InsertTextMode> insertTextMode;
|
||||
std::optional<CompletionList> completionList;
|
||||
};
|
||||
|
||||
struct CompletionOptions : WorkDoneProgressOptions
|
||||
{
|
||||
struct CompletionItem
|
||||
{
|
||||
std::optional<boolean> labelDetailsSupport;
|
||||
};
|
||||
std::optional<std::vector<string>> triggerCharacters;
|
||||
std::optional<std::vector<string>> allCommitCharacters;
|
||||
std::optional<boolean> resolveProvider;
|
||||
std::optional<CompletionItem> completionItem;
|
||||
};
|
||||
struct CompletionRegistrationOptions : TextDocumentRegistrationOptions, CompletionOptions
|
||||
{
|
||||
};
|
||||
struct CompletionParams : TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams
|
||||
{
|
||||
std::optional<CompletionContext> context;
|
||||
};
|
||||
|
||||
}
|
||||
|
|
@ -1,111 +0,0 @@
|
|||
#pragma once
|
||||
#include "./basic_types.hpp"
|
||||
#include "./progress.hpp"
|
||||
|
||||
namespace lsp::protocol
|
||||
{
|
||||
// Configuration
|
||||
struct ConfigurationItem
|
||||
{
|
||||
std::optional<URI> scopeUri;
|
||||
std::optional<string> section;
|
||||
};
|
||||
|
||||
struct ConfigurationParams
|
||||
{
|
||||
std::vector<ConfigurationParams> items;
|
||||
};
|
||||
|
||||
struct DidChangeConfigurationClientCapabilities
|
||||
{
|
||||
std::optional<boolean> dynamicRegistration;
|
||||
};
|
||||
|
||||
struct DidChangeConfigurationParams
|
||||
{
|
||||
LSPAny settings;
|
||||
};
|
||||
|
||||
// Command Execution
|
||||
struct ExecuteCommandClientCapabilities
|
||||
{
|
||||
std::optional<boolean> dynamicRegistration;
|
||||
};
|
||||
|
||||
struct ExecuteCommandOptions : WorkDoneProgressOptions
|
||||
{
|
||||
std::vector<Command> commands;
|
||||
};
|
||||
|
||||
struct ExecuteCommandRegistrationOptions : ExecuteCommandOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct ExecuteCommandParams : WorkDoneProgressParams
|
||||
{
|
||||
string command;
|
||||
std::optional<std::vector<LSPAny>> arguments;
|
||||
};
|
||||
|
||||
// Message
|
||||
enum class MessageType
|
||||
{
|
||||
kError = 1,
|
||||
kWarning = 2,
|
||||
kInfo = 3,
|
||||
kLog = 4,
|
||||
kDebug = 5
|
||||
};
|
||||
|
||||
struct ShowMessageParams
|
||||
{
|
||||
MessageType type;
|
||||
string message;
|
||||
};
|
||||
|
||||
struct ShowMessageRequestClientCapabilities
|
||||
{
|
||||
struct MessageActionItem
|
||||
{
|
||||
std::optional<boolean> additionalPropertiesSupport;
|
||||
};
|
||||
std::optional<MessageActionItem> messageActionItem;
|
||||
};
|
||||
|
||||
struct MessageActionItem
|
||||
{
|
||||
std::string title;
|
||||
};
|
||||
|
||||
struct ShowMessageRequestParams
|
||||
{
|
||||
MessageType type;
|
||||
string message;
|
||||
std::optional<std::vector<MessageActionItem>> actions;
|
||||
};
|
||||
|
||||
struct ShowDocumentClientCapabilities
|
||||
{
|
||||
boolean support;
|
||||
};
|
||||
|
||||
struct ShowDocumentParams
|
||||
{
|
||||
URI uri;
|
||||
std::optional<boolean> external;
|
||||
std::optional<boolean> takeFocus;
|
||||
std::optional<boolean> selection;
|
||||
};
|
||||
|
||||
struct ShowDocumentResult
|
||||
{
|
||||
boolean success;
|
||||
};
|
||||
|
||||
struct LogMessageParams
|
||||
{
|
||||
MessageType type;
|
||||
string message;
|
||||
};
|
||||
|
||||
}
|
||||
|
|
@ -1,169 +0,0 @@
|
|||
#pragma once
|
||||
#include "./basic_types.hpp"
|
||||
#include "./document_sync.hpp"
|
||||
#include "./progress.hpp"
|
||||
|
||||
namespace lsp::protocol
|
||||
{
|
||||
enum class DiagnosticSeverity
|
||||
{
|
||||
kError = 1,
|
||||
kWarning = 2,
|
||||
kInformation = 3,
|
||||
kHint = 4
|
||||
};
|
||||
|
||||
enum class DiagnosticTag
|
||||
{
|
||||
kUnnecessary = 1,
|
||||
kDeprecated = 2
|
||||
};
|
||||
|
||||
struct DiagnosticRelatedInformation
|
||||
{
|
||||
Location location;
|
||||
string message;
|
||||
};
|
||||
|
||||
struct CodeDescription
|
||||
{
|
||||
string href;
|
||||
};
|
||||
|
||||
struct Diagnostic
|
||||
{
|
||||
Range range;
|
||||
std::optional<DiagnosticSeverity> severity;
|
||||
std::optional<integer> code;
|
||||
std::optional<string> codeDescription;
|
||||
std::optional<string> source;
|
||||
string message;
|
||||
std::optional<std::vector<DiagnosticTag>> tags;
|
||||
std::optional<std::vector<DiagnosticRelatedInformation>> relatedInformation;
|
||||
std::optional<LSPAny> data;
|
||||
};
|
||||
|
||||
struct PublishDiagnosticsClientCapabilities
|
||||
{
|
||||
struct TagSupport
|
||||
{
|
||||
std::vector<DiagnosticTag> valueSet;
|
||||
};
|
||||
std::optional<boolean> relatedInformation;
|
||||
std::optional<TagSupport> tagSupport;
|
||||
std::optional<boolean> versionSupport;
|
||||
std::optional<boolean> codeDescriptionSupport;
|
||||
std::optional<boolean> dataSupport;
|
||||
};
|
||||
|
||||
struct PublishDiagnosticsParams
|
||||
{
|
||||
DocumentUri uri;
|
||||
std::optional<integer> version;
|
||||
std::vector<Diagnostic> diagnostics;
|
||||
};
|
||||
|
||||
struct DiagnosticClientCapabilities
|
||||
{
|
||||
std::optional<boolean> dynamicRegistration;
|
||||
std::optional<boolean> relatedDocumentSupport;
|
||||
};
|
||||
struct DiagnosticOptions : WorkDoneProgressOptions
|
||||
{
|
||||
std::optional<string> identifier;
|
||||
boolean interFileDependencies;
|
||||
boolean workspaceDiagnostics;
|
||||
};
|
||||
struct DiagnosticRegistrationOptions : TextDocumentRegistrationOptions, DiagnosticOptions, StaticRegistrationOptions
|
||||
{
|
||||
};
|
||||
struct DiagnosticParams : WorkDoneProgressParams, PartialResultParams
|
||||
{
|
||||
TextDocumentIdentifier textDocument;
|
||||
std::optional<string> identifier;
|
||||
std::optional<string> previousResultId;
|
||||
};
|
||||
|
||||
using DocumentDiagnosticReportKind = std::string_view;
|
||||
namespace DocumentDiagnosticReportKindLiterals
|
||||
{
|
||||
inline constexpr DocumentDiagnosticReportKind Full = "full";
|
||||
inline constexpr DocumentDiagnosticReportKind Unchanged = "unchanged";
|
||||
}
|
||||
|
||||
struct FullDocumentDiagnosticReport
|
||||
{
|
||||
DocumentDiagnosticReportKind kind = DocumentDiagnosticReportKindLiterals::Full;
|
||||
std::optional<string> resultId;
|
||||
std::vector<Diagnostic> items;
|
||||
};
|
||||
|
||||
struct UnchangedDocumentDiagnosticReport
|
||||
{
|
||||
DocumentDiagnosticReportKind kind = DocumentDiagnosticReportKindLiterals::Unchanged;
|
||||
std::optional<string> resultId;
|
||||
};
|
||||
|
||||
struct RelatedFullDocumentDiagnosticReport : FullDocumentDiagnosticReport
|
||||
{
|
||||
std::optional<std::map<string, std::variant<FullDocumentDiagnosticReport, UnchangedDocumentDiagnosticReport>>> relatedDocuments;
|
||||
};
|
||||
|
||||
struct RelatedUnchangedDocumentDiagnosticReport : UnchangedDocumentDiagnosticReport
|
||||
{
|
||||
std::optional<std::map<string, std::variant<FullDocumentDiagnosticReport, UnchangedDocumentDiagnosticReport>>> relatedDocuments;
|
||||
};
|
||||
|
||||
struct DocumentDiagnosticReportPartialResult
|
||||
{
|
||||
std::optional<std::map<string, std::variant<FullDocumentDiagnosticReport, UnchangedDocumentDiagnosticReport>>> relatedDocuments;
|
||||
};
|
||||
|
||||
using DocumentDiagnosticReport = std::variant<RelatedFullDocumentDiagnosticReport, RelatedUnchangedDocumentDiagnosticReport>;
|
||||
|
||||
struct DiagnosticServerCancellationData
|
||||
{
|
||||
std::optional<boolean> retriggerRequest;
|
||||
};
|
||||
|
||||
struct PreviousResultId
|
||||
{
|
||||
DocumentUri uri;
|
||||
string value;
|
||||
};
|
||||
|
||||
struct WorkspaceDiagnosticParams : WorkDoneProgressParams, PartialResultParams
|
||||
{
|
||||
std::optional<string> identifier;
|
||||
std::vector<PreviousResultId> previousResultIds;
|
||||
};
|
||||
|
||||
struct WorkspaceFullDocumentDiagnosticReport : FullDocumentDiagnosticReport
|
||||
{
|
||||
DocumentUri uri;
|
||||
std::optional<integer> version;
|
||||
};
|
||||
|
||||
struct WorkspaceUnchangedDocumentDiagnosticReport : UnchangedDocumentDiagnosticReport
|
||||
{
|
||||
DocumentUri uri;
|
||||
std::optional<integer> version;
|
||||
};
|
||||
|
||||
using WorkspaceDocumentDiagnosticReport = std::variant<WorkspaceFullDocumentDiagnosticReport, WorkspaceUnchangedDocumentDiagnosticReport>;
|
||||
struct WorkspaceDiagnosticReport
|
||||
{
|
||||
std::vector<WorkspaceDocumentDiagnosticReport> items;
|
||||
};
|
||||
|
||||
struct WorkspaceDiagnosticReportPartialResult
|
||||
{
|
||||
std::vector<WorkspaceDocumentDiagnosticReport> items;
|
||||
};
|
||||
|
||||
struct DiagnosticWorkspaceClientCapabilities
|
||||
{
|
||||
std::optional<boolean> refreshSupport;
|
||||
};
|
||||
|
||||
}
|
||||
|
|
@ -1,209 +0,0 @@
|
|||
#pragma once
|
||||
#include "./basic_types.hpp"
|
||||
#include "./document_sync.hpp"
|
||||
#include "./progress.hpp"
|
||||
|
||||
namespace lsp::protocol
|
||||
{
|
||||
// Document Highlight
|
||||
struct DocumentHighlightClientCapabilities
|
||||
{
|
||||
std::optional<boolean> dynamicRegistration;
|
||||
};
|
||||
|
||||
struct DocumentHighlightOptions : WorkDoneProgressOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct DocumentHighlightRegistrationOptions : TextDocumentRegistrationOptions, DocumentHighlightOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct DocumentHighlightParams : TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams
|
||||
{
|
||||
};
|
||||
|
||||
enum class DocumentHighlightKind
|
||||
{
|
||||
Text = 1,
|
||||
Read = 2,
|
||||
Write = 3
|
||||
};
|
||||
|
||||
struct DocumentHighlight
|
||||
{
|
||||
Range range;
|
||||
DocumentHighlightKind kind;
|
||||
};
|
||||
|
||||
// Document Link
|
||||
struct DocumentLinkClientCapabilities
|
||||
{
|
||||
std::optional<boolean> dynamicRegistration;
|
||||
std::optional<boolean> tooltipSupport;
|
||||
};
|
||||
|
||||
struct DocumentLinkOptions : WorkDoneProgressOptions
|
||||
{
|
||||
boolean resolveProvider;
|
||||
};
|
||||
|
||||
struct DocumentLinkRegistrationOptions : TextDocumentRegistrationOptions, DocumentLinkOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct DocumentLinkParams : WorkDoneProgressParams, PartialResultParams
|
||||
{
|
||||
TextDocumentIdentifier textDocument;
|
||||
};
|
||||
|
||||
struct DocumentLink
|
||||
{
|
||||
Range range;
|
||||
std::optional<URI> target;
|
||||
std::optional<string> tooltip;
|
||||
std::optional<LSPAny> data;
|
||||
};
|
||||
|
||||
// Hover
|
||||
struct HoverClientCapabilities
|
||||
{
|
||||
std::optional<boolean> dynamicRegistration;
|
||||
std::optional<std::vector<MarkupKind>> contentFormat;
|
||||
};
|
||||
|
||||
struct HoverOptions : WorkDoneProgressOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct HoverRegistrationOptions : TextDocumentRegistrationOptions, HoverOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct HoverParams : TextDocumentPositionParams, WorkDoneProgressParams
|
||||
{
|
||||
};
|
||||
|
||||
struct Hover
|
||||
{
|
||||
struct MarkedStringObject
|
||||
{
|
||||
std::string language;
|
||||
std::string value;
|
||||
};
|
||||
|
||||
using MarkedString = std::variant<std::string, MarkedStringObject>;
|
||||
|
||||
std::variant<MarkedString, std::vector<MarkedString>, MarkupContent> contents;
|
||||
std::optional<Range> range;
|
||||
};
|
||||
|
||||
// CodeLens
|
||||
struct CodeLensClientCapabilities
|
||||
{
|
||||
std::optional<boolean> dynamicRegistration;
|
||||
};
|
||||
|
||||
struct CodeLensOptions : WorkDoneProgressOptions
|
||||
{
|
||||
std::optional<boolean> resolveProvider;
|
||||
};
|
||||
|
||||
struct CodeLensRegistrationOptions : TextDocumentRegistrationOptions, CodeLensOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct CodeLensParams : WorkDoneProgressParams, PartialResultParams
|
||||
{
|
||||
TextDocumentIdentifier textDocument;
|
||||
};
|
||||
|
||||
struct CodeLens
|
||||
{
|
||||
Range range;
|
||||
std::optional<Command> command;
|
||||
std::optional<LSPAny> data;
|
||||
};
|
||||
|
||||
struct CodeLensWorkspaceClientCapabilities
|
||||
{
|
||||
std::optional<boolean> refreshSupport;
|
||||
};
|
||||
|
||||
// Fold Range
|
||||
using FoldingRangeKind = std::string_view;
|
||||
namespace FoldingRangeKindLiterals
|
||||
{
|
||||
inline constexpr FoldingRangeKind Comment = "comment";
|
||||
inline constexpr FoldingRangeKind Imports = "imports";
|
||||
inline constexpr FoldingRangeKind Region = "region";
|
||||
}
|
||||
|
||||
struct FoldingRangeClientCapabilities
|
||||
{
|
||||
struct FoldingRangeKinds
|
||||
{
|
||||
std::vector<FoldingRangeKind> valueSet;
|
||||
};
|
||||
struct FoldingRange
|
||||
{
|
||||
std::optional<boolean> collapsedText;
|
||||
};
|
||||
|
||||
std::optional<boolean> dynamicRegistration;
|
||||
std::optional<uinteger> rangeLimit;
|
||||
std::optional<boolean> lineFoldingOnly;
|
||||
std::optional<FoldingRangeKinds> foldingRangeKind;
|
||||
std::optional<FoldingRange> foldingRange;
|
||||
};
|
||||
|
||||
struct FoldingRangeOptions : WorkDoneProgressOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct FoldingRangeRegistrationOptions : TextDocumentRegistrationOptions, FoldingRangeOptions, StaticRegistrationOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct FoldingRangeParams : WorkDoneProgressParams, PartialResultParams
|
||||
{
|
||||
TextDocumentIdentifier textDocument;
|
||||
};
|
||||
|
||||
struct FoldingRange
|
||||
{
|
||||
uinteger startLine;
|
||||
std::optional<uinteger> startCharacter;
|
||||
uinteger endLine;
|
||||
std::optional<uinteger> endCharacter;
|
||||
std::optional<FoldingRangeKind> kind;
|
||||
std::optional<string> collapsedText;
|
||||
};
|
||||
|
||||
// Sekection Range
|
||||
struct SelectionRangeClientCapabilities
|
||||
{
|
||||
std::optional<boolean> dynamicRegistration;
|
||||
};
|
||||
|
||||
struct SelectionRangeOptions : WorkDoneProgressOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct SelectionRangeRegistrationOptions : SelectionRangeOptions, TextDocumentRegistrationOptions, StaticRegistrationOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct SelectionRangeParams : WorkDoneProgressParams, PartialResultParams
|
||||
{
|
||||
TextDocumentIdentifier textDocument;
|
||||
std::vector<Position> positions;
|
||||
};
|
||||
|
||||
struct SelectionRange
|
||||
{
|
||||
Range range;
|
||||
std::optional<SelectionRange*> selectionRange;
|
||||
};
|
||||
|
||||
}
|
||||
|
|
@ -1,120 +0,0 @@
|
|||
#pragma once
|
||||
#include "./basic_types.hpp"
|
||||
#include "./registration.hpp"
|
||||
|
||||
namespace lsp::protocol
|
||||
{
|
||||
struct TextDocumentSyncClientCapabilities
|
||||
{
|
||||
boolean dynamicRegistration;
|
||||
std::optional<boolean> willSave;
|
||||
std::optional<boolean> willSaveWaitUntil;
|
||||
std::optional<boolean> didSave;
|
||||
};
|
||||
|
||||
enum class TextDocumentSyncKind
|
||||
{
|
||||
kNone = 0,
|
||||
kFull = 1,
|
||||
kIncremental = 2
|
||||
};
|
||||
|
||||
struct TextDocumentSyncOptions
|
||||
{
|
||||
std::optional<boolean> openClose;
|
||||
std::optional<TextDocumentSyncKind> change;
|
||||
};
|
||||
|
||||
struct TextDocumentItem
|
||||
{
|
||||
DocumentUri uri;
|
||||
string languageId;
|
||||
integer version;
|
||||
string text;
|
||||
};
|
||||
|
||||
struct TextDocumentIdentifier
|
||||
{
|
||||
DocumentUri uri;
|
||||
};
|
||||
|
||||
struct VersionedTextDocumentIdentifier : TextDocumentIdentifier
|
||||
{
|
||||
integer version;
|
||||
};
|
||||
|
||||
struct OptionalVersionedTextDocumentIdentifier : TextDocumentIdentifier
|
||||
{
|
||||
std::optional<integer> version;
|
||||
};
|
||||
|
||||
struct TextDocumentPositionParams
|
||||
{
|
||||
TextDocumentIdentifier textDocument;
|
||||
Position position;
|
||||
};
|
||||
|
||||
struct DidOpenTextDocumentParams
|
||||
{
|
||||
TextDocumentItem textDocument;
|
||||
};
|
||||
|
||||
struct TextDocumentChangeRegistrationOptions : TextDocumentRegistrationOptions
|
||||
{
|
||||
TextDocumentSyncKind syncKind;
|
||||
};
|
||||
|
||||
struct TextDocumentContentChangeEvent
|
||||
{
|
||||
Range range;
|
||||
uinteger rangeLength;
|
||||
string text;
|
||||
};
|
||||
|
||||
struct DidChangeTextDocumentParams
|
||||
{
|
||||
VersionedTextDocumentIdentifier textDocument;
|
||||
std::vector<TextDocumentContentChangeEvent> contentChanges;
|
||||
};
|
||||
|
||||
enum class TextDocumentSaveReason
|
||||
{
|
||||
Manual = 1,
|
||||
AfterDelay = 2,
|
||||
FocusOut = 3
|
||||
};
|
||||
|
||||
struct WillSaveTextDocumentParams
|
||||
{
|
||||
TextDocumentIdentifier textDocument;
|
||||
TextDocumentSaveReason reason;
|
||||
};
|
||||
|
||||
struct SaveOptions
|
||||
{
|
||||
std::optional<boolean> includeText;
|
||||
};
|
||||
|
||||
struct TextDocumentSaveRegistrationOptions : TextDocumentRegistrationOptions
|
||||
{
|
||||
std::optional<boolean> includeText;
|
||||
};
|
||||
|
||||
struct DidSaveTextDocumentParams
|
||||
{
|
||||
TextDocumentIdentifier textDocument;
|
||||
std::optional<string> text;
|
||||
};
|
||||
|
||||
struct DidCloseTextDocumentParams
|
||||
{
|
||||
TextDocumentIdentifier textDocument;
|
||||
};
|
||||
|
||||
struct TextDocumentEdit
|
||||
{
|
||||
// OptionalVersionedTextDocumentIdentifier textDocument;
|
||||
std::variant<std::vector<TextEdit>, std::vector<AnnotatedTextEdit>> edits;
|
||||
};
|
||||
|
||||
}
|
||||
|
|
@ -1,122 +0,0 @@
|
|||
|
||||
#pragma once
|
||||
#include "./basic_types.hpp"
|
||||
#include "./workspace.hpp"
|
||||
|
||||
namespace lsp::protocol
|
||||
{
|
||||
using FileOperationPatternKind = std::string_view;
|
||||
namespace FileOperationPatternKindLiterals
|
||||
{
|
||||
inline constexpr FileOperationPatternKind File = "file";
|
||||
inline constexpr FileOperationPatternKind Folder = "folder";
|
||||
}
|
||||
|
||||
struct FileOperationPatternOptions
|
||||
{
|
||||
std::optional<boolean> ignoreCase;
|
||||
};
|
||||
|
||||
struct FileOperationPattern
|
||||
{
|
||||
string glob;
|
||||
std::optional<FileOperationPatternKind> matches;
|
||||
std::optional<FileOperationPatternOptions> options;
|
||||
};
|
||||
|
||||
struct FileOperationFilter
|
||||
{
|
||||
std::optional<string> scheme;
|
||||
FileOperationPattern pattern;
|
||||
};
|
||||
|
||||
struct FileCreate
|
||||
{
|
||||
string uri;
|
||||
};
|
||||
|
||||
struct CreateFilesParams
|
||||
{
|
||||
std::vector<FileCreate> files;
|
||||
};
|
||||
|
||||
struct FileOperationRegistrationOptions
|
||||
{
|
||||
std::vector<FileOperationFilter> filters;
|
||||
};
|
||||
|
||||
struct FileRename
|
||||
{
|
||||
string oldUri;
|
||||
string newUri;
|
||||
};
|
||||
|
||||
struct RenameFilesParams
|
||||
{
|
||||
std::vector<FileRename> files;
|
||||
};
|
||||
|
||||
struct FileDelete
|
||||
{
|
||||
string uri;
|
||||
};
|
||||
|
||||
struct DeleteFilesParams
|
||||
{
|
||||
std::vector<FileDelete> files;
|
||||
};
|
||||
|
||||
// File Watching
|
||||
struct DidChangeWatchedFilesClientCapabilities
|
||||
{
|
||||
std::optional<boolean> dynamicRegistration;
|
||||
std::optional<boolean> relativePatternSupport;
|
||||
};
|
||||
|
||||
using Pattern = string;
|
||||
|
||||
struct RelativePattern
|
||||
{
|
||||
std::variant<WorkspaceFolder, URI> baseUri;
|
||||
Pattern pattern;
|
||||
};
|
||||
|
||||
using GlobPattern = std::variant<Pattern, RelativePattern>;
|
||||
|
||||
enum class WatchKind
|
||||
{
|
||||
kCreate = 1,
|
||||
kChange = 2,
|
||||
kDelete = 4
|
||||
};
|
||||
|
||||
struct FileSystemWatcher
|
||||
{
|
||||
GlobPattern globPattern;
|
||||
std::optional<WatchKind> kind;
|
||||
};
|
||||
|
||||
struct DidChangeWatchedFilesRegistrationOptions
|
||||
{
|
||||
std::vector<FileSystemWatcher> watchers;
|
||||
};
|
||||
|
||||
enum class FileChangeType
|
||||
{
|
||||
kCreated = 1,
|
||||
kChanged = 2,
|
||||
kDeleted = 3
|
||||
};
|
||||
|
||||
struct FileEvent
|
||||
{
|
||||
DocumentUri uri;
|
||||
FileChangeType type;
|
||||
};
|
||||
|
||||
struct DidChangeWatchedFilesParams
|
||||
{
|
||||
std::vector<FileEvent> changes;
|
||||
};
|
||||
|
||||
}
|
||||
|
|
@ -1,82 +0,0 @@
|
|||
#pragma once
|
||||
#include "./basic_types.hpp"
|
||||
#include "./document_sync.hpp"
|
||||
#include "./progress.hpp"
|
||||
|
||||
namespace lsp::protocol
|
||||
{
|
||||
// Document Formatting
|
||||
struct DocumentFormattingClientCapabilities
|
||||
{
|
||||
std::optional<boolean> dynamicRegistration;
|
||||
};
|
||||
|
||||
struct DocumentFormattingOptions : WorkDoneProgressOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct DocumentFormattingRegistrationOptions : TextDocumentRegistrationOptions, DocumentFormattingOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct FormattingOptions
|
||||
{
|
||||
uinteger tabSize;
|
||||
boolean insertSpaces;
|
||||
std::optional<boolean> trimTrailingWhitespace;
|
||||
std::optional<boolean> insertFinalNewline;
|
||||
std::optional<boolean> trimFinalNewlines;
|
||||
std::map<string, std::variant<boolean, integer, string>> key;
|
||||
};
|
||||
|
||||
struct DocumentFormattingParams : WorkDoneProgressParams
|
||||
{
|
||||
TextDocumentIdentifier textDocument;
|
||||
FormattingOptions options;
|
||||
};
|
||||
|
||||
// Document Range Formatting
|
||||
struct DocumentRangeFormattingClientCapabilities
|
||||
{
|
||||
std::optional<boolean> dynamicRegistration;
|
||||
};
|
||||
|
||||
struct DocumentRangeFormattingOptions : WorkDoneProgressOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct DocumentRangeFormattingRegistrationOptions : TextDocumentRegistrationOptions, DocumentRangeFormattingOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct DocumentRangeFormattingParams : WorkDoneProgressParams
|
||||
{
|
||||
TextDocumentIdentifier textDocument;
|
||||
Range range;
|
||||
FormattingOptions options;
|
||||
};
|
||||
|
||||
// Document On Type Formatting
|
||||
struct DocumentOnTypeFormattingClientCapabilities
|
||||
{
|
||||
std::optional<boolean> dynamicRegistration;
|
||||
};
|
||||
|
||||
struct DocumentOnTypeFormattingOptions : WorkDoneProgressOptions
|
||||
{
|
||||
string firstTriggerCharacter;
|
||||
std::optional<std::vector<string>> moreTriggerCharacter;
|
||||
};
|
||||
|
||||
struct DocumentOnTypeFormattingRegistrationOptions : TextDocumentRegistrationOptions, DocumentOnTypeFormattingOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct DocumentOnTypeFormattingParams
|
||||
{
|
||||
TextDocumentIdentifier textDocument;
|
||||
Position position;
|
||||
string ch;
|
||||
FormattingOptions options;
|
||||
};
|
||||
}
|
||||
|
|
@ -1,162 +0,0 @@
|
|||
#pragma once
|
||||
#include "./basic_types.hpp"
|
||||
#include "./document_sync.hpp"
|
||||
#include "./progress.hpp"
|
||||
|
||||
namespace lsp::protocol
|
||||
{
|
||||
// Inlay Hints
|
||||
struct InlayHintClientCapabilities
|
||||
{
|
||||
struct ResolveSupport
|
||||
{
|
||||
std::vector<string> properties;
|
||||
};
|
||||
std::optional<boolean> dynamicRegistration;
|
||||
std::optional<ResolveSupport> resolveSupport;
|
||||
};
|
||||
|
||||
struct InlayHintOptions : WorkDoneProgressOptions
|
||||
{
|
||||
std::optional<boolean> resolveProvider;
|
||||
};
|
||||
|
||||
struct InlayHintRegistrationOptions : TextDocumentRegistrationOptions, InlayHintOptions, StaticRegistrationOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct InlayHintParams : WorkDoneProgressParams
|
||||
{
|
||||
TextDocumentIdentifier textDocument;
|
||||
Range range;
|
||||
};
|
||||
|
||||
struct InlayHintLabelPart
|
||||
{
|
||||
string value;
|
||||
std::optional<std::variant<string, MarkupContent>> tooltip;
|
||||
std::optional<Location> location;
|
||||
std::optional<Command> command;
|
||||
};
|
||||
|
||||
enum class InlayHintKind
|
||||
{
|
||||
kType = 1,
|
||||
kParameter = 2
|
||||
};
|
||||
|
||||
struct InlayHint
|
||||
{
|
||||
Position position;
|
||||
std::variant<string, std::vector<InlayHintLabelPart>> label;
|
||||
std::optional<InlayHintKind> kind;
|
||||
std::optional<std::vector<TextEdit>> textEdits;
|
||||
;
|
||||
std::optional<std::variant<string, MarkupContent>> tooltip;
|
||||
std::optional<boolean> paddingLeft;
|
||||
std::optional<boolean> paddingRight;
|
||||
std::optional<LSPAny> data;
|
||||
};
|
||||
|
||||
struct InlayHintWorkspaceClientCapabilities
|
||||
{
|
||||
std::optional<boolean> refreshSupport;
|
||||
};
|
||||
|
||||
// Inline Values
|
||||
struct InlineValueClientCapabilities
|
||||
{
|
||||
std::optional<boolean> dynamicRegistration;
|
||||
};
|
||||
|
||||
struct InlineValueOptions : WorkDoneProgressOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct InlineValueRegistrationOptions : TextDocumentRegistrationOptions, InlineValueOptions, StaticRegistrationOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct InlineValueContent
|
||||
{
|
||||
integer frameId;
|
||||
Range stoppedLocation;
|
||||
};
|
||||
|
||||
struct InlineValueText
|
||||
{
|
||||
Range range;
|
||||
string text;
|
||||
};
|
||||
|
||||
struct InlineValueParams : WorkDoneProgressParams
|
||||
{
|
||||
TextDocumentIdentifier textDocument;
|
||||
Range range;
|
||||
InlineValueContent context;
|
||||
};
|
||||
|
||||
struct InlineValueVariableLookup
|
||||
{
|
||||
Range range;
|
||||
std::optional<string> variableName;
|
||||
std::optional<boolean> caseSensitiveLookup;
|
||||
};
|
||||
|
||||
struct InlineValueEvaluatableExpression
|
||||
{
|
||||
Range range;
|
||||
std::optional<string> expression;
|
||||
};
|
||||
using InlineValue = std::variant<InlineValueText, InlineValueVariableLookup, InlineValueEvaluatableExpression>;
|
||||
|
||||
struct InlineValueWorkspaceClientCapabilities
|
||||
{
|
||||
std::optional<boolean> refreshSupport;
|
||||
};
|
||||
|
||||
// Moniker
|
||||
struct MonikerClientCapabilities
|
||||
{
|
||||
std::optional<boolean> dynamicRegistration;
|
||||
};
|
||||
|
||||
struct MonikerOptions : WorkDoneProgressOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct MonikerRegistrationOptions : TextDocumentRegistrationOptions, MonikerOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct MonikerParams : TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams
|
||||
{
|
||||
};
|
||||
|
||||
using UniquenessLevel = std::string_view;
|
||||
namespace UniquenessLevelLiterals
|
||||
{
|
||||
inline constexpr UniquenessLevel Document = "document";
|
||||
inline constexpr UniquenessLevel Project = "project";
|
||||
inline constexpr UniquenessLevel Group = "group";
|
||||
inline constexpr UniquenessLevel Scheme = "scheme";
|
||||
inline constexpr UniquenessLevel Global = "global";
|
||||
}
|
||||
|
||||
using MonikerKind = std::string_view;
|
||||
namespace MonikerKindLiterals
|
||||
{
|
||||
inline constexpr MonikerKind Import = "import";
|
||||
inline constexpr MonikerKind Export = "export";
|
||||
inline constexpr MonikerKind Local = "local";
|
||||
}
|
||||
|
||||
struct Moniker
|
||||
{
|
||||
string scheme;
|
||||
string identifier;
|
||||
UniquenessLevel unique;
|
||||
std::optional<MonikerKind> kind;
|
||||
};
|
||||
|
||||
}
|
||||
|
|
@ -1,193 +0,0 @@
|
|||
#pragma once
|
||||
#include "./basic_types.hpp"
|
||||
|
||||
namespace lsp::protocol
|
||||
{
|
||||
|
||||
inline LSPAny::LSPAny() :
|
||||
value(nullptr) {}
|
||||
|
||||
inline LSPAny::LSPAny(const LSPAny& other) :
|
||||
value(other.value) {}
|
||||
|
||||
inline LSPAny::LSPAny(LSPAny&& other) noexcept :
|
||||
value(std::move(other.value)) {}
|
||||
|
||||
inline LSPAny::LSPAny(const std::map<string, LSPAny>& val) :
|
||||
value(val) {}
|
||||
|
||||
inline LSPAny::LSPAny(std::map<string, LSPAny>&& val) :
|
||||
value(std::move(val)) {}
|
||||
|
||||
inline LSPAny::LSPAny(const std::vector<LSPAny>& val) :
|
||||
value(val) {}
|
||||
|
||||
inline LSPAny::LSPAny(std::vector<LSPAny>&& val) :
|
||||
value(std::move(val)) {}
|
||||
|
||||
inline LSPAny::LSPAny(const string& val) :
|
||||
value(val) {}
|
||||
|
||||
inline LSPAny::LSPAny(string&& val) :
|
||||
value(std::move(val)) {}
|
||||
|
||||
inline LSPAny::LSPAny(const char* val) :
|
||||
value(string(val)) {}
|
||||
|
||||
inline LSPAny::LSPAny(int val) :
|
||||
value(static_cast<decimal>(val)) {}
|
||||
|
||||
inline LSPAny::LSPAny(long val) :
|
||||
value(static_cast<decimal>(val)) {}
|
||||
|
||||
inline LSPAny::LSPAny(long long val) :
|
||||
value(static_cast<decimal>(val)) {}
|
||||
|
||||
inline LSPAny::LSPAny(unsigned int val) :
|
||||
value(static_cast<decimal>(val)) {}
|
||||
|
||||
inline LSPAny::LSPAny(unsigned long val) :
|
||||
value(static_cast<decimal>(val)) {}
|
||||
|
||||
inline LSPAny::LSPAny(unsigned long long val) :
|
||||
value(static_cast<decimal>(val)) {}
|
||||
|
||||
inline LSPAny::LSPAny(float val) :
|
||||
value(static_cast<decimal>(val)) {}
|
||||
|
||||
inline LSPAny::LSPAny(double val) :
|
||||
value(val) {}
|
||||
|
||||
inline LSPAny::LSPAny(long double val) :
|
||||
value(static_cast<decimal>(val)) {}
|
||||
|
||||
inline LSPAny::LSPAny(boolean val) :
|
||||
value(val) {}
|
||||
|
||||
inline LSPAny::LSPAny(std::nullptr_t) :
|
||||
value(nullptr) {}
|
||||
|
||||
// 赋值操作符
|
||||
inline LSPAny& LSPAny::operator=(const LSPAny& other)
|
||||
{
|
||||
value = other.value;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline LSPAny& LSPAny::operator=(LSPAny&& other) noexcept
|
||||
{
|
||||
value = std::move(other.value);
|
||||
return *this;
|
||||
}
|
||||
|
||||
// 针对每种支持的类型的赋值操作符
|
||||
inline LSPAny& LSPAny::operator=(const std::map<string, LSPAny>& val)
|
||||
{
|
||||
value = val;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline LSPAny& LSPAny::operator=(std::map<string, LSPAny>&& val)
|
||||
{
|
||||
value = std::move(val);
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline LSPAny& LSPAny::operator=(const std::vector<LSPAny>& val)
|
||||
{
|
||||
value = val;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline LSPAny& LSPAny::operator=(std::vector<LSPAny>&& val)
|
||||
{
|
||||
value = std::move(val);
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline LSPAny& LSPAny::operator=(const string& val)
|
||||
{
|
||||
value = val;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline LSPAny& LSPAny::operator=(string&& val)
|
||||
{
|
||||
value = std::move(val);
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline LSPAny& LSPAny::operator=(const char* val)
|
||||
{
|
||||
value = string(val);
|
||||
return *this;
|
||||
}
|
||||
|
||||
// 所有数字类型都转换为 decimal
|
||||
inline LSPAny& LSPAny::operator=(int val)
|
||||
{
|
||||
value = static_cast<decimal>(val);
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline LSPAny& LSPAny::operator=(long val)
|
||||
{
|
||||
value = static_cast<decimal>(val);
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline LSPAny& LSPAny::operator=(long long val)
|
||||
{
|
||||
value = static_cast<decimal>(val);
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline LSPAny& LSPAny::operator=(unsigned int val)
|
||||
{
|
||||
value = static_cast<decimal>(val);
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline LSPAny& LSPAny::operator=(unsigned long val)
|
||||
{
|
||||
value = static_cast<decimal>(val);
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline LSPAny& LSPAny::operator=(unsigned long long val)
|
||||
{
|
||||
value = static_cast<decimal>(val);
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline LSPAny& LSPAny::operator=(float val)
|
||||
{
|
||||
value = static_cast<decimal>(val);
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline LSPAny& LSPAny::operator=(double val)
|
||||
{
|
||||
value = val;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline LSPAny& LSPAny::operator=(long double val)
|
||||
{
|
||||
value = static_cast<decimal>(val);
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline LSPAny& LSPAny::operator=(boolean val)
|
||||
{
|
||||
value = val;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline LSPAny& LSPAny::operator=(std::nullptr_t)
|
||||
{
|
||||
value = nullptr;
|
||||
return *this;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,64 +0,0 @@
|
|||
#pragma once
|
||||
#include "./basic_types.hpp"
|
||||
|
||||
namespace lsp::protocol
|
||||
{
|
||||
enum class ErrorCode : int
|
||||
{
|
||||
kParseError = -32700,
|
||||
kInvalidRequest = -32600,
|
||||
kMethodNotFound = -32601,
|
||||
kInvalidParams = -32602,
|
||||
kInternalError = -32603,
|
||||
|
||||
kJsonrpcReservedErrorRangeStart = -32099,
|
||||
kServerNotInitialized = -32002,
|
||||
kUnknownErrorCode = -32001,
|
||||
kJsonrpcReservedErrorRangeEnd = -32000,
|
||||
kLspReservedErrorRangeStart = -32899,
|
||||
kRequestFailed = -32803,
|
||||
kServerCancelled = -32802,
|
||||
kContentModified = -32801,
|
||||
kRequestCancelled = -32800,
|
||||
kLspReservedErrorRangeEnd = -32800
|
||||
};
|
||||
|
||||
struct Message
|
||||
{
|
||||
string jsonrpc = "2.0";
|
||||
};
|
||||
|
||||
struct RequestMessage: Message
|
||||
{
|
||||
std::variant<integer, string> id;
|
||||
string method;
|
||||
std::optional<std::variant<LSPArray, LSPObject>> params;
|
||||
};
|
||||
|
||||
struct ResponseError: Message
|
||||
{
|
||||
ErrorCode code;
|
||||
string message;
|
||||
std::optional<LSPAny> data;
|
||||
};
|
||||
|
||||
struct ResponseMessage: Message
|
||||
{
|
||||
std::variant<integer, string> id;
|
||||
std::optional<LSPAny> result;
|
||||
std::optional<ResponseError> error;
|
||||
};
|
||||
|
||||
struct NotificationMessage: Message
|
||||
{
|
||||
string method;
|
||||
std::optional<LSPAny> params;
|
||||
};
|
||||
|
||||
struct CancelParams
|
||||
{
|
||||
std::variant<integer, string> id;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -1,199 +0,0 @@
|
|||
#pragma once
|
||||
#include "./basic_types.hpp"
|
||||
#include "./document_sync.hpp"
|
||||
#include "./progress.hpp"
|
||||
#include "./symbols.hpp"
|
||||
|
||||
namespace lsp::protocol
|
||||
{
|
||||
// Declaration
|
||||
struct DeclarationClientCapabilities
|
||||
{
|
||||
std::optional<boolean> dynamicRegistration;
|
||||
std::optional<boolean> linkSupport;
|
||||
};
|
||||
|
||||
struct DeclarationOptions : WorkDoneProgressOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct DeclarationRegistrationOptions : DeclarationOptions, TextDocumentRegistrationOptions, StaticRegistrationOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct DeclarationParams : TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams
|
||||
{
|
||||
};
|
||||
|
||||
// Definition
|
||||
struct DefinitionClientCapabilities
|
||||
{
|
||||
std::optional<boolean> dynamicRegistration;
|
||||
std::optional<boolean> linkSupport;
|
||||
};
|
||||
|
||||
struct DefinitionOptions : WorkDoneProgressOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct DefinitionRegistrationOptions : TextDocumentRegistrationOptions, DefinitionOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct DefinitionParams : TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams
|
||||
{
|
||||
};
|
||||
|
||||
// TypeDefinition
|
||||
struct TypeDefinitionClientCapabilities
|
||||
{
|
||||
std::optional<boolean> dynamicRegistration;
|
||||
std::optional<boolean> linkSupport;
|
||||
};
|
||||
|
||||
struct TypeDefinitionOptions : WorkDoneProgressOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct TypeDefinitionRegistrationOptions : TextDocumentRegistrationOptions, TypeDefinitionOptions, StaticRegistrationOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct TypeDefinitionParams : TextDocumentPositionParams, WorkDoneProgressParams
|
||||
{
|
||||
};
|
||||
|
||||
// Implementation
|
||||
struct ImplementationClientCapabilities
|
||||
{
|
||||
std::optional<boolean> dynamicRegistration;
|
||||
std::optional<boolean> linkSupport;
|
||||
};
|
||||
|
||||
struct ImplementationOptions : WorkDoneProgressOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct ImplementationRegistrationOptions : TextDocumentRegistrationOptions, ImplementationOptions, StaticRegistrationOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct ImplementationParams : WorkDoneProgressParams, PartialResultParams
|
||||
{
|
||||
};
|
||||
|
||||
// Reference
|
||||
struct ReferenceContext
|
||||
{
|
||||
boolean includeDeclaration;
|
||||
};
|
||||
struct ReferenceClientCapabilities
|
||||
{
|
||||
std::optional<boolean> dynamicRegistration;
|
||||
};
|
||||
struct ReferenceOptions : WorkDoneProgressOptions
|
||||
{
|
||||
};
|
||||
struct ReferenceRegistrationOptions : TextDocumentRegistrationOptions, ReferenceOptions
|
||||
{
|
||||
};
|
||||
struct ReferenceParams : TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams
|
||||
{
|
||||
ReferenceContext context;
|
||||
};
|
||||
|
||||
// CallHierarchy
|
||||
struct CallHierarchyClientCapabilities
|
||||
{
|
||||
std::optional<boolean> dynamicRegistration;
|
||||
};
|
||||
|
||||
struct CallHierarchyOptions : WorkDoneProgressOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct CallHierarchyRegistrationOptions : TextDocumentRegistrationOptions, CallHierarchyOptions, StaticRegistrationOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct CallHierarchyParams : TextDocumentPositionParams, WorkDoneProgressParams
|
||||
{
|
||||
};
|
||||
|
||||
struct CallHierarchyItem
|
||||
{
|
||||
string name;
|
||||
SymbolKind kind;
|
||||
std::vector<SymbolTag> tags;
|
||||
DocumentUri uri;
|
||||
Range range;
|
||||
Range selectionRange;
|
||||
std::optional<LSPAny> data;
|
||||
};
|
||||
|
||||
struct CallHierarchyIncomingCallsParams : WorkDoneProgressParams, PartialResultParams
|
||||
{
|
||||
CallHierarchyItem item;
|
||||
};
|
||||
|
||||
struct CallHierarchyIncomingCall
|
||||
{
|
||||
CallHierarchyItem from;
|
||||
std::vector<Range> fromRanges;
|
||||
};
|
||||
|
||||
struct CallHierarchyOutgoingCallsParams : WorkDoneProgressParams, PartialResultParams
|
||||
{
|
||||
CallHierarchyItem item;
|
||||
};
|
||||
|
||||
struct CallHierarchyOutgoingCall
|
||||
{
|
||||
CallHierarchyItem from;
|
||||
std::vector<Range> fromRanges;
|
||||
};
|
||||
|
||||
// TypeHierarchy
|
||||
struct TypeHierarchyClientCapabilities
|
||||
{
|
||||
std::optional<boolean> dynamicRegistration;
|
||||
};
|
||||
|
||||
struct TypeHierarchyOptions : WorkDoneProgressOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct TypeHierarchyRegistrationOptions : TextDocumentRegistrationOptions, TypeHierarchyOptions, StaticRegistrationOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct TypeHierarchyParams : TextDocumentPositionParams, WorkDoneProgressParams
|
||||
{
|
||||
};
|
||||
|
||||
struct TypeHierarchyPrepareParams : TextDocumentPositionParams, WorkDoneProgressParams
|
||||
{
|
||||
};
|
||||
|
||||
struct TypeHierarchyItem
|
||||
{
|
||||
string name;
|
||||
SymbolKind kind;
|
||||
std::vector<SymbolTag> tags;
|
||||
DocumentUri uri;
|
||||
Range range;
|
||||
Range selectionRange;
|
||||
std::optional<LSPAny> data;
|
||||
};
|
||||
|
||||
struct TypeHierarchySupertypesParams : WorkDoneProgressParams, PartialResultParams
|
||||
{
|
||||
TypeHierarchyItem item;
|
||||
};
|
||||
|
||||
struct TypeHierarchySubtypesParams : WorkDoneProgressParams, PartialResultParams
|
||||
{
|
||||
TypeHierarchyItem item;
|
||||
};
|
||||
|
||||
}
|
||||
|
|
@ -1,148 +0,0 @@
|
|||
#pragma once
|
||||
#include "./basic_types.hpp"
|
||||
#include "./document_sync.hpp"
|
||||
|
||||
namespace lsp::protocol
|
||||
{
|
||||
enum class NotebookCellKind
|
||||
{
|
||||
Markup = 1,
|
||||
Code = 2,
|
||||
};
|
||||
|
||||
struct ExecutionSummary
|
||||
{
|
||||
uinteger executionOrder;
|
||||
std::optional<boolean> success;
|
||||
};
|
||||
|
||||
struct NotebookCell
|
||||
{
|
||||
NotebookCellKind kind;
|
||||
DocumentUri document;
|
||||
std::optional<LSPObject> metadata;
|
||||
std::optional<ExecutionSummary> executionSummary;
|
||||
};
|
||||
|
||||
struct NotebookDocument
|
||||
{
|
||||
URI uri;
|
||||
string notebookType;
|
||||
integer version;
|
||||
LSPObject metadata;
|
||||
std::vector<NotebookCell> cells;
|
||||
};
|
||||
|
||||
struct NotebookDocumentFilter
|
||||
{
|
||||
string notebookType;
|
||||
std::optional<string> scheme;
|
||||
std::optional<string> pattern;
|
||||
};
|
||||
|
||||
struct NotebookCellTextDocumentFilter
|
||||
{
|
||||
std::variant<string, NotebookDocumentFilter> notebook;
|
||||
std::optional<string> language;
|
||||
};
|
||||
|
||||
struct NotebookSelector
|
||||
{
|
||||
struct Cell
|
||||
{
|
||||
string language;
|
||||
};
|
||||
|
||||
std::variant<string, NotebookDocumentFilter> notebook;
|
||||
std::optional<std::vector<Cell>> cells;
|
||||
};
|
||||
|
||||
struct NotebookDocumentSyncOptions
|
||||
{
|
||||
std::vector<NotebookSelector> notebookSelector;
|
||||
std::optional<boolean> save;
|
||||
};
|
||||
|
||||
struct NotebookDocumentSyncRegistrationOptions : NotebookDocumentSyncOptions, StaticRegistrationOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct NotebookDocumentSyncClientCapabilities
|
||||
{
|
||||
std::optional<boolean> dynamicRegistration;
|
||||
std::optional<boolean> executionSummarySupport;
|
||||
};
|
||||
|
||||
struct NotebookDocumentClientCapabilities
|
||||
{
|
||||
NotebookDocumentSyncClientCapabilities synchronization;
|
||||
};
|
||||
|
||||
struct DidOpenNotebookDocumentParams
|
||||
{
|
||||
NotebookDocument notebookDocument;
|
||||
std::vector<TextDocumentItem> cellTextDocuments;
|
||||
};
|
||||
|
||||
struct VersionedNotebookDocumentIdentifier
|
||||
{
|
||||
integer version;
|
||||
URI uri;
|
||||
};
|
||||
|
||||
struct NotebookCellArrayChange
|
||||
{
|
||||
uinteger start;
|
||||
uinteger deleteCount;
|
||||
std::optional<std::vector<NotebookCell>> cells;
|
||||
};
|
||||
|
||||
struct NotebookDocumentChangeEvent
|
||||
{
|
||||
struct Cell
|
||||
{
|
||||
struct Structure
|
||||
{
|
||||
NotebookCellArrayChange array;
|
||||
std::optional<std::vector<TextDocumentItem>> didOpen;
|
||||
std::optional<std::vector<TextDocumentIdentifier>> didClose;
|
||||
};
|
||||
|
||||
struct TextContent
|
||||
{
|
||||
VersionedTextDocumentIdentifier document;
|
||||
std::vector<TextDocumentContentChangeEvent> changes;
|
||||
};
|
||||
|
||||
std::optional<Structure> structure;
|
||||
std::optional<std::vector<NotebookCell>> data;
|
||||
std::optional<TextContent> textContent;
|
||||
};
|
||||
|
||||
std::optional<LSPObject> metadata;
|
||||
std::optional<std::vector<Cell>> cells;
|
||||
};
|
||||
|
||||
struct DidChangeNotebookDocumentParams
|
||||
{
|
||||
VersionedNotebookDocumentIdentifier notebookDocument;
|
||||
NotebookDocumentChangeEvent change;
|
||||
};
|
||||
|
||||
struct NotebookDocumentIdentifier
|
||||
{
|
||||
URI uri;
|
||||
};
|
||||
|
||||
struct DidSaveNotebookDocumentParams
|
||||
{
|
||||
NotebookDocumentIdentifier notebookDocument;
|
||||
};
|
||||
|
||||
struct DidCloseNotebookDocumentParams
|
||||
{
|
||||
NotebookDocumentIdentifier notebookDocument;
|
||||
std::vector<TextDocumentIdentifier> cellTextDocuments;
|
||||
};
|
||||
|
||||
}
|
||||
|
|
@ -1,73 +0,0 @@
|
|||
#pragma once
|
||||
#include "./basic_types.hpp"
|
||||
|
||||
namespace lsp::protocol
|
||||
{
|
||||
struct WorkDoneProgressBegin
|
||||
{
|
||||
string kind = "begin";
|
||||
string title;
|
||||
boolean cancellable;
|
||||
std::optional<string> message;
|
||||
uinteger percentage;
|
||||
};
|
||||
|
||||
struct WorkDoneProgressReport
|
||||
{
|
||||
string kind = "report";
|
||||
boolean cancellable;
|
||||
std::optional<string> message;
|
||||
uinteger percentage;
|
||||
};
|
||||
|
||||
struct WorkDoneProgressEnd
|
||||
{
|
||||
string kind = "end";
|
||||
string message;
|
||||
};
|
||||
|
||||
struct WorkDoneProgressParams
|
||||
{
|
||||
ProgressToken workDoneToken;
|
||||
};
|
||||
|
||||
struct WorkDoneProgressOptions
|
||||
{
|
||||
boolean workDoneProgress;
|
||||
};
|
||||
|
||||
struct PartialResultParams
|
||||
{
|
||||
ProgressToken partialResultToken;
|
||||
};
|
||||
|
||||
struct WorkDoneProgressCreateParams
|
||||
{
|
||||
ProgressToken token;
|
||||
};
|
||||
|
||||
struct WorkDoneProgressCancelParams
|
||||
{
|
||||
ProgressToken token;
|
||||
};
|
||||
|
||||
using TraceValue = std::string_view;
|
||||
namespace TraceValueLiterals
|
||||
{
|
||||
inline constexpr TraceValue Off = "off";
|
||||
inline constexpr TraceValue Messages = "messages";
|
||||
inline constexpr TraceValue Verbose = "verbose";
|
||||
}
|
||||
|
||||
struct SetTraceParams
|
||||
{
|
||||
TraceValue value;
|
||||
};
|
||||
|
||||
struct LogTraceParams
|
||||
{
|
||||
string message;
|
||||
std::optional<string> verbose;
|
||||
};
|
||||
|
||||
}
|
||||
|
|
@ -1,39 +0,0 @@
|
|||
#pragma once
|
||||
#include "./basic_types.hpp"
|
||||
|
||||
namespace lsp::protocol
|
||||
{
|
||||
struct Registration
|
||||
{
|
||||
string id;
|
||||
string method;
|
||||
std::optional<LSPAny> registerOptions;
|
||||
};
|
||||
|
||||
struct RegistrationParams
|
||||
{
|
||||
std::vector<Registration> registrations;
|
||||
};
|
||||
|
||||
struct StaticRegistrationOptions
|
||||
{
|
||||
std::optional<string> id;
|
||||
};
|
||||
|
||||
struct TextDocumentRegistrationOptions
|
||||
{
|
||||
std::optional<DocumentSelector> documentSelector;
|
||||
};
|
||||
|
||||
struct Unregistration
|
||||
{
|
||||
string id;
|
||||
string method;
|
||||
};
|
||||
|
||||
struct UnregistrationParams
|
||||
{
|
||||
std::vector<Unregistration> unregistration;
|
||||
};
|
||||
|
||||
} // namespace lsp::protocol
|
||||
|
|
@ -1,64 +0,0 @@
|
|||
#pragma once
|
||||
#include "./basic_types.hpp"
|
||||
#include "./document_sync.hpp"
|
||||
#include "./progress.hpp"
|
||||
|
||||
namespace lsp::protocol
|
||||
{
|
||||
enum class PrepareSupportDefaultBehavior
|
||||
{
|
||||
kIdentifier = 1
|
||||
};
|
||||
|
||||
// Rename
|
||||
struct RenameClientCapabilities
|
||||
{
|
||||
std::optional<boolean> dynamicRegistration;
|
||||
std::optional<boolean> prepareSupport;
|
||||
std::optional<PrepareSupportDefaultBehavior> prepareSupportDefaultBehavior;
|
||||
std::optional<boolean> honorsChangeAnnotations;
|
||||
};
|
||||
|
||||
struct RenameOptions : WorkDoneProgressOptions
|
||||
{
|
||||
std::optional<boolean> prepareProvider;
|
||||
};
|
||||
|
||||
struct RenameRegistrationOptions : TextDocumentRegistrationOptions, RenameOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct RenameParams : TextDocumentPositionParams, WorkDoneProgressParams
|
||||
{
|
||||
string newName;
|
||||
};
|
||||
|
||||
struct PrepareRenameParams : TextDocumentPositionParams, WorkDoneProgressParams
|
||||
{
|
||||
};
|
||||
|
||||
// Linked Editing Range
|
||||
struct LinkedEditingRangeClientCapabilities
|
||||
{
|
||||
std::optional<boolean> dynamicRegistration;
|
||||
};
|
||||
|
||||
struct LinkedEditingRangeOptions : WorkDoneProgressOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct LinkedEditingRangeRegistrationOptions : TextDocumentRegistrationOptions, LinkedEditingRangeOptions, StaticRegistrationOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct LinkedEditingRangeParams : TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams
|
||||
{
|
||||
};
|
||||
|
||||
struct LinkedEditingRanges
|
||||
{
|
||||
std::vector<Range> ranges;
|
||||
std::optional<string> wordPattern;
|
||||
};
|
||||
|
||||
}
|
||||
|
|
@ -1,151 +0,0 @@
|
|||
#pragma once
|
||||
#include "./basic_types.hpp"
|
||||
#include "./document_sync.hpp"
|
||||
#include "./progress.hpp"
|
||||
|
||||
namespace lsp::protocol
|
||||
{
|
||||
using SemanticTokenType = std::string_view;
|
||||
namespace SemanticTokenTypesLiterals
|
||||
{
|
||||
inline constexpr SemanticTokenType Namespace = "namespace";
|
||||
inline constexpr SemanticTokenType Type = "type";
|
||||
inline constexpr SemanticTokenType Class = "class";
|
||||
inline constexpr SemanticTokenType Enum = "enum";
|
||||
inline constexpr SemanticTokenType Interface = "interface";
|
||||
inline constexpr SemanticTokenType Struct = "struct";
|
||||
inline constexpr SemanticTokenType TypeParameter = "typeParameter";
|
||||
inline constexpr SemanticTokenType Parameter = "parameter";
|
||||
inline constexpr SemanticTokenType Variable = "variable";
|
||||
inline constexpr SemanticTokenType Property = "property";
|
||||
inline constexpr SemanticTokenType EnumMember = "enumMember";
|
||||
inline constexpr SemanticTokenType Event = "event";
|
||||
inline constexpr SemanticTokenType Function = "function";
|
||||
inline constexpr SemanticTokenType Method = "method";
|
||||
inline constexpr SemanticTokenType Macro = "macro";
|
||||
inline constexpr SemanticTokenType Keyword = "keyword";
|
||||
inline constexpr SemanticTokenType Modifier = "modifier";
|
||||
inline constexpr SemanticTokenType Comment = "comment";
|
||||
inline constexpr SemanticTokenType String = "string";
|
||||
inline constexpr SemanticTokenType Number = "number";
|
||||
inline constexpr SemanticTokenType Regexp = "regexp";
|
||||
inline constexpr SemanticTokenType Operator = "operator";
|
||||
inline constexpr SemanticTokenType Decorator = "decorator";
|
||||
}
|
||||
|
||||
using SemanticTokenModifiers = std::string_view;
|
||||
namespace SemanticTokenModifiersLiterals
|
||||
{
|
||||
inline constexpr SemanticTokenModifiers Declaration = "declaration";
|
||||
inline constexpr SemanticTokenModifiers Definition = "definition";
|
||||
inline constexpr SemanticTokenModifiers Readonly = "readonly";
|
||||
inline constexpr SemanticTokenModifiers Static = "static";
|
||||
inline constexpr SemanticTokenModifiers Deprecated = "deprecated";
|
||||
inline constexpr SemanticTokenModifiers Abstract = "abstract";
|
||||
inline constexpr SemanticTokenModifiers Async = "async";
|
||||
inline constexpr SemanticTokenModifiers Modification = "modification";
|
||||
inline constexpr SemanticTokenModifiers Documentation = "documentation";
|
||||
inline constexpr SemanticTokenModifiers DefaultLibrary = "defaultLibrary";
|
||||
}
|
||||
|
||||
using TokenFormat = std::string_view;
|
||||
namespace TokenFormatLiterals
|
||||
{
|
||||
inline constexpr TokenFormat Relative = "relative";
|
||||
}
|
||||
|
||||
struct SemanticTokensLegend
|
||||
{
|
||||
std::vector<string> tokenType;
|
||||
std::vector<string> tokenModifiers;
|
||||
};
|
||||
|
||||
struct SemanticTokensClientCapabilities
|
||||
{
|
||||
struct Requests
|
||||
{
|
||||
struct Full
|
||||
{
|
||||
std::optional<boolean> delta;
|
||||
};
|
||||
|
||||
std::optional<boolean> range;
|
||||
std::variant<Full, boolean> full;
|
||||
};
|
||||
|
||||
std::optional<boolean> dynamicRegistration;
|
||||
std::vector<string> tokenType;
|
||||
std::vector<string> tokenModifiers;
|
||||
std::optional<boolean> overlappingTokenSupport;
|
||||
std::optional<boolean> multilineTokenSupport;
|
||||
std::optional<boolean> serverCancelSupport;
|
||||
std::optional<boolean> augmentsSyntaxTokens;
|
||||
};
|
||||
|
||||
struct SemanticTokensOptions : WorkDoneProgressOptions
|
||||
{
|
||||
struct Full
|
||||
{
|
||||
std::optional<boolean> delta;
|
||||
};
|
||||
|
||||
SemanticTokensLegend legend;
|
||||
std::optional<boolean> range;
|
||||
std::variant<Full, boolean> full;
|
||||
};
|
||||
|
||||
struct SemanticTokensRegistrationOptions : TextDocumentRegistrationOptions, SemanticTokensOptions, StaticRegistrationOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct SemanticTokensParams : WorkDoneProgressParams, PartialResultParams
|
||||
{
|
||||
TextDocumentIdentifier textDocument;
|
||||
};
|
||||
|
||||
struct SemanticTokens
|
||||
{
|
||||
std::optional<string> resultId;
|
||||
std::vector<uinteger> data;
|
||||
};
|
||||
|
||||
struct SemanticTokensPartialResult
|
||||
{
|
||||
std::vector<uinteger> data;
|
||||
};
|
||||
|
||||
struct SemanticTokensDeltaParams : WorkDoneProgressParams, PartialResultParams
|
||||
{
|
||||
TextDocumentIdentifier textDocument;
|
||||
string previousResultId;
|
||||
};
|
||||
|
||||
struct SemanticTokensEdit
|
||||
{
|
||||
uinteger start;
|
||||
uinteger deleteCount;
|
||||
std::optional<uinteger> data;
|
||||
};
|
||||
|
||||
struct SemanticTokensDelta
|
||||
{
|
||||
std::optional<string> resultId;
|
||||
std::optional<std::vector<SemanticTokensEdit>> edits;
|
||||
};
|
||||
|
||||
struct SemanticTokensDeltaPartialResult
|
||||
{
|
||||
std::optional<std::vector<SemanticTokensEdit>> edits;
|
||||
};
|
||||
|
||||
struct SemanticTokensRangeParams : WorkDoneProgressParams, PartialResultParams
|
||||
{
|
||||
TextDocumentIdentifier textDocument;
|
||||
Range range;
|
||||
};
|
||||
|
||||
struct SemanticTokensWorkspaceClientCapabilities
|
||||
{
|
||||
std::optional<boolean> refreshSupport;
|
||||
};
|
||||
}
|
||||
|
|
@ -1,78 +0,0 @@
|
|||
#pragma once
|
||||
#include "./basic_types.hpp"
|
||||
#include "./document_sync.hpp"
|
||||
#include "./progress.hpp"
|
||||
|
||||
namespace lsp::protocol
|
||||
{
|
||||
struct SignatureHelpClientCapabilities
|
||||
{
|
||||
struct SignatureInformation
|
||||
{
|
||||
struct ParammeterInformation
|
||||
{
|
||||
std::optional<boolean> labelOffsetSupport;
|
||||
};
|
||||
|
||||
std::optional<std::vector<MarkupKind>> documentationFormat;
|
||||
std::optional<ParammeterInformation> parameterInformation;
|
||||
std::optional<boolean> activeParameterSupport;
|
||||
};
|
||||
|
||||
std::optional<boolean> dynamicRegistration;
|
||||
std::optional<SignatureInformation> signatureInformation;
|
||||
std::optional<boolean> contextSupport;
|
||||
};
|
||||
|
||||
struct SignatureHelpOptions : WorkDoneProgressOptions
|
||||
{
|
||||
std::optional<std::vector<string>> triggerCharacters;
|
||||
std::optional<std::vector<string>> retriggerCharacters;
|
||||
};
|
||||
|
||||
struct SignatureHelpRegistrationOptions : TextDocumentRegistrationOptions, SignatureHelpOptions
|
||||
{
|
||||
};
|
||||
|
||||
enum class SignatureHelpTriggerKind
|
||||
{
|
||||
kInvoked = 1,
|
||||
kTriggerCharacter = 2,
|
||||
kContentChange = 3
|
||||
};
|
||||
|
||||
struct ParammeterInformation
|
||||
{
|
||||
string label;
|
||||
std::variant<string, MarkupContent> documentation;
|
||||
};
|
||||
|
||||
struct SignatureInformation
|
||||
{
|
||||
string label;
|
||||
std::optional<std::variant<string, MarkupContent>> documentation;
|
||||
std::optional<std::vector<ParammeterInformation>> parameters;
|
||||
std::optional<uinteger> activeParameter;
|
||||
};
|
||||
|
||||
struct SignatureHelp
|
||||
{
|
||||
std::vector<SignatureInformation> signatures;
|
||||
std::optional<uinteger> activeSignature;
|
||||
std::optional<uinteger> activeParameter;
|
||||
};
|
||||
|
||||
struct SignatureHelpContext
|
||||
{
|
||||
SignatureHelpTriggerKind triggerKind;
|
||||
string triggerCharacter;
|
||||
boolean isRetrigger;
|
||||
std::optional<SignatureHelp> activeSignatureHelp;
|
||||
};
|
||||
|
||||
struct SignatureHelpParams : TextDocumentPositionParams, WorkDoneProgressParams
|
||||
{
|
||||
std::optional<SignatureHelpContext> contextSupport;
|
||||
};
|
||||
|
||||
}
|
||||
|
|
@ -1,147 +0,0 @@
|
|||
#pragma once
|
||||
#include "./basic_types.hpp"
|
||||
#include "./document_sync.hpp"
|
||||
#include "./progress.hpp"
|
||||
#include "./completion.hpp"
|
||||
|
||||
namespace lsp::protocol
|
||||
{
|
||||
enum class SymbolKind
|
||||
{
|
||||
kFile = 1,
|
||||
kModule = 2,
|
||||
kNamespace = 3,
|
||||
kPackage = 4,
|
||||
kClass = 5,
|
||||
kMethod = 6,
|
||||
kProperty = 7,
|
||||
kField = 8,
|
||||
kConstructor = 9,
|
||||
kEnum = 10,
|
||||
kInterface = 11,
|
||||
kFunction = 12,
|
||||
kVariable = 13,
|
||||
kConstant = 14,
|
||||
kString = 15,
|
||||
kNumber = 16,
|
||||
kBoolean = 17,
|
||||
kArray = 18,
|
||||
kObject = 19,
|
||||
kKey = 20,
|
||||
kNull = 21,
|
||||
kEnumMember = 22,
|
||||
kStruct = 23,
|
||||
kEvent = 24,
|
||||
kOperator = 25,
|
||||
kTypeParameter = 26
|
||||
};
|
||||
|
||||
enum class SymbolTag
|
||||
{
|
||||
Deprecated = 1
|
||||
};
|
||||
|
||||
struct DocumentSymbol
|
||||
{
|
||||
string name;
|
||||
std::optional<string> detail;
|
||||
SymbolKind kind;
|
||||
std::optional<std::vector<SymbolTag>> tags;
|
||||
std::optional<boolean> deprecated;
|
||||
Range range;
|
||||
Range selectionRange;
|
||||
std::optional<std::vector<DocumentSymbol>> children;
|
||||
};
|
||||
|
||||
struct SymbolInformation
|
||||
{
|
||||
string name;
|
||||
SymbolKind kind;
|
||||
std::optional<std::vector<SymbolTag>> tags;
|
||||
std::optional<boolean> deprecated;
|
||||
Location location;
|
||||
std::optional<string> containerName;
|
||||
};
|
||||
|
||||
struct DocumentSymbolClientCapabilities
|
||||
{
|
||||
struct SymbolKinds
|
||||
{
|
||||
std::vector<SymbolKind> valueSet;
|
||||
};
|
||||
struct TagSupport
|
||||
{
|
||||
std::optional<std::vector<CompletionItemTag>> valueSet;
|
||||
};
|
||||
|
||||
std::optional<boolean> dynamicRegistration;
|
||||
std::optional<SymbolKinds> symbolKind;
|
||||
std::optional<boolean> hierarchicalDocumentSymbolSupport;
|
||||
std::optional<TagSupport> tagSupport;
|
||||
std::optional<boolean> labelSupport;
|
||||
};
|
||||
|
||||
struct DocumentSymbolOptions : WorkDoneProgressOptions
|
||||
{
|
||||
std::optional<string> label;
|
||||
};
|
||||
|
||||
struct DocumentSymbolRegistrationOptions : TextDocumentRegistrationOptions, DocumentSymbolOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct DocumentSymbolParams : WorkDoneProgressParams, PartialResultParams
|
||||
{
|
||||
TextDocumentIdentifier textDocument;
|
||||
};
|
||||
|
||||
struct WorkspaceSymbolClientCapabilities
|
||||
{
|
||||
struct SymbolKinds
|
||||
{
|
||||
std::vector<SymbolKind> valueSet;
|
||||
};
|
||||
struct TagSupport
|
||||
{
|
||||
std::optional<std::vector<CompletionItemTag>> valueSet;
|
||||
};
|
||||
struct ResolveSupport
|
||||
{
|
||||
std::vector<string> properties;
|
||||
};
|
||||
|
||||
std::optional<boolean> dynamicRegistration;
|
||||
std::optional<SymbolKinds> symbolKind;
|
||||
std::optional<TagSupport> tagSupport;
|
||||
std::optional<ResolveSupport> resolveSupport;
|
||||
};
|
||||
|
||||
struct WorkspaceSymbolOptions : WorkDoneProgressOptions
|
||||
{
|
||||
std::optional<boolean> resolveProvider;
|
||||
};
|
||||
|
||||
struct WorkspaceSymbolRegistrationOptions : WorkspaceSymbolOptions
|
||||
{
|
||||
};
|
||||
|
||||
struct WorkspaceSymbolParams : WorkDoneProgressParams, PartialResultParams
|
||||
{
|
||||
string query;
|
||||
};
|
||||
|
||||
struct WorkspaceSymbol
|
||||
{
|
||||
struct LocationUriOnly
|
||||
{
|
||||
DocumentUri uri;
|
||||
};
|
||||
string name;
|
||||
SymbolKind kind;
|
||||
std::optional<std::vector<SymbolTag>> tags;
|
||||
std::optional<string> containerName;
|
||||
std::variant<Location, LocationUriOnly> location;
|
||||
std::optional<LSPAny> data;
|
||||
};
|
||||
|
||||
}
|
||||
|
|
@ -1,121 +0,0 @@
|
|||
#pragma once
|
||||
#include "./basic_types.hpp"
|
||||
#include "./document_sync.hpp"
|
||||
#include "./diagnostics.hpp"
|
||||
|
||||
namespace lsp::protocol
|
||||
{
|
||||
struct CreateFileOptions
|
||||
{
|
||||
boolean overwrite;
|
||||
boolean ignoreIfExists;
|
||||
};
|
||||
|
||||
struct CreateFile
|
||||
{
|
||||
string kind = "create";
|
||||
DocumentUri uri;
|
||||
std::optional<CreateFileOptions> options;
|
||||
std::optional<string> annotationId;
|
||||
};
|
||||
|
||||
struct RenameFileOptions
|
||||
{
|
||||
boolean overwrite;
|
||||
boolean ignoreIfExists;
|
||||
};
|
||||
|
||||
struct RenameFile
|
||||
{
|
||||
string kind = "rename";
|
||||
DocumentUri oldUri;
|
||||
DocumentUri newUri;
|
||||
std::optional<RenameFileOptions> options;
|
||||
std::optional<string> annotationId;
|
||||
};
|
||||
|
||||
struct DeleteFileOptions
|
||||
{
|
||||
boolean recursive;
|
||||
boolean ignoreIfNotExists;
|
||||
};
|
||||
|
||||
struct DeleteFile
|
||||
{
|
||||
string kind = "delete";
|
||||
DocumentUri uri;
|
||||
std::optional<DeleteFileOptions> options;
|
||||
std::optional<string> annotationId;
|
||||
};
|
||||
|
||||
struct WorkspaceEdit
|
||||
{
|
||||
std::map<DocumentUri, std::vector<TextEdit>> changes;
|
||||
std::variant<std::vector<TextDocumentEdit>, std::vector<CreateFile>, std::vector<RenameFile>, std::vector<DeleteFile>> documentChanges;
|
||||
std::optional<std::map<string, ChangeAnnotation>> changeAnnotations;
|
||||
};
|
||||
|
||||
using ResourceOperationKind = std::string_view;
|
||||
namespace ResourceOperationKindLiterals
|
||||
{
|
||||
inline constexpr ResourceOperationKind Create = "create";
|
||||
inline constexpr ResourceOperationKind Rename = "rename";
|
||||
inline constexpr ResourceOperationKind Delete = "delete";
|
||||
}
|
||||
|
||||
using FailureHandlingKind = std::string_view;
|
||||
namespace FailureHandlingKindLiterals
|
||||
{
|
||||
inline constexpr FailureHandlingKind Abort = "abort";
|
||||
inline constexpr FailureHandlingKind Transactional = "transactional";
|
||||
inline constexpr FailureHandlingKind TextOnlyTransactional = "textOnlyTransactional";
|
||||
inline constexpr FailureHandlingKind Undo = "undo";
|
||||
inline constexpr FailureHandlingKind Commit = "commit";
|
||||
}
|
||||
|
||||
struct WorkspaceEditClientCapabilities
|
||||
{
|
||||
struct ChangeAnnotationSupport
|
||||
{
|
||||
std::optional<bool> groupsOnLabel;
|
||||
};
|
||||
|
||||
boolean documentChanges;
|
||||
std::optional<std::vector<ResourceOperationKind>> resourceOperations;
|
||||
std::optional<FailureHandlingKind> failureHandling;
|
||||
std::optional<boolean> normalizesLineEndings;
|
||||
ChangeAnnotationSupport changeAnnotationSupport;
|
||||
};
|
||||
|
||||
struct WorkspaceFolder
|
||||
{
|
||||
URI uri;
|
||||
string name;
|
||||
};
|
||||
|
||||
struct WorkspaceFolderServerCapabilities
|
||||
{
|
||||
std::optional<boolean> supported;
|
||||
std::optional<std::variant<string, boolean>> changeNotifications;
|
||||
};
|
||||
|
||||
struct WorkspaceFoldersChangeEvent
|
||||
{
|
||||
std::vector<WorkspaceFolder> added;
|
||||
std::vector<WorkspaceFolder> removed;
|
||||
};
|
||||
|
||||
struct ApplyWorkspaceEditParams
|
||||
{
|
||||
std::optional<string> label;
|
||||
WorkspaceEdit edit;
|
||||
};
|
||||
|
||||
struct ApplyWorkspaceEditResult
|
||||
{
|
||||
boolean applied;
|
||||
std::optional<string> failureReason;
|
||||
std::optional<std::vector<Diagnostic>> failedChanges;
|
||||
};
|
||||
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -1,41 +0,0 @@
|
|||
#pragma once
|
||||
#include <type_traits>
|
||||
#include <stdexcept>
|
||||
#include <exception>
|
||||
#include "../detail/basic_types.hpp"
|
||||
|
||||
namespace lsp::transform
|
||||
{
|
||||
// 通用错误类
|
||||
class ConversionError : public std::runtime_error
|
||||
{
|
||||
public:
|
||||
explicit ConversionError(const std::string& message)
|
||||
: std::runtime_error("LSP Conversion Error: " + message) {}
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
struct is_lsp_basic_type: std::false_type {};
|
||||
|
||||
template<> struct is_lsp_basic_type<protocol::boolean> : std::true_type {};
|
||||
template<> struct is_lsp_basic_type<protocol::string> : std::true_type {};
|
||||
template<> struct is_lsp_basic_type<protocol::decimal> : std::true_type {};
|
||||
template<> struct is_lsp_basic_type<std::nullptr_t> : std::true_type {};
|
||||
|
||||
template<typename T>
|
||||
struct is_lsp_container_type : std::false_type {};
|
||||
|
||||
template<> struct is_lsp_container_type<protocol::LSPObject> : std::true_type {};
|
||||
template<> struct is_lsp_container_type<protocol::LSPArray> : std::true_type {};
|
||||
template<> struct is_lsp_container_type<protocol::LSPAny> : std::true_type {};
|
||||
|
||||
// struct类型判断
|
||||
template<typename T>
|
||||
struct is_user_struct : std::integral_constant<bool,
|
||||
!std::is_arithmetic<T>::value &&
|
||||
!std::is_same<T, protocol::string>::value &&
|
||||
!std::is_same<T, const char*>::value &&
|
||||
!std::is_same<T, std::nullptr_t>::value &&
|
||||
!is_lsp_basic_type<T>::value &&
|
||||
!is_lsp_container_type<T>::value> {};
|
||||
}
|
||||
|
|
@ -1,93 +0,0 @@
|
|||
#pragma once
|
||||
#include "./transformer.hpp"
|
||||
|
||||
namespace lsp::transform
|
||||
{
|
||||
|
||||
// ===== 全局便利函数 =====
|
||||
// 基本类型
|
||||
template<typename T>
|
||||
protocol::LSPAny LSPAny(const T& obj);
|
||||
|
||||
// // struct 类型
|
||||
// template<typename T>
|
||||
// typename std::enable_if<is_user_struct<T>::value, protocol::LSPAny>::type LSPAny(const T& value);
|
||||
|
||||
// 容器类型
|
||||
template<typename T>
|
||||
protocol::LSPAny LSPAny(const std::vector<T>& vec);
|
||||
|
||||
template<typename T>
|
||||
protocol::LSPAny LSPAny(const std::map<protocol::string, T>& map);
|
||||
|
||||
template<typename T>
|
||||
protocol::LSPAny LSPAny(const std::optional<T>& opt);
|
||||
|
||||
template<typename T>
|
||||
T As(const protocol::LSPAny& any);
|
||||
|
||||
template<typename T, typename From>
|
||||
std::optional<T> As(const std::optional<From>& opt);
|
||||
|
||||
template<typename T, typename... Ts>
|
||||
T As(const std::variant<Ts...>& var);
|
||||
|
||||
template<typename T>
|
||||
T As(const protocol::LSPObject& obj);
|
||||
|
||||
template<typename T>
|
||||
T As(const protocol::LSPArray& arr);
|
||||
|
||||
template<typename T>
|
||||
T Number(const protocol::LSPAny& any);
|
||||
|
||||
template<typename T>
|
||||
std::vector<T> Vector(const protocol::LSPAny& any);
|
||||
|
||||
template<typename T>
|
||||
std::optional<T> Optional(const protocol::LSPAny& any);
|
||||
|
||||
template<typename T>
|
||||
protocol::LSPObject LSPObject(const T& obj);
|
||||
|
||||
template<typename T>
|
||||
protocol::LSPArray LSPArray(const T& vec);
|
||||
|
||||
protocol::string String(const protocol::LSPAny& any);
|
||||
protocol::boolean Bool(const protocol::LSPAny& any);
|
||||
|
||||
// === 外观接口：类型检查 ===
|
||||
namespace check
|
||||
{
|
||||
inline bool IsObject(const protocol::LSPAny& any) { return any.is<protocol::LSPObject>(); }
|
||||
inline bool IsArray(const protocol::LSPAny& any) { return any.is<protocol::LSPArray>(); }
|
||||
inline bool IsString(const protocol::LSPAny& any) { return any.is<protocol::string>(); }
|
||||
inline bool IsNumber(const protocol::LSPAny& any) { return any.is<protocol::decimal>(); }
|
||||
inline bool IsBool(const protocol::LSPAny& any) { return any.is<protocol::boolean>(); }
|
||||
inline bool IsNull(const protocol::LSPAny& any) { return any.is<std::nullptr_t>(); }
|
||||
}
|
||||
|
||||
// === 外观接口：调试功能 ===
|
||||
|
||||
namespace debug
|
||||
{
|
||||
inline std::string GetTypeName(const protocol::LSPAny& any)
|
||||
{
|
||||
if (any.is<protocol::LSPObject>())
|
||||
return "LSPObject";
|
||||
if (any.is<protocol::LSPArray>())
|
||||
return "LSPArray";
|
||||
if (any.is<protocol::string>())
|
||||
return "string";
|
||||
if (any.is<protocol::decimal>())
|
||||
return "decimal";
|
||||
if (any.is<protocol::boolean>())
|
||||
return "boolean";
|
||||
if (any.is<std::nullptr_t>())
|
||||
return "null";
|
||||
return "unknown";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#include "./facade.inl"
|
||||
|
|
@ -1,120 +0,0 @@
|
|||
#pragma once
|
||||
#include "./facade.hpp"
|
||||
|
||||
namespace lsp::transform
|
||||
{
|
||||
template<typename T>
|
||||
inline protocol::LSPAny LSPAny(const T& obj)
|
||||
{
|
||||
return LSPAnyConverter::ToLSPAny(obj);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline protocol::LSPAny LSPAny(const std::vector<T>& vec)
|
||||
{
|
||||
return LSPAnyConverter::ToLSPAny(vec);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline protocol::LSPAny LSPAny(const std::map<protocol::string, T>& map)
|
||||
{
|
||||
return LSPAnyConverter::ToLSPAny(map);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline protocol::LSPAny LSPAny(const std::optional<T>& opt)
|
||||
{
|
||||
return LSPAnyConverter::ToLSPAny(opt);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline T As(const protocol::LSPAny& any)
|
||||
{
|
||||
return LSPAnyConverter::FromLSPAny<T>(any);
|
||||
}
|
||||
|
||||
template<typename T, typename From>
|
||||
inline std::optional<T> As(const std::optional<From>& opt)
|
||||
{
|
||||
return LSPAnyConverter::As<T>(opt);
|
||||
}
|
||||
|
||||
template<typename T, typename... Ts>
|
||||
inline T As(const std::variant<Ts...>& var)
|
||||
{
|
||||
return LSPAnyConverter::As<T>(var);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline T As(const protocol::LSPObject& obj)
|
||||
{
|
||||
return LSPAnyConverter::As<T>(obj);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline T As(const protocol::LSPArray& arr)
|
||||
{
|
||||
return LSPAnyConverter::As<T>(arr);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline T Number(const protocol::LSPAny& any)
|
||||
{
|
||||
return LSPAnyConverter::ToNumber<T>(any);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline std::vector<T> Vector(const protocol::LSPAny& any)
|
||||
{
|
||||
return LSPAnyConverter::ToVector<T>(any);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline std::optional<T> Optional(const protocol::LSPAny& any)
|
||||
{
|
||||
return LSPAnyConverter::ToOptional<T>(any);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline protocol::LSPObject LSPObject(const T& obj)
|
||||
{
|
||||
// 如果已经是 LSPAny，直接获取其中的 LSPObject
|
||||
if constexpr (std::is_same_v<T, protocol::LSPAny>)
|
||||
{
|
||||
return LSPAnyConverter::ToLSPObject(obj);
|
||||
}
|
||||
else
|
||||
{
|
||||
// 否则先转换为 LSPAny，再获取 LSPObject
|
||||
protocol::LSPAny any = LSPAnyConverter::ToLSPAny(obj);
|
||||
return LSPAnyConverter::ToLSPObject(any);
|
||||
}
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline protocol::LSPArray LSPArray(const T& container)
|
||||
{
|
||||
// 如果已经是 LSPAny，直接获取其中的 LSPArray
|
||||
if constexpr (std::is_same_v<T, protocol::LSPAny>)
|
||||
{
|
||||
return LSPAnyConverter::ToLSPArray(container);
|
||||
}
|
||||
else
|
||||
{
|
||||
// 否则转换为 LSPAny
|
||||
protocol::LSPAny any = LSPAnyConverter::ToLSPAny(container);
|
||||
return LSPAnyConverter::ToLSPArray(any);
|
||||
}
|
||||
}
|
||||
|
||||
inline protocol::string String(const protocol::LSPAny& any)
|
||||
{
|
||||
return LSPAnyConverter::ToString(any);
|
||||
}
|
||||
|
||||
inline protocol::boolean Bool(const protocol::LSPAny& any)
|
||||
{
|
||||
return LSPAnyConverter::ToBool(any);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,85 +0,0 @@
|
|||
#pragma once
|
||||
#include "../protocol.hpp"
|
||||
#include "./common.hpp"
|
||||
|
||||
namespace lsp::transform
|
||||
{
|
||||
// LSPAny 序列化/反序列化工具类
|
||||
class LSPAnyConverter
|
||||
{
|
||||
public:
|
||||
// === 基本类型的转换 ===
|
||||
static protocol::LSPAny ToLSPAny(protocol::boolean value);
|
||||
static protocol::LSPAny ToLSPAny(int value);
|
||||
static protocol::LSPAny ToLSPAny(long value);
|
||||
static protocol::LSPAny ToLSPAny(long long value);
|
||||
static protocol::LSPAny ToLSPAny(unsigned int value);
|
||||
static protocol::LSPAny ToLSPAny(unsigned long value);
|
||||
static protocol::LSPAny ToLSPAny(unsigned long long value);
|
||||
static protocol::LSPAny ToLSPAny(float value);
|
||||
static protocol::LSPAny ToLSPAny(double value);
|
||||
static protocol::LSPAny ToLSPAny(long double value);
|
||||
static protocol::LSPAny ToLSPAny(const protocol::string& str);
|
||||
static protocol::LSPAny ToLSPAny(const char* str);
|
||||
static protocol::LSPAny ToLSPAny(std::nullptr_t);
|
||||
static protocol::LSPAny ToLSPAny(const protocol::LSPAny& any);
|
||||
|
||||
// === LSPAny 到基本类型的转换 ===
|
||||
static protocol::boolean ToBool(const protocol::LSPAny& any);
|
||||
static protocol::string ToString(const protocol::LSPAny& any);
|
||||
|
||||
// 其他转换
|
||||
static protocol::LSPObject ToLSPObject(const protocol::LSPAny& any);
|
||||
static protocol::LSPArray ToLSPArray(const protocol::LSPAny& any);
|
||||
|
||||
// === 容器类型的转换 ===
|
||||
template<typename T>
|
||||
static protocol::LSPAny ToLSPAny(const std::vector<T>& vec);
|
||||
|
||||
template<typename T>
|
||||
static protocol::LSPAny ToLSPAny(const std::map<protocol::string, T>& map);
|
||||
|
||||
template<typename T>
|
||||
static protocol::LSPAny ToLSPAny(const std::optional<T>& opt);
|
||||
|
||||
// === Struct 到 LSPAny 的转换 ===
|
||||
template<typename T>
|
||||
static typename std::enable_if<is_user_struct<T>::value, protocol::LSPAny>::type ToLSPAny(const T& obj);
|
||||
|
||||
template<typename T>
|
||||
static typename std::enable_if<std::is_arithmetic<T>::value && !std::is_same<T, protocol::boolean>::value, T>::type ToNumber(const protocol::LSPAny& any);
|
||||
|
||||
// === LSPAny 到容器类型的转换 ===
|
||||
template<typename T>
|
||||
static std::vector<T> ToVector(const protocol::LSPAny& any);
|
||||
|
||||
template<typename T>
|
||||
static std::optional<T> ToOptional(const protocol::LSPAny& any);
|
||||
|
||||
template<typename T>
|
||||
static typename std::enable_if<is_user_struct<T>::value, T>::type FromLSPAny(const protocol::LSPAny& any);
|
||||
|
||||
// 处理 std::optional<T>
|
||||
template<typename T, typename From>
|
||||
static std::optional<T> As(const std::optional<From>& opt);
|
||||
|
||||
// 处理 std::variant<Ts...>
|
||||
template<typename T, typename... Ts>
|
||||
static T As(const std::variant<Ts...>& var);
|
||||
|
||||
// 处理 LSPObject 和 LSPArray
|
||||
template<typename T>
|
||||
static T As(const protocol::LSPObject& obj);
|
||||
|
||||
template<typename T>
|
||||
static T As(const protocol::LSPArray& arr);
|
||||
|
||||
|
||||
private:
|
||||
template<typename T>
|
||||
static T FromLSPAnyImpl(const protocol::LSPAny& any);
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#include "./transformer.inl"
|
||||
|
|
@ -1,259 +0,0 @@
|
|||
#pragma once
|
||||
#include "./transformer.hpp"
|
||||
|
||||
namespace lsp::transform
|
||||
{
|
||||
inline protocol::LSPAny LSPAnyConverter::ToLSPAny(protocol::boolean value)
|
||||
{
|
||||
return protocol::LSPAny(value);
|
||||
}
|
||||
|
||||
inline protocol::LSPAny LSPAnyConverter::ToLSPAny(int value)
|
||||
{
|
||||
return protocol::LSPAny(value);
|
||||
}
|
||||
|
||||
inline protocol::LSPAny LSPAnyConverter::ToLSPAny(long value)
|
||||
{
|
||||
return protocol::LSPAny(value);
|
||||
}
|
||||
|
||||
inline protocol::LSPAny LSPAnyConverter::ToLSPAny(long long value)
|
||||
{
|
||||
return protocol::LSPAny(value);
|
||||
}
|
||||
|
||||
inline protocol::LSPAny LSPAnyConverter::ToLSPAny(unsigned int value)
|
||||
{
|
||||
return protocol::LSPAny(value);
|
||||
}
|
||||
|
||||
inline protocol::LSPAny LSPAnyConverter::ToLSPAny(unsigned long value)
|
||||
{
|
||||
return protocol::LSPAny(value);
|
||||
}
|
||||
|
||||
inline protocol::LSPAny LSPAnyConverter::ToLSPAny(unsigned long long value)
|
||||
{
|
||||
return protocol::LSPAny(value);
|
||||
}
|
||||
|
||||
inline protocol::LSPAny LSPAnyConverter::ToLSPAny(float value)
|
||||
{
|
||||
return protocol::LSPAny(value);
|
||||
}
|
||||
|
||||
inline protocol::LSPAny LSPAnyConverter::ToLSPAny(double value)
|
||||
{
|
||||
return protocol::LSPAny(value);
|
||||
}
|
||||
|
||||
inline protocol::LSPAny LSPAnyConverter::ToLSPAny(long double value)
|
||||
{
|
||||
return protocol::LSPAny(value);
|
||||
}
|
||||
|
||||
inline protocol::LSPAny LSPAnyConverter::ToLSPAny(const protocol::string& str)
|
||||
{
|
||||
return protocol::LSPAny(str);
|
||||
}
|
||||
|
||||
inline protocol::LSPAny LSPAnyConverter::ToLSPAny(const char* str)
|
||||
{
|
||||
return protocol::LSPAny(str);
|
||||
}
|
||||
|
||||
inline protocol::LSPAny LSPAnyConverter::ToLSPAny(std::nullptr_t)
|
||||
{
|
||||
return protocol::LSPAny(nullptr);
|
||||
}
|
||||
|
||||
inline protocol::LSPAny LSPAnyConverter::ToLSPAny(const protocol::LSPAny& any)
|
||||
{
|
||||
return any;
|
||||
}
|
||||
|
||||
inline protocol::boolean LSPAnyConverter::ToBool(const protocol::LSPAny& any)
|
||||
{
|
||||
if (!any.is<protocol::boolean>())
|
||||
throw ConversionError("LSPAny does not contain a boolean");
|
||||
return any.get<protocol::boolean>();
|
||||
}
|
||||
|
||||
inline protocol::string LSPAnyConverter::ToString(const protocol::LSPAny& any)
|
||||
{
|
||||
if (!any.is<protocol::string>())
|
||||
throw ConversionError("LSPAny does not contain a string");
|
||||
return any.get<protocol::string>();
|
||||
}
|
||||
|
||||
inline protocol::LSPObject LSPAnyConverter::ToLSPObject(const protocol::LSPAny& any)
|
||||
{
|
||||
if (!any.is<protocol::LSPObject>())
|
||||
throw ConversionError("LSPAny does not contain LSPObject");
|
||||
return any.get<protocol::LSPObject>();
|
||||
}
|
||||
|
||||
inline protocol::LSPArray LSPAnyConverter::ToLSPArray(const protocol::LSPAny& any)
|
||||
{
|
||||
if (!any.is<protocol::LSPArray>())
|
||||
throw ConversionError("LSPAny does not contain LSPArray");
|
||||
return any.get<protocol::LSPArray>();
|
||||
}
|
||||
|
||||
// 模板实现
|
||||
template<typename T>
|
||||
inline protocol::LSPAny LSPAnyConverter::ToLSPAny(const std::vector<T>& vec)
|
||||
{
|
||||
protocol::LSPArray arr;
|
||||
arr.reserve(vec.size());
|
||||
for (const auto& item : vec)
|
||||
arr.push_back(ToLSPAny(item));
|
||||
return protocol::LSPAny(std::move(arr));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline protocol::LSPAny LSPAnyConverter::ToLSPAny(const std::map<protocol::string, T>& map)
|
||||
{
|
||||
protocol::LSPObject obj;
|
||||
for (const auto& [key, value] : map)
|
||||
obj[key] = ToLSPAny(value);
|
||||
return protocol::LSPAny(std::move(obj));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline protocol::LSPAny LSPAnyConverter::ToLSPAny(const std::optional<T>& opt)
|
||||
{
|
||||
if (opt.has_value())
|
||||
return ToLSPAny(*opt);
|
||||
return protocol::LSPAny(nullptr);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline typename std::enable_if<is_user_struct<T>::value, protocol::LSPAny>::type
|
||||
LSPAnyConverter::ToLSPAny(const T& obj)
|
||||
{
|
||||
try
|
||||
{
|
||||
// 使用glaze序列化为JSON字符串
|
||||
std::string json;
|
||||
auto ec = glz::write_json(obj, json);
|
||||
if (ec)
|
||||
{
|
||||
throw ConversionError("Failed to serialize struct to JSON: " + std::string(glz::format_error(ec, json)));
|
||||
}
|
||||
|
||||
// 直接解析为LSPAny
|
||||
protocol::LSPAny result;
|
||||
ec = glz::read_json(result, json);
|
||||
if (ec)
|
||||
{
|
||||
throw ConversionError("Failed to parse JSON to LSPAny: " + std::string(glz::format_error(ec, json)));
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
catch (const std::exception& e)
|
||||
{
|
||||
throw ConversionError("struct to LSPAny conversion failed: " + std::string(e.what()));
|
||||
}
|
||||
}
|
||||
|
||||
// Fromprotocol::LSPAny 实现
|
||||
template<typename T>
|
||||
inline typename std::enable_if<std::is_arithmetic<T>::value && !std::is_same<T, protocol::boolean>::value, T>::type LSPAnyConverter::ToNumber(const protocol::LSPAny& any)
|
||||
{
|
||||
if (!any.is<protocol::decimal>())
|
||||
throw ConversionError("LSPAny does not contain a number");
|
||||
return static_cast<T>(any.get<protocol::decimal>());
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline std::vector<T> LSPAnyConverter::ToVector(const protocol::LSPAny& any)
|
||||
{
|
||||
if (!any.is<protocol::LSPArray>())
|
||||
throw ConversionError("LSPAny does not contain an array");
|
||||
|
||||
const auto& arr = any.get<protocol::LSPArray>();
|
||||
std::vector<T> result;
|
||||
result.reserve(arr.size());
|
||||
for (const auto& item : arr)
|
||||
result.push_back(FromLSPAny<T>(item));
|
||||
return result;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline std::optional<T> LSPAnyConverter::ToOptional(const protocol::LSPAny& any)
|
||||
{
|
||||
if (any.is<std::nullptr_t>())
|
||||
return std::nullopt;
|
||||
return FromLSPAny<T>(any);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline typename std::enable_if<is_user_struct<T>::value, T>::type
|
||||
LSPAnyConverter::FromLSPAny(const protocol::LSPAny& any)
|
||||
{
|
||||
return FromLSPAnyImpl<T>(any);
|
||||
}
|
||||
|
||||
// 处理 std::optional<T>
|
||||
template<typename T, typename From>
|
||||
inline std::optional<T> LSPAnyConverter::As(const std::optional<From>& opt)
|
||||
{
|
||||
if (opt.has_value())
|
||||
return As<T>(*opt);
|
||||
return std::nullopt;
|
||||
}
|
||||
|
||||
// 处理 std::variant<Ts...>
|
||||
template<typename T, typename... Ts>
|
||||
inline T LSPAnyConverter::As(const std::variant<Ts...>& var)
|
||||
{
|
||||
return std::visit([](const auto& val) -> T {
|
||||
return As<T>(val);
|
||||
}, var);
|
||||
}
|
||||
|
||||
// 处理 LSPObject
|
||||
template<typename T>
|
||||
inline T LSPAnyConverter::As(const protocol::LSPObject& obj)
|
||||
{
|
||||
protocol::LSPAny any(obj);
|
||||
return FromLSPAny<T>(any);
|
||||
}
|
||||
|
||||
// 处理 LSPArray
|
||||
template<typename T>
|
||||
inline T LSPAnyConverter::As(const protocol::LSPArray& arr)
|
||||
{
|
||||
protocol::LSPAny any(arr);
|
||||
return FromLSPAny<T>(any);
|
||||
}
|
||||
|
||||
// FromLSPAnyImpl 实现
|
||||
template<typename T>
|
||||
inline T LSPAnyConverter::FromLSPAnyImpl(const protocol::LSPAny& any)
|
||||
{
|
||||
try
|
||||
{
|
||||
// 序列化LSPAny为JSON
|
||||
std::string json;
|
||||
auto ec = glz::write_json(any.value, json);
|
||||
if (ec)
|
||||
throw ConversionError("Failed to serialize LSPAny to JSON: " + std::string(glz::format_error(ec, json)));
|
||||
|
||||
// 解析JSON到目标类型
|
||||
T result;
|
||||
ec = glz::read_json(result, json);
|
||||
if (ec)
|
||||
throw ConversionError("Failed to parse JSON to target type: " + std::string(glz::format_error(ec, json)));
|
||||
return result;
|
||||
}
|
||||
catch (const std::exception& e)
|
||||
{
|
||||
throw ConversionError("LSPAny to struct conversion failed: " + std::string(e.what()));
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,23 +0,0 @@
|
|||
#include <spdlog/spdlog.h>
|
||||
#include "./provider_interface.hpp"
|
||||
|
||||
namespace lsp::providers
|
||||
{
|
||||
|
||||
std::string ILspProvider::BuildErrorMessageResponse(protocol::ErrorCode code, const std::string& message)
|
||||
{
|
||||
protocol::ResponseError error;
|
||||
error.code = code;
|
||||
error.message = message;
|
||||
std::string json;
|
||||
auto ec = glz::write_json(error, json);
|
||||
if (ec)
|
||||
{
|
||||
spdlog::error("{}: Error", GetProviderName());
|
||||
std::string errmsg = "Failed to serialize [" + GetProviderName() + "] error response: " + glz::format_error(ec);
|
||||
throw std::runtime_error(errmsg);
|
||||
}
|
||||
return json;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,25 +0,0 @@
|
|||
#pragma once
|
||||
#include <string>
|
||||
#include "../../protocol/protocol.hpp"
|
||||
|
||||
namespace lsp::providers
|
||||
{
|
||||
|
||||
// LSP请求提供者接口基类
|
||||
class ILspProvider
|
||||
{
|
||||
public:
|
||||
virtual ~ILspProvider() = default;
|
||||
|
||||
// 处理LSP请求
|
||||
virtual std::string ProvideResponse(const protocol::RequestMessage& request) = 0;
|
||||
// 获取支持的LSP方法名
|
||||
virtual std::string GetMethod() const = 0;
|
||||
// 获取提供者名称（用于日志和调试）
|
||||
virtual std::string GetProviderName() const = 0;
|
||||
|
||||
protected:
|
||||
std::string BuildErrorMessageResponse(protocol::ErrorCode code, const std::string& message);
|
||||
};
|
||||
|
||||
}
|
||||
|
|
@ -1,27 +0,0 @@
|
|||
#include <spdlog/spdlog.h>
|
||||
#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"
|
||||
|
||||
namespace lsp::providers
|
||||
{
|
||||
|
||||
void RegisterAllProviders(RequestDispatcher& dispatcher)
|
||||
{
|
||||
spdlog::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);
|
||||
|
||||
spdlog::info("Successfully registered {} LSP providers", dispatcher.GetSupportedMethods().size());
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,30 +0,0 @@
|
|||
#pragma once
|
||||
#include <spdlog/spdlog.h>
|
||||
#include "../../lsp/dispacther.hpp"
|
||||
#include "./provider_interface.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>();
|
||||
|
||||
spdlog::info("Registering {} for method: {}", provider->GetProviderName(), provider->GetMethod());
|
||||
|
||||
dispatcher.RegisterProvider(
|
||||
provider->GetMethod(),
|
||||
[provider](const protocol::RequestMessage& request) -> std::string {
|
||||
return provider->ProvideResponse(request);
|
||||
});
|
||||
}
|
||||
|
||||
// 批量注册provider
|
||||
void RegisterAllProviders(RequestDispatcher& dispatcher);
|
||||
|
||||
}
|
||||
|
|
@ -1,44 +0,0 @@
|
|||
#include <spdlog/spdlog.h>
|
||||
#include "./initialize_provider.hpp"
|
||||
#include "../../protocol/transform/facade.hpp"
|
||||
|
||||
namespace lsp::providers::initialize
|
||||
{
|
||||
std::string InitializeProvider::ProvideResponse(const protocol::RequestMessage& request)
|
||||
{
|
||||
spdlog::debug("InitializeProvider: Providing response for method {}", request.method);
|
||||
protocol::ResponseMessage response;
|
||||
response.id = request.id;
|
||||
response.result = transform::LSPAny(BuildInitializeResult());
|
||||
std::string json;
|
||||
auto ec = glz::write_json(response, json);
|
||||
return ec ? BuildErrorMessageResponse(protocol::ErrorCode::kInternalError, "Internal error") : json;
|
||||
}
|
||||
|
||||
std::string InitializeProvider::GetMethod() const
|
||||
{
|
||||
return "initialize";
|
||||
}
|
||||
|
||||
std::string InitializeProvider::GetProviderName() const
|
||||
{
|
||||
return "InitializeProvider";
|
||||
}
|
||||
|
||||
protocol::InitializeResult InitializeProvider::BuildInitializeResult()
|
||||
{
|
||||
protocol::InitializeResult result;
|
||||
result.serverInfo.name = "TSL Language Server";
|
||||
result.serverInfo.version = "1.0.0";
|
||||
protocol::TextDocumentSyncOptions opts;
|
||||
opts.openClose = true;
|
||||
opts.change = protocol::TextDocumentSyncKind::kIncremental;
|
||||
protocol::CompletionOptions completion_provider;
|
||||
completion_provider.resolveProvider = false;
|
||||
|
||||
result.capabilities.textDocumentSync = opts;
|
||||
result.capabilities.completionProvider = completion_provider;
|
||||
return result;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,18 +0,0 @@
|
|||
#pragma once
|
||||
#include "../base/provider_interface.hpp"
|
||||
|
||||
namespace lsp::providers::initialize
|
||||
{
|
||||
using namespace lsp;
|
||||
class InitializeProvider : public ILspProvider
|
||||
{
|
||||
public:
|
||||
InitializeProvider() = default;
|
||||
std::string ProvideResponse(const protocol::RequestMessage& request) override;
|
||||
std::string GetMethod() const override;
|
||||
std::string GetProviderName() const override;
|
||||
|
||||
private:
|
||||
protocol::InitializeResult BuildInitializeResult();
|
||||
};
|
||||
}
|
||||
|
|
@ -1,26 +0,0 @@
|
|||
#include <spdlog/spdlog.h>
|
||||
#include "./initialized_provider.hpp"
|
||||
|
||||
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 ? BuildErrorMessageResponse(protocol::ErrorCode::kInternalError, "Internal error") : json;
|
||||
}
|
||||
|
||||
std::string InitializedProvider::GetMethod() const
|
||||
{
|
||||
return "initialized";
|
||||
}
|
||||
|
||||
std::string InitializedProvider::GetProviderName() const
|
||||
{
|
||||
return "InitializedProvider";
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,14 +0,0 @@
|
|||
#pragma once
|
||||
#include "../base/provider_interface.hpp"
|
||||
|
||||
namespace lsp::providers::initialized
|
||||
{
|
||||
class InitializedProvider : public ILspProvider
|
||||
{
|
||||
public:
|
||||
InitializedProvider() = default;
|
||||
std::string ProvideResponse(const protocol::RequestMessage& request) override;
|
||||
std::string GetMethod() const override;
|
||||
std::string GetProviderName() const override;
|
||||
};
|
||||
}
|
||||
|
|
@ -1,159 +0,0 @@
|
|||
#include <spdlog/spdlog.h>
|
||||
#include "./completion_provider.hpp"
|
||||
#include "../../protocol/transform/facade.hpp"
|
||||
|
||||
namespace lsp::providers::text_document
|
||||
{
|
||||
std::string CompletionProvider::ProvideResponse(const protocol::RequestMessage& request)
|
||||
{
|
||||
spdlog::debug("CompletionProvider: Providing response for method {}", request.method);
|
||||
|
||||
try {
|
||||
// 验证请求是否包含参数
|
||||
if (!request.params.has_value()) {
|
||||
spdlog::warn("{}: Missing params in request", GetProviderName());
|
||||
return BuildErrorMessageResponse(protocol::ErrorCode::kInvalidParams, "Missing params");
|
||||
}
|
||||
|
||||
// 从 variant 中提取参数
|
||||
protocol::CompletionParams completion_params = transform::As<protocol::CompletionParams>(request.params.value());
|
||||
protocol::CompletionList completion_list = BuildCompletionResponse(completion_params);
|
||||
|
||||
// 构建响应消息
|
||||
protocol::ResponseMessage response;
|
||||
response.id = request.id;
|
||||
response.result = transform::LSPAny(completion_list);
|
||||
|
||||
std::string json;
|
||||
auto ec = glz::write_json(response, json);
|
||||
if (ec) {
|
||||
spdlog::error("{}: Failed to serialize response: {}", GetProviderName(), glz::format_error(ec, json));
|
||||
return BuildErrorMessageResponse(protocol::ErrorCode::kInternalError, "Failed to serialize response");
|
||||
}
|
||||
|
||||
return json;
|
||||
|
||||
} catch (const transform::ConversionError& e) {
|
||||
spdlog::error("{}: Failed to convert params: {}", GetProviderName(), e.what());
|
||||
return BuildErrorMessageResponse(protocol::ErrorCode::kInvalidParams, "Invalid completion params");
|
||||
} catch (const std::exception& e) {
|
||||
spdlog::error("{}: Unexpected error: {}", GetProviderName(), e.what());
|
||||
return BuildErrorMessageResponse(protocol::ErrorCode::kInternalError, "Internal error");
|
||||
}
|
||||
}
|
||||
|
||||
std::string CompletionProvider::GetMethod() const
|
||||
{
|
||||
return "textDocument/completion";
|
||||
}
|
||||
|
||||
std::string CompletionProvider::GetProviderName() const
|
||||
{
|
||||
return "CompletionProvider";
|
||||
}
|
||||
|
||||
protocol::CompletionList CompletionProvider::BuildCompletionResponse(const protocol::CompletionParams& params)
|
||||
{
|
||||
spdlog::trace("{}: Processing completion request for URI='{}', Position=({}, {})",
|
||||
GetProviderName(),
|
||||
params.textDocument.uri,
|
||||
params.position.line,
|
||||
params.position.character);
|
||||
|
||||
// 获取补全前缀
|
||||
std::string prefix = ExtractPrefix(params.textDocument, params.position);
|
||||
|
||||
// 如果提供了 context，可以使用其中的信息
|
||||
if (params.context.has_value())
|
||||
{
|
||||
spdlog::trace("{}: Trigger kind: {}", GetProviderName(), static_cast<int>(params.context->triggerKind));
|
||||
if (params.context->triggerCharacter.has_value())
|
||||
spdlog::trace("{}: Trigger character: '{}'", GetProviderName(), params.context->triggerCharacter.value());
|
||||
}
|
||||
|
||||
// 收集所有补全项
|
||||
std::vector<protocol::CompletionItem> allItems;
|
||||
|
||||
// 添加关键字补全
|
||||
auto keywordItems = ProvideKeywordCompletions(prefix);
|
||||
allItems.insert(allItems.end(), keywordItems.begin(), keywordItems.end());
|
||||
|
||||
// 添加上下文相关补全
|
||||
auto contextualItems = ProvideContextualCompletions(params.textDocument, params.position, prefix);
|
||||
allItems.insert(allItems.end(), contextualItems.begin(), contextualItems.end());
|
||||
|
||||
// 构建补全列表
|
||||
protocol::CompletionList result;
|
||||
result.isIncomplete = false; // 表示这是完整的补全列表
|
||||
result.items = std::move(allItems);
|
||||
|
||||
spdlog::info("{}: Provided {} completion items", GetProviderName(), result.items.size());
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
std::string CompletionProvider::ExtractPrefix(const protocol::TextDocumentIdentifier& textDocument, const protocol::Position& position)
|
||||
{
|
||||
// TODO: 实现从文档内容和位置计算前缀
|
||||
// 这需要访问文档管理器来获取文档内容
|
||||
// 现在返回空字符串
|
||||
spdlog::trace("{}: ExtractPrefix not implemented, returning empty string", GetProviderName());
|
||||
return "";
|
||||
}
|
||||
|
||||
std::vector<protocol::CompletionItem> CompletionProvider::ProvideKeywordCompletions(const std::string& prefix)
|
||||
{
|
||||
std::vector<protocol::CompletionItem> items;
|
||||
|
||||
// 从 tsl_keywords_ 获取补全项
|
||||
auto tslItems = tsl_keywords_.GetCompletionItems(prefix);
|
||||
|
||||
for (const auto& tslItem : tslItems) {
|
||||
protocol::CompletionItem item;
|
||||
item.label = tslItem.label;
|
||||
item.kind = protocol::CompletionItemKind::kKeyword;
|
||||
item.detail = "TSL Keyword";
|
||||
|
||||
// 创建文档内容
|
||||
protocol::MarkupContent documentation;
|
||||
documentation.kind = protocol::MarkupKindLiterals::PlainText;
|
||||
documentation.value = "TSL language keyword";
|
||||
item.documentation = documentation;
|
||||
|
||||
item.insertText = tslItem.label;
|
||||
|
||||
items.push_back(item);
|
||||
}
|
||||
|
||||
spdlog::debug("{}: Found {} keyword completions", GetProviderName(), items.size());
|
||||
return items;
|
||||
}
|
||||
|
||||
std::vector<protocol::CompletionItem> CompletionProvider::ProvideContextualCompletions(const protocol::TextDocumentIdentifier& textDocument, const protocol::Position& position, const std::string& prefix)
|
||||
{
|
||||
spdlog::debug("{}: Processing contextual completions for URI: {}", GetProviderName(), textDocument.uri);
|
||||
|
||||
std::vector<protocol::CompletionItem> items;
|
||||
|
||||
// TODO: 基于上下文提供补全
|
||||
// 示例：添加一个变量补全
|
||||
if (!prefix.empty() && prefix[0] == '$')
|
||||
{
|
||||
protocol::CompletionItem varItem;
|
||||
varItem.label = "$myVariable";
|
||||
varItem.kind = protocol::CompletionItemKind::kVariable;
|
||||
varItem.detail = "Local variable";
|
||||
varItem.insertText = "$myVariable";
|
||||
|
||||
protocol::MarkupContent doc;
|
||||
doc.kind = protocol::MarkupKindLiterals::Markdown;
|
||||
doc.value = "Example variable completion";
|
||||
varItem.documentation = doc;
|
||||
|
||||
items.push_back(varItem);
|
||||
}
|
||||
|
||||
spdlog::debug("{}: Found {} contextual completions", GetProviderName(), items.size());
|
||||
return items;
|
||||
}
|
||||
}
|
||||
|
|
@ -1,33 +0,0 @@
|
|||
#pragma once
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include "../base/provider_interface.hpp"
|
||||
#include "../../protocol/protocol.hpp"
|
||||
#include "../../language/tsl_keywords.hpp"
|
||||
|
||||
namespace lsp::providers::text_document
|
||||
{
|
||||
class CompletionProvider : public ILspProvider
|
||||
{
|
||||
public:
|
||||
CompletionProvider() = default;
|
||||
|
||||
std::string ProvideResponse(const protocol::RequestMessage& request) override;
|
||||
std::string GetMethod() const override;
|
||||
std::string GetProviderName() const override;
|
||||
|
||||
private:
|
||||
// 构建完整的补全响应
|
||||
protocol::CompletionList BuildCompletionResponse(const protocol::CompletionParams& params);
|
||||
|
||||
// 获取补全前缀（从文档内容和位置计算）
|
||||
std::string ExtractPrefix(const protocol::TextDocumentIdentifier& textDocument, const protocol::Position& position);
|
||||
|
||||
// 提供不同类型的补全
|
||||
std::vector<protocol::CompletionItem> ProvideKeywordCompletions(const std::string& prefix);
|
||||
std::vector<protocol::CompletionItem> ProvideContextualCompletions(const protocol::TextDocumentIdentifier& textDocument, const protocol::Position& position, const std::string& prefix);
|
||||
|
||||
private:
|
||||
tsl::TslKeywords tsl_keywords_;
|
||||
};
|
||||
}
|
||||
|
|
@ -1,27 +0,0 @@
|
|||
#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 ? BuildErrorMessageResponse(protocol::ErrorCode::kInternalError, "Internal error") : json;
|
||||
}
|
||||
|
||||
std::string DidChangeProvider::GetMethod() const
|
||||
{
|
||||
return "textDocument/didChange";
|
||||
}
|
||||
|
||||
std::string DidChangeProvider::GetProviderName() const
|
||||
{
|
||||
return "DidChangeProvider";
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,14 +0,0 @@
|
|||
#pragma once
|
||||
#include "../base/provider_interface.hpp"
|
||||
|
||||
namespace lsp::providers::text_document
|
||||
{
|
||||
class DidChangeProvider : public ILspProvider
|
||||
{
|
||||
public:
|
||||
DidChangeProvider() = default;
|
||||
std::string ProvideResponse(const protocol::RequestMessage& request) override;
|
||||
std::string GetMethod() const override;
|
||||
std::string GetProviderName() const override;
|
||||
};
|
||||
}
|
||||
|
|
@ -1,25 +0,0 @@
|
|||
#include <spdlog/spdlog.h>
|
||||
#include "./did_open_provider.hpp"
|
||||
|
||||
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 ? BuildErrorMessageResponse(protocol::ErrorCode::kInternalError, "Internal error") : json;
|
||||
}
|
||||
|
||||
std::string DidOpenProvider::GetMethod() const
|
||||
{
|
||||
return "textDocument/didOpen";
|
||||
}
|
||||
|
||||
std::string DidOpenProvider::GetProviderName() const
|
||||
{
|
||||
return "DidOpenProvider";
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,15 +0,0 @@
|
|||
#pragma once
|
||||
#include <unordered_map>
|
||||
#include "../base/provider_interface.hpp"
|
||||
|
||||
namespace lsp::providers::text_document
|
||||
{
|
||||
class DidOpenProvider : public ILspProvider
|
||||
{
|
||||
public:
|
||||
DidOpenProvider() = default;
|
||||
std::string ProvideResponse(const protocol::RequestMessage& request) override;
|
||||
std::string GetMethod() const override;
|
||||
std::string GetProviderName() const override;
|
||||
};
|
||||
}
|
||||
|
|
@ -1,26 +0,0 @@
|
|||
#include <spdlog/spdlog.h>
|
||||
#include "./set_trace_provider.hpp"
|
||||
|
||||
namespace lsp::providers::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 ? BuildErrorMessageResponse(protocol::ErrorCode::kInternalError, "Internal error") : json;
|
||||
}
|
||||
|
||||
std::string SetTraceProvider::GetMethod() const
|
||||
{
|
||||
return "$/setTrace";
|
||||
}
|
||||
|
||||
std::string SetTraceProvider::GetProviderName() const
|
||||
{
|
||||
return "SetTraceProvider";
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,14 +0,0 @@
|
|||
#pragma once
|
||||
#include "../base/provider_interface.hpp"
|
||||
|
||||
namespace lsp::providers::trace
|
||||
{
|
||||
class SetTraceProvider : public ILspProvider
|
||||
{
|
||||
public:
|
||||
SetTraceProvider() = default;
|
||||
std::string ProvideResponse(const protocol::RequestMessage& request) override;
|
||||
std::string GetMethod() const override;
|
||||
std::string GetProviderName() const override;
|
||||
};
|
||||
}
|
||||
Loading…
Reference in New Issue