diff options
Diffstat (limited to 'Build/source/utils/asymptote/LspCpp/LibLsp/lsp/lsp.cpp')
-rw-r--r-- | Build/source/utils/asymptote/LspCpp/LibLsp/lsp/lsp.cpp | 1087 |
1 files changed, 1087 insertions, 0 deletions
diff --git a/Build/source/utils/asymptote/LspCpp/LibLsp/lsp/lsp.cpp b/Build/source/utils/asymptote/LspCpp/LibLsp/lsp/lsp.cpp new file mode 100644 index 00000000000..81bf34ba3a4 --- /dev/null +++ b/Build/source/utils/asymptote/LspCpp/LibLsp/lsp/lsp.cpp @@ -0,0 +1,1087 @@ + + +#include "lru_cache.h" + + +#include <rapidjson/writer.h> + + +#include <stdio.h> +#include <iostream> +#include "location_type.h" +#include "out_list.h" +#include "lsTextDocumentIdentifier.h" +#include "lsVersionedTextDocumentIdentifier.h" +#include "lsResponseError.h" +#include "lsPosition.h" +#include "lsTextEdit.h" +#include "lsMarkedString.h" +#include "lsWorkspaceEdit.h" +#include "textDocument/code_action.h" +#include "textDocument/document_symbol.h" +#include "extention/jdtls/codeActionResult.h" + +#include "textDocument/selectionRange.h" +#include "AbsolutePath.h" + +#ifdef _WIN32 +#include <Windows.h> +#else +#include <climits> +#include <cstdlib> +#endif + +#include "Directory.h" +#include "lsFormattingOptions.h" +#include "LibLsp/JsonRpc/json.h" +#include "language/language.h" +#include "network/uri/uri_builder.hpp" +#include "lsp_completion.h" +#include "utils.h" +#include "client/registerCapability.h" +#include <boost/uuid/uuid.hpp> +#include <boost/uuid/uuid_io.hpp> +#include <boost/uuid/uuid_generators.hpp> +// namespace + + + +lsTextDocumentIdentifier +lsVersionedTextDocumentIdentifier::AsTextDocumentIdentifier() const { + lsTextDocumentIdentifier result; + result.uri = uri; + return result; +} + + +lsPosition::lsPosition() {} +lsPosition::lsPosition(int line, int character) + : line(line), character(character) {} + +bool lsPosition::operator==(const lsPosition& other) const { + return line == other.line && character == other.character; +} + +bool lsPosition::operator<(const lsPosition& other) const { + return line != other.line ? line < other.line : character < other.character; +} + +std::string lsPosition::ToString() const { + return std::to_string(line) + ":" + std::to_string(character); +} +const lsPosition lsPosition::kZeroPosition = lsPosition(); + +lsRange::lsRange() {} +lsRange::lsRange(lsPosition start, lsPosition end) : start(start), end(end) {} + +bool lsRange::operator==(const lsRange& o) const { + return start == o.start && end == o.end; +} + +bool lsRange::operator<(const lsRange& o) const { + return !(start == o.start) ? start < o.start : end < o.end; +} + +std::string lsRange::ToString() const +{ + std::stringstream ss; + ss << "start:" << start.ToString() << std::endl; + ss << "end" << end.ToString() << std::endl; + return ss.str(); +} + +lsLocation::lsLocation() {} +lsLocation::lsLocation(lsDocumentUri uri, lsRange range) + : uri(uri), range(range) {} + +bool lsLocation::operator==(const lsLocation& o) const { + return uri == o.uri && range == o.range; +} + +bool lsLocation::operator<(const lsLocation& o) const { + return std::make_tuple(uri.raw_uri_, range) < + std::make_tuple(o.uri.raw_uri_, o.range); +} + +bool lsTextEdit::operator==(const lsTextEdit& that) { + return range == that.range && newText == that.newText; +} + +std::string lsTextEdit::ToString() const +{ + std::stringstream ss; + ss << "Range:" << range.ToString() << std::endl; + ss << "newText:" << newText << std::endl; + return ss.str(); +} + +void Reflect(Writer& visitor, lsMarkedString& value) { + // If there is a language, emit a `{language:string, value:string}` object. If + // not, emit a string. + if (value.language) { + REFLECT_MEMBER_START(); + REFLECT_MEMBER(language); + REFLECT_MEMBER(value); + REFLECT_MEMBER_END(); + } else { + Reflect(visitor, value.value); + } +} + +void Reflect(Reader& visitor, lsMarkedString& value) +{ + REFLECT_MEMBER_START(); + REFLECT_MEMBER(language); + REFLECT_MEMBER(value); + REFLECT_MEMBER_END(); +} + + void Reflect(Reader& visitor, LocationListEither::Either& value) +{ + if(!visitor.IsArray()) + { + throw std::invalid_argument("Rsp_LocationListEither::Either& value is not array"); + } + auto data = ((JsonReader&)visitor).m_->GetArray(); + if (data.Size() && data[0].HasMember("originSelectionRange")) + { + Reflect(visitor, value.second); + } + else { + Reflect(visitor, value.first); + } + +} + + void Reflect(Writer& visitor, LocationListEither::Either& value) +{ + if (value.first) + { + Reflect(visitor, value.first.value()); + } + else if (value.second) + { + Reflect(visitor, value.second.value()); + } +} + + +void Reflect(Reader& visitor, TextDocumentCodeAction::Either& value) +{ + + + if(visitor.HasMember("command")) + { + if(visitor["command"]->IsString()) + { + Reflect(visitor, value.first); + } + else + { + Reflect(visitor, value.second); + } + } + else + { + if (visitor.HasMember("diagnostics") || visitor.HasMember("edit")) + { + Reflect(visitor, value.second); + } + else + { + Reflect(visitor, value.first); + } + } + +} + + +void Reflect(Reader& visitor, lsWorkspaceEdit::Either& value) +{ + + + if(visitor.HasMember("textDocument")) + { + Reflect(visitor, value.first); + } + else + { + Reflect(visitor, value.second); + } +} +ResourceOperation* GetResourceOperation(lsp::Any& lspAny) +{ + rapidjson::Document document; + auto& data = lspAny.Data(); + document.Parse(data.c_str(), data.length()); + if (document.HasParseError()) { + // ��ʾ + return nullptr; + } + auto find = document.FindMember("kind"); + + JsonReader visitor{ &document }; + try + { + if (find->value == "create") + { + auto ptr = std::make_unique<lsCreateFile>(); + auto temp = ptr.get(); + Reflect(visitor, *temp); + return ptr.release(); + } + else if (find->value == "rename") + { + auto ptr = std::make_unique<lsRenameFile>(); + auto temp = ptr.get(); + Reflect(visitor, *temp); + return ptr.release(); + } + else if (find->value == "delete") + { + + auto ptr = std::make_unique<lsDeleteFile>(); + auto temp = ptr.get(); + Reflect(visitor, *temp); + return ptr.release(); + } + } + catch (std::exception&) + { + + } + return nullptr; +} + + void Reflect(Writer& visitor, ResourceOperation* value) +{ + + if(!value) + { + throw std::invalid_argument("ResourceOperation value is nullptr"); + } + if (value->kind == "create") + { + auto temp = (lsCreateFile*)value; + Reflect(visitor, *temp); + } + else if (value->kind == "rename") + { + auto temp = (lsRenameFile*)value; + Reflect(visitor, *temp); + } + else if (value->kind == "delete") + { + + auto temp = (lsDeleteFile*)value; + Reflect(visitor, *temp); + } + +} + +int lsp::Any::GuessType() +{ + if (!data.empty()) + { + if (data == "null") + { + jsonType = rapidjson::kNullType; + } + else if (data == "true") + { + jsonType = rapidjson::kTrueType; + } + else if(data == "false") + { + jsonType = rapidjson::kFalseType; + } + else if (data[0] == '{') + { + jsonType = rapidjson::kObjectType; + } + else if (data[0] == '[') + { + if (data.size() >= 2 && data[1] == '{') + jsonType = rapidjson::kStringType; + else + jsonType = rapidjson::kArrayType; + } + else if (data[0] == '"') + { + jsonType = rapidjson::kStringType; + } + else + { + jsonType = rapidjson::kNumberType; + } + } + else + { + if (jsonType != kUnKnown) + return jsonType; + jsonType = rapidjson::kNullType; + } + return jsonType; +} + +int lsp::Any::GetType() +{ + if (jsonType == Type::kUnKnown) + { + if (data.empty()) + { + jsonType = rapidjson::kNullType; + return jsonType; + } + rapidjson::Document document; + document.Parse(data.c_str(), data.length()); + if (document.HasParseError()) + { + // ��ʾ + return jsonType; + } + jsonType = document.GetType(); + } + return jsonType; +} + +void lsp::Any::Set(std::unique_ptr<LspMessage> value) +{ + if (value) + { + jsonType = rapidjson::Type::kObjectType; + data = value->ToJson(); + } + else + { + assert(false); + } +} + +void lsp::Any::SetJsonString(std::string&& _data, Type _type) +{ + jsonType = _type; + data.swap(_data); + GetType(); +} + +void lsp::Any::SetJsonString(const std::string& _data, Type _type) +{ + jsonType = _type; + data = (_data); + GetType(); +} + +void lsp::Any::swap(Any& arg) noexcept +{ + data.swap(arg.data); + const int temp = jsonType; + jsonType = arg.jsonType; + arg.jsonType = temp; +} + +class JsonReaderForAny : public JsonReader +{ +public: + JsonReaderForAny() + : JsonReader(&document) + { + } + rapidjson::Document document; +}; + +bool lsp::Any::GetForMapHelper(std::string& value) +{ + return Get(value); +} + +bool lsp::Any::GetForMapHelper(boost::optional<std::string>& value) +{ + return Get(value); +} + +std::unique_ptr<Reader> lsp::Any::GetReader() +{ + auto reader = new JsonReaderForAny(); + std::unique_ptr<Reader> ret(reader); + reader->document.Parse(data.c_str(), data.length()); + if (reader->document.HasParseError()) + { + return {}; + } + if (jsonType == kUnKnown) + { + jsonType = reader->document.GetType(); + } + return (ret); +} + +class JsonWriterForAny : public JsonWriter +{ +public: + rapidjson::StringBuffer output; + rapidjson::Writer<rapidjson::StringBuffer> writer; + JsonWriterForAny():JsonWriter(&writer), writer(output) + { + + } +}; + +std::unique_ptr<Writer> lsp::Any::GetWriter() const +{ + return std::make_unique<JsonWriterForAny>(); +} + +void lsp::Any::SetData(std::unique_ptr<Writer>& writer) +{ + auto _temp = static_cast<JsonWriterForAny*>(writer.get()); + data = _temp->output.GetString(); + GuessType(); +} + +namespace +{ +#if 0 + rapidjson::Type convert(lsp::Any::Type type) + { + switch (type) + { + case lsp::Any::Type::kNullType: + return rapidjson::Type::kNullType; + case lsp::Any::Type::kFalseType: + return rapidjson::Type::kFalseType; + case lsp::Any::Type::kTrueType: + return rapidjson::Type::kTrueType; + case lsp::Any::Type::kObjectType: + return rapidjson::Type::kObjectType; + case lsp::Any::Type::kArrayType: + return rapidjson::Type::kArrayType; + case lsp::Any::Type::kStringType: + return rapidjson::Type::kStringType; + case lsp::Any::Type::kNumberType: + return rapidjson::Type::kNumberType; + default: + return rapidjson::Type::kNullType; + } + } +#endif + lsp::Any::Type convert(rapidjson::Type type) + { + switch (type) + { + case rapidjson::Type::kNullType: + return lsp::Any::Type::kNullType; + case rapidjson::Type::kFalseType: + return lsp::Any::Type::kFalseType; + case rapidjson::Type::kTrueType: + return lsp::Any::Type::kTrueType; + case rapidjson::Type::kObjectType: + return lsp::Any::Type::kObjectType; + case rapidjson::Type::kArrayType: + return lsp::Any::Type::kArrayType; + case rapidjson::Type::kStringType: + return lsp::Any::Type::kStringType; + case rapidjson::Type::kNumberType: + return lsp::Any::Type::kNumberType; + default: + return lsp::Any::Type::kNullType; + } + } +} + +void Reflect(Reader& visitor, lsp::Any& value) +{ + + //if (visitor.IsNull()) { + // visitor.GetNull(); + // value.SetJsonString("", rapidjson::Type::kNullType); + // return; + //}else + //{ + // + //} + JsonReader& json_reader = reinterpret_cast<JsonReader&>(visitor); + value.SetJsonString(visitor.ToString(), convert(json_reader.m_->GetType())); +} + void Reflect(Writer& visitor, lsp::Any& value) + { + JsonWriter& json_writer = reinterpret_cast<JsonWriter&>(visitor); + json_writer.m_->RawValue( value.Data().data(),value.Data().size(),static_cast<rapidjson::Type>(value.GetType())); + + } + void Reflect(Reader& visitor, lsFormattingOptions::KeyData& value) +{ + if (visitor.IsBool()) + { + Reflect(visitor, value._boolean); + } + else if (visitor.IsInt() || visitor.IsInt64() || visitor.IsUint64()) + { + Reflect(visitor, value._integer); + } + else if(visitor.IsString()) + { + Reflect(visitor, value._string); + } +} + void Reflect(Writer& visitor, lsFormattingOptions::KeyData& value) +{ + if (value._boolean.has_value()) + { + Reflect(visitor, value._boolean); + } + else if (value._integer.has_value()) + { + Reflect(visitor, value._integer); + } + else if (value._string.has_value()) + { + Reflect(visitor, value._string); + } +} + +lsCreateFile::lsCreateFile() +{ + kind = "create"; +} + +lsDeleteFile::lsDeleteFile() +{ + kind = "delete"; +} + +lsRenameFile::lsRenameFile() +{ + kind = "rename"; +} + + +void Reflect(Reader& visitor, boost::optional< SelectionRange* >& value) +{ + if (visitor.IsNull()) { + visitor.GetNull(); + return; + } + + SelectionRange* entry_value = nullptr; + + + std::unique_ptr<SelectionRange> ptr = std::make_unique<SelectionRange>(); + SelectionRange* temp = ptr.get(); + Reflect(visitor, *temp); + + entry_value = ptr.release(); + value = (entry_value); + +} +void Reflect(Writer& visitor, SelectionRange* value) +{ + + if (!value) + { + throw std::invalid_argument("ResourceOperation value is nullptr"); + } + + Reflect(visitor, *value); + + +} + + std::string make_file_scheme_uri(const std::string& absolute_path) +{ + network::uri_builder builder; + builder.scheme("file"); + builder.host(""); + builder.path(absolute_path); + return builder.uri().string(); + //// lsDocumentUri uri; + //// uri.SetPath(absolute_path); + /// return uri.raw_uri_; +} + +// static +AbsolutePath AbsolutePath::BuildDoNotUse(const std::string& path) { + AbsolutePath p; + p.path = std::string(path); + return p; +} + + +AbsolutePath::AbsolutePath() {} + + + +AbsolutePath::operator std::string() const { + return path; +} + +bool AbsolutePath::operator==(const AbsolutePath& rhs) const { + return path == rhs.path; +} + +bool AbsolutePath::operator!=(const AbsolutePath& rhs) const { + return path != rhs.path; +} + +bool AbsolutePath::operator<(const AbsolutePath& rhs) const +{ + return path < rhs.path; +} + +bool AbsolutePath::operator>(const AbsolutePath& rhs) const +{ + return path > rhs.path; +} + +void Reflect(Reader& visitor, AbsolutePath& value) { + value.path = visitor.GetString(); +} +void Reflect(Writer& visitor, AbsolutePath& value) { + visitor.String(value.path.c_str(), value.path.length()); +} + +std::ostream& operator<<(std::ostream& out, const AbsolutePath& path) { + out << path.path; + return out; +} + +lsDocumentUri lsDocumentUri::FromPath(const AbsolutePath& path) { + lsDocumentUri result; + result.SetPath(path); + return result; +} +//void lsDocumentUri::SetPath(const AbsolutePath& path) +//{ +// raw_uri_ = make_file_scheme_uri(path.path); +//} +// +void lsDocumentUri::SetPath(const AbsolutePath& path) { + // file:///c%3A/Users/jacob/Desktop/superindex/indexer/full_tests + raw_uri_ = path; + + size_t index = raw_uri_.find(":"); + if (index == 1) { // widows drive letters must always be 1 char + raw_uri_.replace(raw_uri_.begin() + index, raw_uri_.begin() + index + 1, + "%3A"); + } + + // subset of reserved characters from the URI standard + // http://www.ecma-international.org/ecma-262/6.0/#sec-uri-syntax-and-semantics + std::string t; + t.reserve(8 + raw_uri_.size()); + + // TODO: proper fix +#if defined(_WIN32) + t += "file:///"; +#else + t += "file://"; +#endif + + // clang-format off + for (char c : raw_uri_) + switch (c) { + case ' ': t += "%20"; break; + case '#': t += "%23"; break; + case '$': t += "%24"; break; + case '&': t += "%26"; break; + case '(': t += "%28"; break; + case ')': t += "%29"; break; + case '+': t += "%2B"; break; + case ',': t += "%2C"; break; + case ';': t += "%3B"; break; + case '?': t += "%3F"; break; + case '@': t += "%40"; break; + default: t += c; break; + } + // clang-format on + raw_uri_ = std::move(t); +} + +std::string lsDocumentUri::GetRawPath() const { + + + if (raw_uri_.compare(0, 8, "file:///")) + return raw_uri_; + + + std::string ret; +#if defined(_WIN32) + size_t i = 8; +#else + size_t i = 7; +#endif + auto from_hex = [](unsigned char c) { + return c - '0' < 10 ? c - '0' : (c | 32) - 'a' + 10; + }; + for (; i < raw_uri_.size(); i++) { + if (i + 3 <= raw_uri_.size() && raw_uri_[i] == '%') { + ret.push_back(from_hex(raw_uri_[i + 1]) * 16 + from_hex(raw_uri_[i + 2])); + i += 2; + } + else + ret.push_back(raw_uri_[i] == '\\' ? '/' : raw_uri_[i]); + } + return ret; +} + +lsDocumentUri::lsDocumentUri() {} + + +lsDocumentUri::lsDocumentUri(const AbsolutePath& path) +{ + SetPath(path); +} + +lsDocumentUri::lsDocumentUri(const lsDocumentUri& other): raw_uri_(other.raw_uri_) +{ +} + +bool lsDocumentUri::operator==(const lsDocumentUri& other) const { + return raw_uri_ == other.raw_uri_; +} + +bool lsDocumentUri::operator==(const std::string& other) const +{ + return raw_uri_ == other; +} + + +AbsolutePath lsDocumentUri::GetAbsolutePath() const { + + + if (raw_uri_.find("file://") != std::string::npos){ + try + { + return lsp::NormalizePath(GetRawPath(), false /*ensure_exists*/, false); + } + catch (std::exception&) + { + return AbsolutePath("", false); + } + } + + return AbsolutePath(raw_uri_,false); + +} + +AbsolutePath::AbsolutePath(const std::string& path, bool validate) + : path(path) { + // TODO: enable validation after fixing tests. + if (validate && !lsp::IsAbsolutePath(path)) { + qualify = false; + auto temp = lsp::NormalizePath(path,false); + if(!temp.path.empty()) + { + this->path = temp.path; + } + } +} + +void Reflect(Writer& visitor, lsDocumentUri& value) { + Reflect(visitor, value.raw_uri_); +} +void Reflect(Reader& visitor, lsDocumentUri& value) { + Reflect(visitor, value.raw_uri_); + // Only record the path when we deserialize a URI, since it most likely came + // from the client. + +} + + std::string ProgressReport::ToString() const +{ + std::string info; + info += "id:" + id + "\n"; + info += "task:" + task + "\n"; + info += "subTask:" + subTask + "\n"; + info += "status:" + status + "\n"; + { + std::stringstream ss; + ss << "totalWork:" << totalWork << std::endl; + info += ss.str(); + } + { + std::stringstream ss; + ss << "workDone:" << workDone << std::endl; + info += ss.str(); + } + + { + std::stringstream ss; + ss << "complete:" << complete << std::endl; + info += ss.str(); + } + + return info; +} + +std::string EventNotification::ToString() const +{ + std::string info; + if (ClasspathUpdated == eventType) + { + info += "eventType:ClasspathUpdated\n"; + } + else if (ProjectsImported == eventType) + { + info += "eventType:ProjectsImported\n"; + } + else + { + std::ostringstream oss; + oss << std::hex << eventType << std::endl; + + info += "eventType:"; + info += oss.str(); + } + info += "data:" + data.Data() + "\n"; + return info; +} + +std::string lsp::ToString(lsCompletionItemKind _kind) +{ + switch (_kind) { + case lsCompletionItemKind::Text: + return "Text"; + case lsCompletionItemKind::Method: + return "Method"; + case lsCompletionItemKind::Function: + return ""; + case lsCompletionItemKind::Constructor: + return "Function"; + case lsCompletionItemKind::Field: + return "Field"; + case lsCompletionItemKind::Variable: + return ""; + case lsCompletionItemKind::Class: + return "Variable"; + case lsCompletionItemKind::Interface: + return "Interface"; + case lsCompletionItemKind::Module: + return "Module"; + case lsCompletionItemKind::Property: + return "Property"; + case lsCompletionItemKind::Unit: + return "Unit"; + case lsCompletionItemKind::Value: + return "Value"; + case lsCompletionItemKind::Enum: + return "Enum"; + case lsCompletionItemKind::Keyword: + return "Keyword"; + case lsCompletionItemKind::Snippet: + return "Snippet"; + case lsCompletionItemKind::Color: + return "Color"; + case lsCompletionItemKind::File: + return "File"; + case lsCompletionItemKind::Reference: + return "Reference"; + case lsCompletionItemKind::Folder: + return "Folder"; + case lsCompletionItemKind::EnumMember: + return "EnumMember"; + case lsCompletionItemKind::Constant: + return "Constant"; + case lsCompletionItemKind::Struct: + return "Struct"; + case lsCompletionItemKind::Event: + return "Event"; + case lsCompletionItemKind::Operator: + return "Operator"; + case lsCompletionItemKind::TypeParameter: + return "TypeParameter"; + default: + return "Unknown"; + } +} + +std::string lsp::ToString(lsInsertTextFormat _kind) +{ + if (_kind == lsInsertTextFormat::PlainText) + { + return "PlainText"; + } + else if (_kind == lsInsertTextFormat::Snippet) + { + return "Snippet"; + }else + { + return "Unknown"; + } +} + +const std::string& lsCompletionItem::InsertedContent() const +{ + if (textEdit) + return textEdit->newText; + if (insertText.has_value() && !insertText->empty()) + return insertText.value(); + return label; +} + +std::string lsCompletionItem::DisplayText() +{ + + if (detail) + { + + return label + " in " + detail.value(); + } + return label; +} + +std::string lsCompletionItem::ToString() + { + std::stringstream info; + info << "label : " << label << std::endl; + if(kind) + info << "kind : " << lsp::ToString(kind.value()) << std::endl; + else + info << "kind : no exist." << std::endl; + + if (detail) + info << "detail : " << detail.value() << std::endl; + else + info << "detail : no exist." << std::endl; + + if (documentation) + { + info << "documentation : " << std::endl; + if(documentation.value().first) + { + info << documentation.value().first.value(); + } + else if(documentation.value().second) + { + info << documentation.value().second.value().value; + } + } + else + info << "documentation : no exist." << std::endl; + + if (deprecated) + info << "deprecated : " << deprecated.value() << std::endl; + else + info << "deprecated : no exist." << std::endl; + + if (preselect) + info << "preselect : " << preselect.value() << std::endl; + else + info << "preselect : no exist." << std::endl; + + if (sortText) + info << "sortText : " << sortText.value() << std::endl; + else + info << "sortText : no exist." << std::endl; + + if (filterText) + info << "filterText : " << filterText.value() << std::endl; + else + info << "filterText : no exist." << std::endl; + + + if (insertText) + info << "insertText : " << insertText.value() << std::endl; + else + info << "insertText : no exist." << std::endl; + + + if (insertTextFormat) + info << "insertText : " << lsp::ToString(insertTextFormat.value()) << std::endl; + else + info << "insertTextFormat : no exist." << std::endl; + + if (textEdit) + info << "textEdit : " << textEdit.value().ToString() << std::endl; + else + info << "textEdit : no exist." << std::endl; + + + + return info.str(); + + } +namespace JDT +{ + namespace CodeActionKind { + + + /** + * Base kind for quickfix actions: 'quickfix' + */ + const char* QuickFix = "quickfix"; + + /** + * Base kind for refactoring actions: 'refactor' + */ + const char* Refactor = "refactor"; + + /** + * Base kind for refactoring extraction actions: 'refactor.extract' + * + * Example extract actions: + * + * - Extract method - Extract function - Extract variable - Extract interface + * from class - ... + */ + const char* RefactorExtract = "refactor.extract"; + + /** + * Base kind for refactoring inline actions: 'refactor.inline' + * + * Example inline actions: + * + * - Inline function - Inline variable - Inline constant - ... + */ + const char* RefactorInline = "refactor.inline"; + + /** + * Base kind for refactoring rewrite actions: 'refactor.rewrite' + * + * Example rewrite actions: + * + * - Convert JavaScript function to class - Add or remove parameter - + * Encapsulate field - Make method static - Move method to base class - ... + */ + const char* RefactorRewrite = "refactor.rewrite"; + + /** + * Base kind for source actions: `source` + * + * Source code actions apply to the entire file. + */ + const char* Source = "source"; + + /** + * Base kind for an organize imports source action: `source.organizeImports` + */ + const char* SourceOrganizeImports = "source.organizeImports"; + + const char* COMMAND_ID_APPLY_EDIT = "java.apply.workspaceEdit"; + + }; + + +} +Directory::Directory(const AbsolutePath& path) : path(path.path) { + lsp::EnsureEndsInSlash(this->path); +} + +bool Directory::operator==(const Directory& rhs) const { + return path == rhs.path; +} + +bool Directory::operator!=(const Directory& rhs) const { + return path != rhs.path; +} + + + + Registration Registration::Create(const std::string& method) +{ + Registration reg; + reg.method = method; + const boost::uuids::uuid a_uuid = boost::uuids::random_generator()(); + reg.id = to_string(a_uuid); + return reg; +} |