搭建语言服务

Author: CppCXY

CodeFormatServer/CMakeLists.txt

@@ -37,10 +37,8 @@ target_sources(CodeFormatServer
 	#protocol
 	${CodeFormatServer_SOURCE_DIR}/src/Protocol/ProtocolParser.cpp
 	${CodeFormatServer_SOURCE_DIR}/src/Protocol/ProtocolBuffer.cpp
-	# protocol/request
-	${CodeFormatServer_SOURCE_DIR}/src/Protocol/Request/JsonRequestProtocol.cpp
-	${CodeFormatServer_SOURCE_DIR}/src/Protocol/Request/RequestProtocolFactory.cpp
-	${CodeFormatServer_SOURCE_DIR}/src/Protocol/Request/InitializeRequestProtocol.cpp
+
+	${CodeFormatServer_SOURCE_DIR}/src/VSCode.cpp
 )
 
 target_link_libraries(CodeFormatServer PUBLIC CodeService)

CodeFormatServer/src/CodeFormatServer.cpp

@@ -19,7 +19,6 @@ int main(int argc, char** argv)
             LanguageClient::GetInstance().SetSession(std::make_shared<SocketIOSession>(std::move(socket)));
             LanguageClient::GetInstance().Run();
         }
-        
     }
     else
     {

CodeFormatServer/src/LanguageClient.cpp

@@ -11,6 +11,11 @@ void LanguageClient::SetSession(std::shared_ptr<IOSession> session)
 	_session = session;
 }
 
+std::shared_ptr<IOSession> LanguageClient::GetSession()
+{
+	return _session;
+}
+
 void LanguageClient::Run()
 {
 	if (_session)

CodeFormatServer/src/LanguageService.cpp

@@ -1,4 +1,7 @@
 #include "CodeFormatServer/LanguageService.h"
+#include "CodeFormatServer/VSCode.h"
+#include "CodeService/LuaFormatOptions.h"
+#include "CodeService/LuaFormatter.h"
 
 using namespace std::placeholders;
 
@@ -12,28 +15,49 @@ LanguageService::~LanguageService()
 
 bool LanguageService::Initialize()
 {
-#define DynamicBind(Method, ProtocolClass)\
-	[this](auto request){ return Method(std::dynamic_pointer_cast<ProtocolClass>(request)); }
+#define DynamicBind(Method, ParamClass)\
+	[this](auto param) { auto inputParam = std::dynamic_pointer_cast<ParamClass>(param); return Method(inputParam);}
 
-	_handles["initialize"] = DynamicBind(OnInitialize, InitializeRequestProtocol);
-	
+	_handles["initialize"] = DynamicBind(OnInitialize, vscode::InitializeParams);
+	_handles["textDocument/didChange"] = DynamicBind(OnDidChange, vscode::DidChangeTextDocumentParams);
 
 	return true;
 }
 
-std::shared_ptr<JsonResponseProtocol> LanguageService::Dispatch(std::string_view method,
-	std::shared_ptr<JsonRequestProtocol> request)
+std::shared_ptr<vscode::Serializable> LanguageService::Dispatch(std::string_view method,
+	std::shared_ptr<vscode::Serializable> param)
 {
 	auto it = _handles.find(method);
-	if(it != _handles.end())
+	if (it != _handles.end())
 	{
-		return it->second(request);
+		return it->second(param);
 	}
 	return nullptr;
 }
 
+std::shared_ptr<vscode::InitializeResult> LanguageService::OnInitialize(std::shared_ptr<vscode::InitializeParams> param)
+{
+	auto result = std::make_shared<vscode::InitializeResult>();
+
+	result->capabilities.documentFormattingProvider = true;
+	result->capabilities.textDocumentSync.change = vscode::TextDocumentSyncKind::Full;
+	result->capabilities.textDocumentSync.openClose = true;
+	return result;
+}
 
-std::shared_ptr<JsonResponseProtocol> LanguageService::OnInitialize(std::shared_ptr<InitializeRequestProtocol> request)
+std::shared_ptr<vscode::Serializable> LanguageService::OnDidChange(
+	std::shared_ptr<vscode::DidChangeTextDocumentParams> param)
 {
-	return nullptr;
+	LuaFormatOptions options;
+	
+	std::shared_ptr<LuaParser> parser = LuaParser::LoadFromBuffer(std::move(param->contentChanges[0].text));
+	parser->BuildAstWithComment();
+
+	LuaFormatter formatter(parser, options);
+	formatter.BuildFormattedElement();
+
+	auto diagnosis = formatter.GetDiagnosisInfos();
+
+
+
 }

CodeFormatServer/src/Protocol/JsonResponseProtocol.cpp

@@ -2,40 +2,55 @@
 
 #include <iostream>
 #include <nlohmann/json.hpp>
-
+#include "Util/format.h"
 #include "CodeFormatServer/LanguageService.h"
-#include "CodeFormatServer/Protocol/Request/RequestProtocolFactory.h"
 
 ProtocolParser::ProtocolParser()
-	: _id(0),
-	  _method(),
-	  _request(nullptr)
+	: _id(-1)
 {
 }
 
 void ProtocolParser::Parse(std::string_view msg)
 {
 	std::cout << msg << std::endl;
 	auto jsonMessage = nlohmann::json::parse(msg);
-
-	_id = jsonMessage["id"].get<int>();
-	_method = jsonMessage["method"].get<std::string>();
-	auto params = jsonMessage["params"];
-
-	_request = RequestProtocolFactory::GetInstance().MakeProtocol(_method, params);
+	if (jsonMessage["id"].is_number())
+	{
+		_id = jsonMessage["id"].get<int>();
+	}
+	if (jsonMessage["method"].is_string())
+	{
+		_method = jsonMessage["method"].get<std::string>();
+	}
+	if (jsonMessage["params"].is_object())
+	{
+		auto params = jsonMessage["params"];
+		_param = vscode::MakeFromRequest(_method, params);
+	}
 }
 
-std::shared_ptr<JsonRequestProtocol> ProtocolParser::GetRequest()
+std::shared_ptr<vscode::Serializable> ProtocolParser::GetParam()
 {
-	return _request;
+	return _param;
 }
 
 std::string_view ProtocolParser::GetMethod()
 {
 	return _method;
 }
 
-std::string ProtocolParser::SerializeProtocol(std::shared_ptr<JsonResponseProtocol> response)
+std::string ProtocolParser::SerializeProtocol(std::shared_ptr<vscode::Serializable> result)
 {
-	return "";
+
+	nlohmann::json json;
+	if (_id != -1) {
+		json["id"] = _id;
+	}
+	json["result"] = result->Serialize();
+	json["jsonrpc"] = "2.0";
+	auto dumpResult = json.dump();
+	std::string message = format("Content-Length:{}\r\n\r\n", dumpResult.size());
+
+	message.append(dumpResult);
+	return std::move(message);
 }

CodeFormatServer/src/Protocol/ProtocolParser.cpp

@@ -18,13 +18,13 @@ std::string IOSession::Handle(std::string_view msg)
 
 	parser.Parse(msg);
 
-	auto request = parser.GetRequest();
+	auto param = parser.GetParam();
 
-	if (request)
+	if (param)
 	{
-		auto response = _service.Dispatch(parser.GetMethod(), request);
-		if (response) {
-			return parser.SerializeProtocol(response);
+		auto result = _service.Dispatch(parser.GetMethod(), param);
+		if (result) {
+			return parser.SerializeProtocol(result);
 		}
 	}