搭建auto import 基础

Author: CppCXY

3rd/uriparser/src/config.h

@@ -43,7 +43,7 @@
 
 #define PACKAGE_VERSION "0.9.5"
 
-#define HAVE_WPRINTF
+/* #undef HAVE_WPRINTF */
 /* #undef HAVE_REALLOCARRAY */
 
 

CodeFormatServer/CMakeLists.txt

@@ -33,6 +33,7 @@ target_sources(CodeFormatServer
 	${CodeFormatServer_SOURCE_DIR}/src/LanguageService.cpp
 	${CodeFormatServer_SOURCE_DIR}/src/FileManager.cpp
 	${CodeFormatServer_SOURCE_DIR}/src/VirtualFile/VirtualFile.cpp
+	${CodeFormatServer_SOURCE_DIR}/src/Indexs/ModuleIndex.cpp
 	${CodeFormatServer_SOURCE_DIR}/src/Session/IOSession.cpp
 	${CodeFormatServer_SOURCE_DIR}/src/Session/SocketIOSession.cpp
 	${CodeFormatServer_SOURCE_DIR}/src/Session/StandardIOSession.cpp
@@ -43,6 +44,9 @@ target_sources(CodeFormatServer
 
 	${CodeFormatServer_SOURCE_DIR}/src/VSCode.cpp
 
+	#service
+	${CodeFormatServer_SOURCE_DIR}/src/Service/ModuleService.cpp
+
 	# mimalloc
 	${LuaCodeStyle_SOURCE_DIR}/3rd/mimalloc-2.0.3/src/static.c
 )

CodeFormatServer/src/Indexs/ModuleIndex.cpp

@@ -0,0 +1,67 @@
+#include "CodeFormatServer/Indexs/ModuleIndex.h"
+#include "CodeFormatServer/LanguageClient.h"
+
+
+ModuleIndex::ModuleIndex()
+{
+}
+
+void ModuleIndex::BuildIndex(const std::vector<std::string>& files)
+{
+	for (auto& filename : files)
+	{
+		auto options = LanguageClient::GetInstance().GetOptions(filename);
+		auto relativePath = std::filesystem::relative(filename, options->export_root);
+		std::string modulePath = relativePath.replace_extension("").string();
+		if (modulePath.starts_with("."))
+		{
+			continue;
+		}
+
+		for (auto& c : modulePath)
+		{
+			if (c == '/' || c == '\\')
+			{
+				c = '.';
+			}
+		}
+
+		if (modulePath.ends_with(".init"))
+		{
+			modulePath = modulePath.substr(0, modulePath.size() - 5);
+		}
+
+		if (_moduleIndex.count(options->export_root) == 0)
+		{
+			_moduleIndex.insert({options->export_root, std::set<std::string>()});
+		}
+
+		_moduleIndex.at(options->export_root).insert(modulePath);
+	}
+}
+
+void ModuleIndex::ReBuildIndex(const std::vector<std::string>& files)
+{
+	_moduleIndex.clear();
+	BuildIndex(files);
+}
+
+std::vector<std::string> ModuleIndex::GetModules(std::string filename)
+{
+	auto options = LanguageClient::GetInstance().GetOptions(filename);
+
+	std::vector<std::string> modules;
+	for (auto& from : options->import_from)
+	{
+		auto it = _moduleIndex.find(from);
+
+		if (it != _moduleIndex.end())
+		{
+			for (auto& modulePath : it->second)
+			{
+				modules.emplace_back(modulePath);
+			}
+		}
+	}
+	return modules;
+}

CodeFormatServer/src/LanguageClient.cpp

@@ -5,6 +5,7 @@
 #include "LuaParser/LuaParser.h"
 #include "Util/format.h"
 #include "Util/Url.h"
+#include "Util/FileFinder.h"
 
 LanguageClient& LanguageClient::GetInstance()
 {
@@ -13,7 +14,9 @@ LanguageClient& LanguageClient::GetInstance()
 }
 
 LanguageClient::LanguageClient()
-	: _defaultOptions(std::make_shared<LuaCodeStyleOptions>())
+	: _defaultOptions(std::make_shared<LuaCodeStyleOptions>()),
+	  _idCounter(0),
+	  _moduleIndex(std::make_shared<ModuleIndex>())
 {
 }
 
@@ -44,6 +47,24 @@ void LanguageClient::SendNotification(std::string_view method, std::shared_ptr<v
 	}
 }
 
+void LanguageClient::SendRequest(std::string_view method, std::shared_ptr<vscode::Serializable> param)
+{
+	auto json = nlohmann::json::object();
+	json["jsonrpc"] = "2.0";
+	json["method"] = method;
+	json["id"] = GetRequestId();
+	json["params"] = param->Serialize();
+
+	if (_session)
+	{
+		auto dumpResult = json.dump();
+		std::string message = format("Content-Length:{}\r\n\r\n", dumpResult.size());
+
+		message.append(dumpResult);
+		_session->Send(std::move(message));
+	}
+}
+
 void LanguageClient::CacheFile(std::string_view uri, std::string&& text)
 {
 	auto filename = url::UrlToFilePath(uri);
@@ -110,6 +131,9 @@ void LanguageClient::DiagnosticFile(std::string_view uri)
 		diagnosis.severity = vscode::DiagnosticSeverity::Warning;
 	}
 
+
+
+
 	SendNotification("textDocument/publishDiagnostics", vscodeDiagnosis);
 }
 
@@ -133,9 +157,18 @@ void LanguageClient::Run()
 	}
 }
 
-std::shared_ptr<LuaCodeStyleOptions> LanguageClient::GetOptions(std::string_view uri)
+std::shared_ptr<LuaCodeStyleOptions> LanguageClient::GetOptions(std::string_view uriOrFilename)
 {
-	auto filename = url::UrlToFilePath(uri);
+	std::string filename;
+	if (uriOrFilename.starts_with("file"))
+	{
+		filename = url::UrlToFilePath(uriOrFilename);
+	}
+	else
+	{
+		filename = std::string(uriOrFilename);
+	}
+
 	std::size_t matchLength = 0;
 	std::shared_ptr<LuaCodeStyleOptions> options = _defaultOptions;
 	for (auto it = _editorConfigVector.begin(); it != _editorConfigVector.end(); it++)
@@ -159,6 +192,7 @@ void LanguageClient::UpdateOptions(std::string_view workspaceUri, std::string_vi
 		{
 			pair.second = LuaEditorConfig::LoadFromFile(std::string(configPath));
 			pair.second->SetWorkspace(workspace);
+			pair.second->SetRootWorkspace(_root);
 			return;
 		}
 	}
@@ -168,6 +202,7 @@ void LanguageClient::UpdateOptions(std::string_view workspaceUri, std::string_vi
 		LuaEditorConfig::LoadFromFile(std::string(configPath))
 	});
 	_editorConfigVector.back().second->SetWorkspace(workspace);
+	_editorConfigVector.back().second->SetRootWorkspace(_root);
 }
 
 void LanguageClient::RemoveOptions(std::string_view workspaceUri)
@@ -185,9 +220,32 @@ void LanguageClient::RemoveOptions(std::string_view workspaceUri)
 
 void LanguageClient::UpdateAllDiagnosis()
 {
+	FileFinder finder(_root);
+
+	finder.AddIgnoreDirectory(".git");
+	finder.AddIgnoreDirectory(".github");
+	finder.AddIgnoreDirectory(".svn");
+	finder.AddIgnoreDirectory(".idea");
+	finder.AddIgnoreDirectory(".vs");
+	finder.AddIgnoreDirectory(".vscode");
+
+	finder.AddFindExtension(".lua");
+
+	_moduleIndex->ReBuildIndex(finder.FindFiles());
+
 	for (auto it : _fileMap)
 	{
 		auto uri = url::FilePathToUrl(it.first);
 		DiagnosticFile(uri);
 	}
 }
+
+void LanguageClient::SetRoot(std::string_view root)
+{
+	_root = root;
+}
+
+uint64_t LanguageClient::GetRequestId()
+{
+	return ++_idCounter;
+}

CodeFormatServer/src/LanguageService.cpp

@@ -22,6 +22,7 @@ LanguageService::~LanguageService()
 bool LanguageService::Initialize()
 {
 	JsonProtocol("initialize", &LanguageService::OnInitialize);
+	JsonProtocol("Initialized", &LanguageService::OnInitialized);
 	JsonProtocol("textDocument/didChange", &LanguageService::OnDidChange);
 	JsonProtocol("textDocument/didOpen", &LanguageService::OnDidOpen);
 	JsonProtocol("textDocument/didClose", &LanguageService::OnClose);
@@ -100,10 +101,17 @@ std::shared_ptr<vscode::InitializeResult> LanguageService::OnInitialize(std::sha
 		}
 	}
 
+	LanguageClient::GetInstance().SetRoot(param->rootPath);
 
 	return result;
 }
 
+std::shared_ptr<vscode::Serializable> LanguageService::OnInitialized(std::shared_ptr<vscode::Serializable> param)
+{
+	LanguageClient::GetInstance().UpdateAllDiagnosis();
+	return nullptr;
+}
+
 std::shared_ptr<vscode::Serializable> LanguageService::OnDidChange(
 	std::shared_ptr<vscode::DidChangeTextDocumentParams> param)
 {
@@ -278,11 +286,12 @@ std::shared_ptr<vscode::CodeActionResult> LanguageService::OnCodeAction(std::sha
 std::shared_ptr<vscode::Serializable> LanguageService::OnExecuteCommand(
 	std::shared_ptr<vscode::ExecuteCommandParams> param)
 {
-	if(param->command == "emmylua.reformat.me")
+	auto result = std::make_shared<vscode::Serializable>();
+	if (param->command == "emmylua.reformat.me")
 	{
-		if(param->arguments.size() < 2)
+		if (param->arguments.size() < 2)
 		{
-			return nullptr;
+			return result;
 		}
 
 		std::string uri = param->arguments[0];
@@ -292,29 +301,32 @@ std::shared_ptr<vscode::Serializable> LanguageService::OnExecuteCommand(
 
 		auto parser = LanguageClient::GetInstance().GetFileParser(uri);
 
-		auto result = std::make_shared<vscode::DocumentFormattingResult>();
+		auto applyParams = std::make_shared<vscode::ApplyWorkspaceEditParams>();
 
 		auto options = LanguageClient::GetInstance().GetOptions(uri);
 
 		if (parser->HasError())
 		{
-			result->hasError = true;
 			return result;
 		}
 
 		LuaFormatter formatter(parser, *options);
 		formatter.BuildFormattedElement();
+		auto it = applyParams->edit.changes.emplace(uri, std::vector<vscode::TextEdit>());
+		auto& change = it.first->second;
 
-		auto& edit = result->edits.emplace_back();
+		auto& edit = change.emplace_back();
 		LuaFormatRange formattedRange(static_cast<int>(range.start.line), static_cast<int>(range.end.line));
 
 		edit.newText = formatter.GetRangeFormattedText(formattedRange);
 		edit.range = vscode::Range(
 			vscode::Position(formattedRange.StartLine, formattedRange.StartCharacter),
 			vscode::Position(formattedRange.EndLine + 1, formattedRange.EndCharacter)
 		);
-		return result;
+
+
+		LanguageClient::GetInstance().SendRequest("workspace/applyEdit", applyParams);
 	}
 
-	return nullptr;
+	return result;
 }

CodeFormatServer/src/Service/ModuleService.cpp

@@ -0,0 +1,22 @@
+#include "CodeFormatServer/Service/ModuleService.h"
+#include "LuaParser/LuaAstVisitor.h"
+
+class UnResolveModuleFinder : public LuaAstVisitor
+{
+protected:
+	void VisitParamList(const std::shared_ptr<LuaAstNode>& node) override;
+
+	void VisitLocalFunctionStatement(const std::shared_ptr<LuaAstNode>& node) override;
+
+	void VisitLocalStatement(const std::shared_ptr<LuaAstNode>& node) override;
+
+	void VisitIdentify(const std::shared_ptr<LuaAstNode>& node) override;
+
+};
+
+
+
+
+std::vector<vscode::Diagnostic> ModuleService::GetModuleDiagnostics()
+{
+}

CodeFormatServer/src/VSCode.cpp

@@ -1,5 +1,6 @@
 #include "CodeFormatServer/VSCode.h"
 
+
 vscode::Serializable::~Serializable()
 {
 }
@@ -409,3 +410,61 @@ void vscode::ExecuteCommandParams::Deserialize(nlohmann::json json)
 		}
 	}
 }
+
+nlohmann::json vscode::OptionalVersionedTextDocumentIdentifier::Serialize()
+{
+	auto object = TextDocument::Serialize();
+	if(version.has_value())
+	{
+		object["version"] = version.value();
+	}
+	else
+	{
+		object["version"] = nullptr;
+	}
+
+	return object;
+}
+
+nlohmann::json vscode::TextDocumentEdit::Serialize()
+{
+	auto object = nlohmann::json::object();
+
+	object["textDocument"] = textDocument.Serialize();
+
+	object["edits"] = SerializeArray(edits);
+
+	return object;
+}
+
+nlohmann::json vscode::WorkspaceEdit::Serialize()
+{
+	auto object = nlohmann::json::object();
+
+	auto changesObject = nlohmann::json::object();
+
+	for (auto it : changes) {
+		changesObject[it.first] = SerializeArray(it.second);
+	}
+	object["changes"] = changesObject;
+
+	return object;
+}
+
+nlohmann::json vscode::ApplyWorkspaceEditParams::Serialize()
+{
+	auto object = nlohmann::json::object();
+
+	if(label.has_value())
+	{
+		object["label"] = label.value();
+	}
+	else
+	{
+		object["label"] = nullptr;
+	}
+
+	object["edit"] = edit.Serialize();
+
+	return object;
+}