优化语言服务

Author: CppCXY

CodeFormatLib/src/CodeFormatLib.cpp

@@ -442,7 +442,7 @@ int spell_analysis(lua_State* L)
 			std::string filename = lua_tostring(L, 1);
 			std::string text = lua_tostring(L, 2);
 
-			std::set<std::string> tempDict;
+			CodeSpellChecker::CustomDictionary tempDict;
 
 			if (top == 3 && lua_istable(L, 3))
 			{

CodeFormatLib/src/LuaCodeFormat.cpp

@@ -133,7 +133,8 @@ std::pair<bool, std::vector<LuaDiagnosisInfo>> LuaCodeFormat::Diagnose(const std
 	return std::make_pair(true, ctx.GetDiagnosisInfos());
 }
 
-std::vector<LuaDiagnosisInfo> LuaCodeFormat::SpellCheck(const std::string& uri, std::string&& text, std::set<std::string>& tempDict)
+std::vector<LuaDiagnosisInfo> LuaCodeFormat::SpellCheck(const std::string& uri, std::string&& text,
+                                                        const CodeSpellChecker::CustomDictionary& tempDict)
 {
 	auto parser = LuaParser::LoadFromBuffer(std::move(text));
 
@@ -142,7 +143,7 @@ std::vector<LuaDiagnosisInfo> LuaCodeFormat::SpellCheck(const std::string& uri,
 	DiagnosisContext ctx(parser, *options);
 
 	_codeSpellChecker->Analysis(ctx, tempDict);
-	
+
 	return ctx.GetDiagnosisInfos();
 }
 

CodeFormatLib/src/LuaCodeFormat.h

@@ -26,13 +26,14 @@ class LuaCodeFormat
 
 	void LoadSpellDictionaryFromBuffer(const std::string& buffer);
 
-	std::string Reformat(const std::string& uri, std::string&& text,ConfigMap& configMap);
+	std::string Reformat(const std::string& uri, std::string&& text, ConfigMap& configMap);
 
 	std::string RangeFormat(const std::string& uri, LuaFormatRange& range, std::string&& text, ConfigMap& configMap);
 
 	std::pair<bool, std::vector<LuaDiagnosisInfo>> Diagnose(const std::string& uri, std::string&& text);
 
-	std::vector<LuaDiagnosisInfo> SpellCheck(const std::string& uri, std::string&& text, std::set<std::string>& tempDict);
+	std::vector<LuaDiagnosisInfo> SpellCheck(const std::string& uri, std::string&& text,
+	                                         const CodeSpellChecker::CustomDictionary& tempDict);
 
 	std::vector<SuggestItem> SpellCorrect(const std::string& word);
 

CodeFormatServer/CMakeLists.txt

@@ -57,6 +57,7 @@ target_sources(CodeFormatServer
 	${CodeFormatServer_SOURCE_DIR}/src/Service/ModuleService.cpp
 	${CodeFormatServer_SOURCE_DIR}/src/Service/CodeFormatService.cpp
 	${CodeFormatServer_SOURCE_DIR}/src/Service/CompletionService.cpp
+	${CodeFormatServer_SOURCE_DIR}/src/Service/CommandService.cpp
 
 	# mimalloc
 	${LuaCodeStyle_SOURCE_DIR}/3rd/mimalloc-2.0.3/src/static.c

CodeFormatServer/src/LanguageClient.cpp

@@ -10,7 +10,7 @@
 #include "CodeFormatServer/Service/ModuleService.h"
 #include "CodeFormatServer/Service/CodeFormatService.h"
 #include "CodeFormatServer/Service/CompletionService.h"
-
+#include "CodeFormatServer/Service/CommandService.h"
 
 LanguageClient& LanguageClient::GetInstance()
 {
@@ -30,6 +30,7 @@ void LanguageClient::InitializeService()
 	AddService<CodeFormatService>();
 	AddService<ModuleService>();
 	AddService<CompletionService>();
+	AddService<CommandService>();
 
 	for (auto service : _services)
 	{

CodeFormatServer/src/LanguageService.cpp

@@ -1,4 +1,4 @@
-#include "CodeFormatServer/LanguageService.h"
+#include "CodeFormatServer/LanguageService.h"
 #include <fstream>
 #include <iostream>
 #include <sstream>
@@ -9,6 +9,7 @@
 #include "CodeService/LuaFormatter.h"
 #include "CodeFormatServer/LanguageClient.h"
 #include "CodeFormatServer/Service/CodeFormatService.h"
+#include "CodeFormatServer/Service/CommandService.h"
 #include "CodeFormatServer/Service/ModuleService.h"
 #include "CodeFormatServer/Service/CompletionService.h"
 #include "Util/Url.h"
@@ -76,15 +77,14 @@ std::shared_ptr<vscode::InitializeResult> LanguageService::OnInitialize(std::sha
 	LanguageClient::GetInstance().SetVscodeSettings(param->initializationOptions.vscodeConfig);
 
 	result->capabilities.codeActionProvider = true;
-	result->capabilities.executeCommandProvider.commands = {
-		"emmylua.reformat.me",
-		"emmylua.import.me",
-		"emmylua.spell.correct"
-	};
+	result->capabilities.executeCommandProvider.commands =
+		LanguageClient::GetInstance().GetService<CommandService>()->GetCommands();
 
-	result->capabilities.completionProvider.resolveProvider = false;
-	result->capabilities.completionProvider.triggerCharacters = {};
-	result->capabilities.completionProvider.completionItem.labelDetailsSupport = true;
+	// result->capabilities.completionProvider.resolveProvider = false;
+	// result->capabilities.completionProvider.triggerCharacters = {};
+	// result->capabilities.completionProvider.completionItem.labelDetailsSupport = true;
+	// 砍掉代码补全
+	result->capabilities.completionProvider.supportCompletion = false;
 
 	auto& editorConfigFiles = param->initializationOptions.editorConfigFiles;
 	for (auto& configFile : editorConfigFiles)
@@ -344,6 +344,7 @@ std::shared_ptr<vscode::Serializable> LanguageService::OnTypeFormatting(
 
 std::shared_ptr<vscode::CodeActionResult> LanguageService::OnCodeAction(std::shared_ptr<vscode::CodeActionParams> param)
 {
+	// TODO refactor move to CodeActionService
 	auto range = param->range;
 	auto uri = param->textDocument.uri;
 	auto filePath = url::UrlToFilePath(uri);
@@ -354,27 +355,34 @@ std::shared_ptr<vscode::CodeActionResult> LanguageService::OnCodeAction(std::sha
 		if (LanguageClient::GetInstance().GetService<CodeFormatService>()->IsCodeFormatDiagnostic(diagnostic))
 		{
 			auto& action = codeActionResult->actions.emplace_back();
-			std::string title = "reformat";
+			std::string title = "reformat current line";
 			action.title = title;
 			action.command.title = title;
-			action.command.command = "emmylua.reformat.me";
+			action.command.command = LanguageClient::GetInstance().
+			                         GetService<CommandService>()->GetCommand(CommandService::Command::Reformat);
 			action.command.arguments.push_back(param->textDocument.uri);
 			action.command.arguments.push_back(param->range.Serialize());
 
 			action.kind = vscode::CodeActionKind::QuickFix;
 		}
 		else if (LanguageClient::GetInstance().GetService<CodeFormatService>()->IsSpellDiagnostic(diagnostic))
 		{
-			LanguageClient::GetInstance().GetService<CodeFormatService>()->MakeSpellActions(codeActionResult, diagnostic, param->textDocument.uri);
+			LanguageClient::GetInstance().GetService<CodeFormatService>()->MakeSpellActions(
+				codeActionResult, diagnostic, param->textDocument.uri);
 		}
-		else if (LanguageClient::GetInstance().GetService<ModuleService>()->IsDiagnosticRange(filePath, range))
+		else if (LanguageClient::GetInstance().GetService<ModuleService>()->IsModuleDiagnostic(diagnostic))
 		{
 			auto modules = LanguageClient::GetInstance().GetService<ModuleService>()->GetImportModules(filePath, range);
 			auto& action = codeActionResult->actions.emplace_back();
-			std::string title = "import me";
+			std::string title = "import multi choice";
+			if (modules.size() == 1)
+			{
+				title = Util::format("import '{}'", modules.front().ModuleName);
+			}
 			action.title = title;
 			action.command.title = title;
-			action.command.command = "emmylua.import.me";
+			action.command.command = LanguageClient::GetInstance().
+			                         GetService<CommandService>()->GetCommand(CommandService::Command::Import);
 			action.command.arguments.push_back(param->textDocument.uri);
 			action.command.arguments.push_back(param->range.Serialize());
 			for (auto& module : modules)
@@ -395,108 +403,8 @@ std::shared_ptr<vscode::CodeActionResult> LanguageService::OnCodeAction(std::sha
 std::shared_ptr<vscode::Serializable> LanguageService::OnExecuteCommand(
 	std::shared_ptr<vscode::ExecuteCommandParams> param)
 {
-	auto result = std::make_shared<vscode::Serializable>();
-	if (param->command == "emmylua.reformat.me")
-	{
-		if (param->arguments.size() < 2)
-		{
-			return result;
-		}
-
-		std::string uri = param->arguments[0];
-		vscode::Range range;
-
-		range.Deserialize(param->arguments[1]);
-
-		auto parser = LanguageClient::GetInstance().GetFileParser(uri);
-
-		auto applyParams = std::make_shared<vscode::ApplyWorkspaceEditParams>();
-
-		auto options = LanguageClient::GetInstance().GetOptions(uri);
-
-		if (parser->HasError())
-		{
-			return result;
-		}
-
-		auto it = applyParams->edit.changes.emplace(uri, std::vector<vscode::TextEdit>());
-		auto& change = it.first->second;
-
-		auto& edit = change.emplace_back();
-		LuaFormatRange formattedRange(static_cast<int>(range.start.line), static_cast<int>(range.end.line));
-
-		auto formatResult = LanguageClient::GetInstance().GetService<CodeFormatService>()->RangeFormat(
-			formattedRange, parser, options);
-
-		edit.newText = std::move(formatResult);
-
-		edit.range = vscode::Range(
-			vscode::Position(formattedRange.StartLine, formattedRange.StartCharacter),
-			vscode::Position(formattedRange.EndLine + 1, formattedRange.EndCharacter)
-		);
-
-		LanguageClient::GetInstance().SendRequest("workspace/applyEdit", applyParams);
-	}
-	else if (param->command == "emmylua.import.me")
-	{
-		if (param->arguments.size() < 4)
-		{
-			return result;
-		}
-
-		std::string uri = param->arguments[0];
-		std::string filePath = url::UrlToFilePath(uri);
-		auto config = LanguageClient::GetInstance().GetService<ModuleService>()->GetIndex().GetConfig(filePath);
-		if (!config)
-		{
-			return nullptr;
-		}
-		vscode::Range range;
-
-		range.Deserialize(param->arguments[1]);
-
-		std::string moduleName = param->arguments[2];
-
-		std::string moduleDefineName = param->arguments[3];
-
-		std::string requireString = Util::format("local {} = {}(\"{}\")\n", moduleDefineName, config->import_function,
-		                                   moduleName);
-		auto parser = LanguageClient::GetInstance().GetFileParser(uri);
-		auto applyParams = std::make_shared<vscode::ApplyWorkspaceEditParams>();
-		auto it = applyParams->edit.changes.emplace(uri, std::vector<vscode::TextEdit>());
-		auto& change = it.first->second;
-
-		auto& edit = change.emplace_back();
-
-		edit.newText = requireString;
-
-		edit.range = LanguageClient::GetInstance().GetService<ModuleService>()->FindRequireRange(parser, config);
-
-		LanguageClient::GetInstance().SendRequest("workspace/applyEdit", applyParams);
-	}
-	else if(param->command == "emmylua.spell.correct")
-	{
-		std::string uri = param->arguments[0];
-		vscode::Range range;
-
-		range.Deserialize(param->arguments[1]);
-
-		std::string newText = param->arguments[2];
-
-		auto applyParams = std::make_shared<vscode::ApplyWorkspaceEditParams>();
-		auto it = applyParams->edit.changes.emplace(uri, std::vector<vscode::TextEdit>());
-		auto& change = it.first->second;
-
-		auto& edit = change.emplace_back();
-
-		edit.newText = newText;
-
-		edit.range = range;
-
-		LanguageClient::GetInstance().SendRequest("workspace/applyEdit", applyParams);
-	}
-
-	return result;
+	LanguageClient::GetInstance().GetService<CommandService>()->Dispatch(param->command, param);
+	return nullptr;
 }
 
 std::shared_ptr<vscode::Serializable> LanguageService::OnDidChangeWatchedFiles(
@@ -528,6 +436,7 @@ std::shared_ptr<vscode::Serializable> LanguageService::OnDidChangeWatchedFiles(
 	return nullptr;
 }
 
+//@depreacated
 std::shared_ptr<vscode::CompletionList> LanguageService::OnCompletion(std::shared_ptr<vscode::CompletionParams> param)
 {
 	auto list = std::make_shared<vscode::CompletionList>();

CodeFormatServer/src/Service/AstUtil/ModuleFinder.cpp

@@ -41,7 +41,6 @@ std::set<std::string> ModuleFinder::GetDefinedName(std::shared_ptr<LuaAstNode> u
 	return definedName;
 }
 
-
 void ModuleFinder::VisitParamList(const std::shared_ptr<LuaAstNode>& paramList)
 {
 	for (auto param : paramList->GetChildren())

CodeFormatServer/src/Service/CodeFormatService.cpp

@@ -1,4 +1,6 @@
 #include "CodeFormatServer/Service/CodeFormatService.h"
+
+#include "CodeFormatServer/Service/CommandService.h"
 #include "CodeService/LuaFormatter.h"
 #include "CodeService/FormatElement/DiagnosisContext.h"
 #include "CodeService/NameStyle/NameStyleChecker.h"
@@ -49,13 +51,14 @@ std::vector<vscode::Diagnostic> CodeFormatService::Diagnose(std::string_view fil
 		case DiagnosisType::Blank:
 		case DiagnosisType::Align:
 			{
-				diagnosis.data = "emmylua.format";
+				diagnosis.code = "Emmylua style-check";
 				break;
 			}
 		case DiagnosisType::Spell:
 			{
 				diagnosis.severity = vscode::DiagnosticSeverity::Information;
-				diagnosis.data = "emmylua.spell|" + diagnosisInfo.Data;
+				diagnosis.code = "Emmylua spell-check";
+				diagnosis.data = diagnosisInfo.Data;
 				break;
 			}
 		default:
@@ -88,13 +91,8 @@ std::string CodeFormatService::RangeFormat(LuaFormatRange& range,
 void CodeFormatService::MakeSpellActions(std::shared_ptr<vscode::CodeActionResult> result,
                                          vscode::Diagnostic& diagnostic, std::string_view uri)
 {
-	auto pos = diagnostic.data.find_first_of("|");
-	if (pos == std::string::npos)
-	{
-		return;
-	}
 
-	auto originText = diagnostic.data.substr(pos + 1);
+	auto& originText = diagnostic.data;
 	if (originText.empty())
 	{
 		return;
@@ -103,13 +101,14 @@ void CodeFormatService::MakeSpellActions(std::shared_ptr<vscode::CodeActionResul
 	auto suggests = _spellChecker->GetSuggests(originText);
 	for (auto& suggest : suggests)
 	{
-		if (!suggest.Term.empty()) {
+		if (!suggest.Term.empty())
+		{
 			auto& action = result->actions.emplace_back();
 			auto& term = suggest.Term;
 
 			action.title = term;
 			action.command.title = term;
-			action.command.command = "emmylua.spell.correct";
+			action.command.command = GetService<CommandService>()->GetCommand(CommandService::Command::SpellCorrect);
 			action.command.arguments.push_back(uri);
 			action.command.arguments.push_back(diagnostic.range.Serialize());
 			action.command.arguments.push_back(term);
@@ -126,10 +125,10 @@ void CodeFormatService::LoadDictionary(std::string_view path)
 
 bool CodeFormatService::IsCodeFormatDiagnostic(vscode::Diagnostic& diagnostic)
 {
-	return diagnostic.data == "emmylua.format";
+	return diagnostic.code == "Emmylua style-check";
 }
 
 bool CodeFormatService::IsSpellDiagnostic(vscode::Diagnostic& diagnostic)
 {
-	return diagnostic.data.starts_with("emmylua.spell");
+	return diagnostic.code == "Emmylua spell-check";
 }