Add a symbol pool to cache all native symbols and workspackes symbols.
Implement hover Implement completion documentation resolve Implement hover documentation Implement go to definition
This commit is contained in:
geequlim
parent
f58560ac36
commit
37aafaaa9c
|
|
@ -30,6 +30,9 @@
|
|||
|
||||
#include "gdscript_extend_parser.h"
|
||||
#include "../gdscript.h"
|
||||
#include "core/io/json.h"
|
||||
#include "gdscript_language_protocol.h"
|
||||
#include "gdscript_workspace.h"
|
||||
|
||||
void ExtendGDScriptParser::update_diagnostics() {
|
||||
|
||||
|
|
@ -43,7 +46,7 @@ void ExtendGDScriptParser::update_diagnostics() {
|
|||
diagnostic.code = -1;
|
||||
lsp::Range range;
|
||||
lsp::Position pos;
|
||||
int line = get_error_line() - 1;
|
||||
int line = LINE_NUMBER_TO_INDEX(get_error_line());
|
||||
const String &line_text = get_lines()[line];
|
||||
pos.line = line;
|
||||
pos.character = line_text.length() - line_text.strip_edges(true, false).length();
|
||||
|
|
@ -64,7 +67,7 @@ void ExtendGDScriptParser::update_diagnostics() {
|
|||
diagnostic.code = warning.code;
|
||||
lsp::Range range;
|
||||
lsp::Position pos;
|
||||
int line = warning.line - 1;
|
||||
int line = LINE_NUMBER_TO_INDEX(warning.line);
|
||||
const String &line_text = get_lines()[line];
|
||||
pos.line = line;
|
||||
pos.character = line_text.length() - line_text.strip_edges(true, false).length();
|
||||
|
|
@ -84,17 +87,23 @@ void ExtendGDScriptParser::update_symbols() {
|
|||
}
|
||||
|
||||
void ExtendGDScriptParser::parse_class_symbol(const GDScriptParser::ClassNode *p_class, lsp::DocumentSymbol &r_symbol) {
|
||||
|
||||
const String uri = get_uri();
|
||||
|
||||
r_symbol.uri = uri;
|
||||
r_symbol.script_path = path;
|
||||
r_symbol.children.clear();
|
||||
r_symbol.name = p_class->name;
|
||||
if (r_symbol.name.empty())
|
||||
r_symbol.name = path.get_file();
|
||||
r_symbol.kind = lsp::SymbolKind::Class;
|
||||
r_symbol.detail = p_class->get_datatype().to_string();
|
||||
r_symbol.deprecated = false;
|
||||
r_symbol.range.start.line = p_class->line - 1;
|
||||
r_symbol.range.start.line = LINE_NUMBER_TO_INDEX(p_class->line);
|
||||
r_symbol.range.start.character = p_class->column;
|
||||
r_symbol.range.end.line = p_class->end_line - 1;
|
||||
r_symbol.range.end.line = LINE_NUMBER_TO_INDEX(p_class->end_line);
|
||||
r_symbol.selectionRange.start.line = r_symbol.range.start.line;
|
||||
r_symbol.detail = "class " + r_symbol.name;
|
||||
r_symbol.documentation = parse_documentation(LINE_NUMBER_TO_INDEX(p_class->line));
|
||||
|
||||
for (int i = 0; i < p_class->variables.size(); ++i) {
|
||||
|
||||
|
|
@ -103,14 +112,22 @@ void ExtendGDScriptParser::parse_class_symbol(const GDScriptParser::ClassNode *p
|
|||
lsp::DocumentSymbol symbol;
|
||||
symbol.name = m.identifier;
|
||||
symbol.kind = lsp::SymbolKind::Variable;
|
||||
symbol.detail = m.data_type.to_string();
|
||||
symbol.deprecated = false;
|
||||
const int line = m.line - 1;
|
||||
const int line = LINE_NUMBER_TO_INDEX(m.line);
|
||||
symbol.range.start.line = line;
|
||||
symbol.range.start.character = lines[line].length() - lines[line].strip_edges(true, false).length();
|
||||
symbol.range.end.line = line;
|
||||
symbol.range.end.character = lines[line].length();
|
||||
symbol.selectionRange.start.line = symbol.range.start.line;
|
||||
symbol.detail = "var " + m.identifier;
|
||||
if (m.data_type.kind != GDScriptParser::DataType::UNRESOLVED) {
|
||||
symbol.detail += ": " + m.data_type.to_string();
|
||||
}
|
||||
symbol.detail += " = " + String(m.default_value);
|
||||
|
||||
symbol.documentation = parse_documentation(line);
|
||||
symbol.uri = uri;
|
||||
symbol.script_path = path;
|
||||
|
||||
r_symbol.children.push_back(symbol);
|
||||
}
|
||||
|
|
@ -122,27 +139,49 @@ void ExtendGDScriptParser::parse_class_symbol(const GDScriptParser::ClassNode *p
|
|||
symbol.name = signal.name;
|
||||
symbol.kind = lsp::SymbolKind::Event;
|
||||
symbol.deprecated = false;
|
||||
const int line = signal.line - 1;
|
||||
const int line = LINE_NUMBER_TO_INDEX(signal.line);
|
||||
symbol.range.start.line = line;
|
||||
symbol.range.start.character = lines[line].length() - lines[line].strip_edges(true, false).length();
|
||||
symbol.range.end.line = symbol.range.start.line;
|
||||
symbol.range.end.character = lines[line].length();
|
||||
symbol.selectionRange.start.line = symbol.range.start.line;
|
||||
symbol.documentation = parse_documentation(line);
|
||||
symbol.uri = uri;
|
||||
symbol.script_path = path;
|
||||
symbol.detail = "signal " + signal.name + "(";
|
||||
for (int j = 0; j < signal.arguments.size(); j++) {
|
||||
if (j > 0) {
|
||||
symbol.detail += ", ";
|
||||
}
|
||||
symbol.detail += signal.arguments[j];
|
||||
}
|
||||
symbol.detail += ")";
|
||||
|
||||
r_symbol.children.push_back(symbol);
|
||||
}
|
||||
|
||||
for (Map<StringName, GDScriptParser::ClassNode::Constant>::Element *E = p_class->constant_expressions.front(); E; E = E->next()) {
|
||||
lsp::DocumentSymbol symbol;
|
||||
const GDScriptParser::ClassNode::Constant &c = E->value();
|
||||
const GDScriptParser::ConstantNode *node = dynamic_cast<const GDScriptParser::ConstantNode *>(c.expression);
|
||||
symbol.name = E->key();
|
||||
symbol.kind = lsp::SymbolKind::Constant;
|
||||
symbol.deprecated = false;
|
||||
const int line = E->get().expression->line - 1;
|
||||
const int line = LINE_NUMBER_TO_INDEX(E->get().expression->line);
|
||||
symbol.range.start.line = line;
|
||||
symbol.range.start.character = E->get().expression->column;
|
||||
symbol.range.end.line = symbol.range.start.line;
|
||||
symbol.range.end.character = lines[line].length();
|
||||
symbol.selectionRange.start.line = symbol.range.start.line;
|
||||
symbol.documentation = parse_documentation(line);
|
||||
symbol.uri = uri;
|
||||
symbol.script_path = path;
|
||||
|
||||
symbol.detail = "const " + symbol.name;
|
||||
if (c.type.kind != GDScriptParser::DataType::UNRESOLVED) {
|
||||
symbol.detail += ": " + c.type.to_string();
|
||||
}
|
||||
symbol.detail += " = " + String(node->value);
|
||||
|
||||
r_symbol.children.push_back(symbol);
|
||||
}
|
||||
|
|
@ -170,39 +209,120 @@ void ExtendGDScriptParser::parse_class_symbol(const GDScriptParser::ClassNode *p
|
|||
}
|
||||
|
||||
void ExtendGDScriptParser::parse_function_symbol(const GDScriptParser::FunctionNode *p_func, lsp::DocumentSymbol &r_symbol) {
|
||||
|
||||
const String uri = get_uri();
|
||||
|
||||
r_symbol.name = p_func->name;
|
||||
r_symbol.kind = lsp::SymbolKind::Function;
|
||||
r_symbol.detail = p_func->get_datatype().to_string();
|
||||
r_symbol.detail = "func " + p_func->name + "(";
|
||||
r_symbol.deprecated = false;
|
||||
const int line = p_func->line - 1;
|
||||
const int line = LINE_NUMBER_TO_INDEX(p_func->line);
|
||||
r_symbol.range.start.line = line;
|
||||
r_symbol.range.start.character = p_func->column;
|
||||
r_symbol.range.end.line = MAX(p_func->body->end_line - 2, p_func->body->line);
|
||||
r_symbol.range.end.character = lines[r_symbol.range.end.line].length();
|
||||
r_symbol.selectionRange.start.line = r_symbol.range.start.line;
|
||||
r_symbol.documentation = GDScriptWorkspace::marked_documentation(parse_documentation(line));
|
||||
r_symbol.uri = uri;
|
||||
r_symbol.script_path = path;
|
||||
|
||||
for (const Map<StringName, LocalVarNode *>::Element *E = p_func->body->variables.front(); E; E = E->next()) {
|
||||
lsp::DocumentSymbol symbol;
|
||||
symbol.name = E->key();
|
||||
symbol.kind = lsp::SymbolKind::Variable;
|
||||
symbol.range.start.line = E->get()->line - 1;
|
||||
symbol.range.start.character = E->get()->column;
|
||||
symbol.range.end.line = symbol.range.start.line;
|
||||
symbol.range.end.character = lines[symbol.range.end.line].length();
|
||||
r_symbol.children.push_back(symbol);
|
||||
}
|
||||
String arguments;
|
||||
for (int i = 0; i < p_func->arguments.size(); i++) {
|
||||
lsp::DocumentSymbol symbol;
|
||||
symbol.kind = lsp::SymbolKind::Variable;
|
||||
symbol.name = p_func->arguments[i];
|
||||
symbol.range.start.line = p_func->body->line - 1;
|
||||
symbol.range.start.line = LINE_NUMBER_TO_INDEX(p_func->body->line);
|
||||
symbol.range.start.character = p_func->body->column;
|
||||
symbol.range.end = symbol.range.start;
|
||||
symbol.uri = uri;
|
||||
symbol.script_path = path;
|
||||
r_symbol.children.push_back(symbol);
|
||||
if (i > 0) {
|
||||
arguments += ", ";
|
||||
}
|
||||
arguments += String(p_func->arguments[i]);
|
||||
if (p_func->argument_types[i].kind != GDScriptParser::DataType::UNRESOLVED) {
|
||||
arguments += ": " + p_func->argument_types[i].to_string();
|
||||
}
|
||||
int default_value_idx = i - (p_func->arguments.size() - p_func->default_values.size());
|
||||
if (default_value_idx >= 0) {
|
||||
const GDScriptParser::ConstantNode *const_node = dynamic_cast<const GDScriptParser::ConstantNode *>(p_func->default_values[default_value_idx]);
|
||||
if (const_node == NULL) {
|
||||
const GDScriptParser::OperatorNode *operator_node = dynamic_cast<const GDScriptParser::OperatorNode *>(p_func->default_values[default_value_idx]);
|
||||
if (operator_node) {
|
||||
const_node = dynamic_cast<const GDScriptParser::ConstantNode *>(operator_node->next);
|
||||
}
|
||||
}
|
||||
|
||||
if (const_node) {
|
||||
String value = JSON::print(const_node->value);
|
||||
arguments += " = " + value;
|
||||
}
|
||||
}
|
||||
}
|
||||
r_symbol.detail += arguments + ")";
|
||||
if (p_func->return_type.kind != GDScriptParser::DataType::UNRESOLVED) {
|
||||
r_symbol.detail += " -> " + p_func->return_type.to_string();
|
||||
}
|
||||
|
||||
for (const Map<StringName, LocalVarNode *>::Element *E = p_func->body->variables.front(); E; E = E->next()) {
|
||||
lsp::DocumentSymbol symbol;
|
||||
const GDScriptParser::LocalVarNode *var = E->value();
|
||||
symbol.name = E->key();
|
||||
symbol.kind = lsp::SymbolKind::Variable;
|
||||
symbol.range.start.line = LINE_NUMBER_TO_INDEX(E->get()->line);
|
||||
symbol.range.start.character = E->get()->column;
|
||||
symbol.range.end.line = symbol.range.start.line;
|
||||
symbol.range.end.character = lines[symbol.range.end.line].length();
|
||||
symbol.uri = uri;
|
||||
symbol.script_path = path;
|
||||
symbol.detail = "var " + symbol.name;
|
||||
if (var->datatype.kind != GDScriptParser::DataType::UNRESOLVED) {
|
||||
symbol.detail += ": " + var->datatype.to_string();
|
||||
}
|
||||
symbol.documentation = GDScriptWorkspace::marked_documentation(parse_documentation(line));
|
||||
r_symbol.children.push_back(symbol);
|
||||
}
|
||||
}
|
||||
|
||||
String ExtendGDScriptParser::get_text_for_completion(const lsp::Position &p_cursor) {
|
||||
String ExtendGDScriptParser::parse_documentation(int p_line) {
|
||||
ERR_FAIL_INDEX_V(p_line, lines.size(), String());
|
||||
|
||||
List<String> doc_lines;
|
||||
|
||||
// inline comment
|
||||
String inline_comment = lines[p_line];
|
||||
int comment_start = inline_comment.find("#");
|
||||
if (comment_start != -1) {
|
||||
inline_comment = inline_comment.substr(comment_start, inline_comment.length());
|
||||
if (inline_comment.length() > 1) {
|
||||
doc_lines.push_back(inline_comment.substr(1, inline_comment.length()));
|
||||
}
|
||||
}
|
||||
|
||||
// upper line comments
|
||||
for (int i = p_line - 1; i >= 0; --i) {
|
||||
String line_comment = lines[i].strip_edges(true, false);
|
||||
if (line_comment.begins_with("#")) {
|
||||
if (line_comment.length() > 1) {
|
||||
doc_lines.push_front(line_comment.substr(1, line_comment.length()));
|
||||
} else {
|
||||
doc_lines.push_front("");
|
||||
}
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
String doc;
|
||||
for (List<String>::Element *E = doc_lines.front(); E; E = E->next()) {
|
||||
String content = E->get();
|
||||
doc += content + "\n";
|
||||
}
|
||||
return doc;
|
||||
}
|
||||
|
||||
String ExtendGDScriptParser::get_text_for_completion(const lsp::Position &p_cursor) const {
|
||||
|
||||
String longthing;
|
||||
int len = lines.size();
|
||||
|
|
@ -224,6 +344,164 @@ String ExtendGDScriptParser::get_text_for_completion(const lsp::Position &p_curs
|
|||
return longthing;
|
||||
}
|
||||
|
||||
String ExtendGDScriptParser::get_text_for_lookup_symbol(const lsp::Position &p_cursor, const String &p_symbol, bool p_func_requred) const {
|
||||
String longthing;
|
||||
int len = lines.size();
|
||||
for (int i = 0; i < len; i++) {
|
||||
|
||||
if (i == p_cursor.line) {
|
||||
String line = lines[i];
|
||||
String first_part = line.substr(0, p_cursor.character);
|
||||
String last_part = line.substr(p_cursor.character, lines[i].size());
|
||||
if (!p_symbol.empty()) {
|
||||
String left_cursor_text;
|
||||
for (int c = p_cursor.character - 1; c >= 0; c--) {
|
||||
left_cursor_text = line.substr(c, p_cursor.character - c);
|
||||
if (p_symbol.begins_with(left_cursor_text)) {
|
||||
first_part = line.substr(0, c);
|
||||
first_part += p_symbol;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
longthing += first_part;
|
||||
longthing += String::chr(0xFFFF); //not unicode, represents the cursor
|
||||
if (p_func_requred) {
|
||||
longthing += "("; // tell the parser this is a function call
|
||||
}
|
||||
longthing += last_part;
|
||||
} else {
|
||||
|
||||
longthing += lines[i];
|
||||
}
|
||||
|
||||
if (i != len - 1)
|
||||
longthing += "\n";
|
||||
}
|
||||
|
||||
return longthing;
|
||||
}
|
||||
|
||||
String ExtendGDScriptParser::get_identifier_under_position(const lsp::Position &p_position, Vector2i &p_offset) const {
|
||||
|
||||
ERR_FAIL_INDEX_V(p_position.line, lines.size(), "");
|
||||
String line = lines[p_position.line];
|
||||
ERR_FAIL_INDEX_V(p_position.character, line.size(), "");
|
||||
|
||||
int start_pos = p_position.character;
|
||||
for (int c = p_position.character; c >= 0; c--) {
|
||||
start_pos = c;
|
||||
CharType ch = line[c];
|
||||
bool valid_char = (ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch == '_';
|
||||
if (!valid_char) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
int end_pos = p_position.character;
|
||||
for (int c = p_position.character; c < line.length(); c++) {
|
||||
CharType ch = line[c];
|
||||
bool valid_char = (ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch == '_';
|
||||
if (!valid_char) {
|
||||
break;
|
||||
}
|
||||
end_pos = c;
|
||||
}
|
||||
if (start_pos < end_pos) {
|
||||
p_offset.x = start_pos - p_position.character;
|
||||
p_offset.y = end_pos - p_position.character;
|
||||
return line.substr(start_pos + 1, end_pos - start_pos);
|
||||
}
|
||||
|
||||
return "";
|
||||
}
|
||||
|
||||
String ExtendGDScriptParser::get_uri() const {
|
||||
return GDScriptLanguageProtocol::get_singleton()->get_workspace().get_file_uri(path);
|
||||
}
|
||||
|
||||
const lsp::DocumentSymbol *ExtendGDScriptParser::search_symbol_defined_at_line(int p_line, const lsp::DocumentSymbol &p_parent) const {
|
||||
const lsp::DocumentSymbol *ret = NULL;
|
||||
if (p_line < p_parent.range.start.line) {
|
||||
return ret;
|
||||
} else if (p_parent.range.start.line == p_line) {
|
||||
return &p_parent;
|
||||
} else {
|
||||
for (int i = 0; i < p_parent.children.size(); i++) {
|
||||
ret = search_symbol_defined_at_line(p_line, p_parent.children[i]);
|
||||
if (ret) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
const lsp::DocumentSymbol *ExtendGDScriptParser::get_symbol_defined_at_line(int p_line) const {
|
||||
if (p_line <= 0) {
|
||||
return &class_symbol;
|
||||
}
|
||||
return search_symbol_defined_at_line(p_line, class_symbol);
|
||||
}
|
||||
|
||||
const lsp::DocumentSymbol *ExtendGDScriptParser::get_member_symbol(const String &p_name) const {
|
||||
const GDScriptParser::Node *head = get_parse_tree();
|
||||
|
||||
if (const GDScriptParser::ClassNode *gdclass = dynamic_cast<const GDScriptParser::ClassNode *>(head)) {
|
||||
|
||||
if (const Map<StringName, GDScriptParser::ClassNode::Constant>::Element *E = gdclass->constant_expressions.find(p_name)) {
|
||||
return get_symbol_defined_at_line(LINE_NUMBER_TO_INDEX(E->get().expression->line));
|
||||
}
|
||||
|
||||
for (int i = 0; i < gdclass->subclasses.size(); i++) {
|
||||
const ClassNode *m = gdclass->subclasses[i];
|
||||
if (m && m->name == p_name) {
|
||||
return get_symbol_defined_at_line(LINE_NUMBER_TO_INDEX(m->line));
|
||||
}
|
||||
}
|
||||
|
||||
for (int i = 0; i < gdclass->variables.size(); i++) {
|
||||
const GDScriptParser::ClassNode::Member &m = gdclass->variables[i];
|
||||
if (m.identifier == p_name) {
|
||||
return get_symbol_defined_at_line(LINE_NUMBER_TO_INDEX(m.line));
|
||||
}
|
||||
}
|
||||
|
||||
for (int i = 0; i < gdclass->functions.size(); i++) {
|
||||
const GDScriptParser::FunctionNode *m = gdclass->functions[i];
|
||||
if (m->name == p_name) {
|
||||
return get_symbol_defined_at_line(LINE_NUMBER_TO_INDEX(m->line));
|
||||
}
|
||||
}
|
||||
|
||||
for (int i = 0; i < gdclass->static_functions.size(); i++) {
|
||||
const GDScriptParser::FunctionNode *m = gdclass->static_functions[i];
|
||||
if (m->name == p_name) {
|
||||
return get_symbol_defined_at_line(LINE_NUMBER_TO_INDEX(m->line));
|
||||
}
|
||||
}
|
||||
|
||||
for (int i = 0; i < gdclass->_signals.size(); i++) {
|
||||
const GDScriptParser::ClassNode::Signal &m = gdclass->_signals[i];
|
||||
if (m.name == p_name) {
|
||||
return get_symbol_defined_at_line(LINE_NUMBER_TO_INDEX(m.line));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void ExtendGDScriptParser::dump_symbols(HashMap<String, lsp::DocumentedSymbolInformation> &r_symbols) {
|
||||
Vector<lsp::DocumentedSymbolInformation> list;
|
||||
class_symbol.symbol_tree_as_list(path, list, path, true);
|
||||
for (int i = 0; i < list.size(); i++) {
|
||||
const lsp::DocumentedSymbolInformation &symbol = list[i];
|
||||
r_symbols.set(symbol.name, symbol);
|
||||
}
|
||||
}
|
||||
|
||||
Error ExtendGDScriptParser::parse(const String &p_code, const String &p_path) {
|
||||
path = p_path;
|
||||
code = p_code;
|
||||
|
|
@ -232,6 +510,5 @@ Error ExtendGDScriptParser::parse(const String &p_code, const String &p_path) {
|
|||
Error err = GDScriptParser::parse(p_code, p_path.get_base_dir(), false, p_path, false, NULL, false);
|
||||
update_diagnostics();
|
||||
update_symbols();
|
||||
|
||||
return err;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -35,6 +35,10 @@
|
|||
#include "core/variant.h"
|
||||
#include "lsp.hpp"
|
||||
|
||||
#ifndef LINE_NUMBER_TO_INDEX
|
||||
#define LINE_NUMBER_TO_INDEX(p_line) ((p_line)-1)
|
||||
#endif
|
||||
|
||||
class ExtendGDScriptParser : public GDScriptParser {
|
||||
String path;
|
||||
String code;
|
||||
|
|
@ -48,6 +52,9 @@ class ExtendGDScriptParser : public GDScriptParser {
|
|||
|
||||
void parse_class_symbol(const GDScriptParser::ClassNode *p_class, lsp::DocumentSymbol &r_symbol);
|
||||
void parse_function_symbol(const GDScriptParser::FunctionNode *p_func, lsp::DocumentSymbol &r_symbol);
|
||||
String parse_documentation(int p_line);
|
||||
|
||||
const lsp::DocumentSymbol *search_symbol_defined_at_line(int p_line, const lsp::DocumentSymbol &p_parent) const;
|
||||
|
||||
public:
|
||||
_FORCE_INLINE_ const String &get_path() const { return path; }
|
||||
|
|
@ -56,7 +63,15 @@ public:
|
|||
_FORCE_INLINE_ const lsp::DocumentSymbol &get_symbols() const { return class_symbol; }
|
||||
_FORCE_INLINE_ const Vector<lsp::Diagnostic> &get_diagnostics() const { return diagnostics; }
|
||||
|
||||
String get_text_for_completion(const lsp::Position &p_cursor);
|
||||
String get_text_for_completion(const lsp::Position &p_cursor) const;
|
||||
String get_text_for_lookup_symbol(const lsp::Position &p_cursor, const String &p_symbol = "", bool p_func_requred = false) const;
|
||||
String get_identifier_under_position(const lsp::Position &p_position, Vector2i &p_offset) const;
|
||||
String get_uri() const;
|
||||
|
||||
const lsp::DocumentSymbol *get_symbol_defined_at_line(int p_line) const;
|
||||
const lsp::DocumentSymbol *get_member_symbol(const String &p_name) const;
|
||||
|
||||
void dump_symbols(HashMap<String, lsp::DocumentedSymbolInformation> &r_symbols);
|
||||
|
||||
Error parse(const String &p_code, const String &p_path);
|
||||
};
|
||||
|
|
|
|||
|
|
@ -90,7 +90,7 @@ void GDScriptLanguageProtocol::_bind_methods() {
|
|||
Dictionary GDScriptLanguageProtocol::initialize(const Dictionary &p_params) {
|
||||
|
||||
lsp::InitializeResult ret;
|
||||
|
||||
workspace.initialize();
|
||||
return ret.to_json();
|
||||
}
|
||||
|
||||
|
|
@ -163,6 +163,7 @@ GDScriptLanguageProtocol::GDScriptLanguageProtocol() {
|
|||
server = NULL;
|
||||
singleton = this;
|
||||
set_scope("textDocument", &text_document);
|
||||
set_scope("completionItem", &text_document);
|
||||
set_scope("workspace", &workspace);
|
||||
workspace.root = ProjectSettings::get_singleton()->get_resource_path();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -30,6 +30,7 @@
|
|||
|
||||
#include "gdscript_text_document.h"
|
||||
#include "../gdscript.h"
|
||||
#include "gdscript_extend_parser.h"
|
||||
#include "gdscript_language_protocol.h"
|
||||
|
||||
void GDScriptTextDocument::_bind_methods() {
|
||||
|
|
@ -37,11 +38,13 @@ void GDScriptTextDocument::_bind_methods() {
|
|||
ClassDB::bind_method(D_METHOD("didChange"), &GDScriptTextDocument::didChange);
|
||||
ClassDB::bind_method(D_METHOD("documentSymbol"), &GDScriptTextDocument::documentSymbol);
|
||||
ClassDB::bind_method(D_METHOD("completion"), &GDScriptTextDocument::completion);
|
||||
ClassDB::bind_method(D_METHOD("resolve"), &GDScriptTextDocument::resolve);
|
||||
ClassDB::bind_method(D_METHOD("foldingRange"), &GDScriptTextDocument::foldingRange);
|
||||
ClassDB::bind_method(D_METHOD("codeLens"), &GDScriptTextDocument::codeLens);
|
||||
ClassDB::bind_method(D_METHOD("documentLink"), &GDScriptTextDocument::documentLink);
|
||||
ClassDB::bind_method(D_METHOD("colorPresentation"), &GDScriptTextDocument::colorPresentation);
|
||||
ClassDB::bind_method(D_METHOD("hover"), &GDScriptTextDocument::hover);
|
||||
ClassDB::bind_method(D_METHOD("definition"), &GDScriptTextDocument::definition);
|
||||
}
|
||||
|
||||
void GDScriptTextDocument::didOpen(const Variant &p_param) {
|
||||
|
|
@ -75,7 +78,7 @@ Array GDScriptTextDocument::documentSymbol(const Dictionary &p_params) {
|
|||
String path = GDScriptLanguageProtocol::get_singleton()->get_workspace().get_file_path(uri);
|
||||
Array arr;
|
||||
if (const Map<String, ExtendGDScriptParser *>::Element *parser = GDScriptLanguageProtocol::get_singleton()->get_workspace().scripts.find(path)) {
|
||||
Vector<lsp::SymbolInformation> list;
|
||||
Vector<lsp::DocumentedSymbolInformation> list;
|
||||
parser->get()->get_symbols().symbol_tree_as_list(uri, list);
|
||||
for (int i = 0; i < list.size(); i++) {
|
||||
arr.push_back(list[i].to_json());
|
||||
|
|
@ -144,6 +147,18 @@ Array GDScriptTextDocument::completion(const Dictionary &p_params) {
|
|||
return arr;
|
||||
}
|
||||
|
||||
Dictionary GDScriptTextDocument::resolve(const Dictionary &p_params) {
|
||||
lsp::CompletionItem item;
|
||||
item.load(p_params);
|
||||
lsp::CompletionParams params;
|
||||
params.load(p_params["data"]);
|
||||
const lsp::DocumentSymbol *symbol = GDScriptLanguageProtocol::get_singleton()->get_workspace().resolve_symbol(params, item.label, item.kind == lsp::CompletionItemKind::Method || item.kind == lsp::CompletionItemKind::Function);
|
||||
if (symbol) {
|
||||
item.documentation = symbol->render();
|
||||
}
|
||||
return item.to_json();
|
||||
}
|
||||
|
||||
Array GDScriptTextDocument::foldingRange(const Dictionary &p_params) {
|
||||
Dictionary params = p_params["textDocument"];
|
||||
String path = params["uri"];
|
||||
|
|
@ -168,9 +183,49 @@ Array GDScriptTextDocument::colorPresentation(const Dictionary &p_params) {
|
|||
|
||||
Variant GDScriptTextDocument::hover(const Dictionary &p_params) {
|
||||
Variant ret;
|
||||
|
||||
lsp::TextDocumentPositionParams params;
|
||||
params.load(p_params);
|
||||
|
||||
const lsp::DocumentSymbol *symbol = GDScriptLanguageProtocol::get_singleton()->get_workspace().resolve_symbol(params);
|
||||
if (symbol) {
|
||||
lsp::Hover hover;
|
||||
hover.contents = symbol->render();
|
||||
ret = hover.to_json();
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
Array GDScriptTextDocument::definition(const Dictionary &p_params) {
|
||||
Array arr;
|
||||
|
||||
lsp::TextDocumentPositionParams params;
|
||||
params.load(p_params);
|
||||
|
||||
const lsp::DocumentSymbol *symbol = GDScriptLanguageProtocol::get_singleton()->get_workspace().resolve_symbol(params);
|
||||
if (symbol) {
|
||||
lsp::Location location;
|
||||
location.uri = symbol->uri;
|
||||
location.range = symbol->range;
|
||||
|
||||
const String &path = GDScriptLanguageProtocol::get_singleton()->get_workspace().get_file_path(symbol->uri);
|
||||
if (file_checker->file_exists(path)) {
|
||||
arr.push_back(location.to_json());
|
||||
}
|
||||
}
|
||||
|
||||
return arr;
|
||||
}
|
||||
|
||||
GDScriptTextDocument::GDScriptTextDocument() {
|
||||
file_checker = FileAccess::create(FileAccess::ACCESS_RESOURCES);
|
||||
}
|
||||
|
||||
GDScriptTextDocument::~GDScriptTextDocument() {
|
||||
memdelete(file_checker);
|
||||
}
|
||||
|
||||
void GDScriptTextDocument::sync_script_content(const String &p_uri, const String &p_content) {
|
||||
String path = GDScriptLanguageProtocol::get_singleton()->get_workspace().get_file_path(p_uri);
|
||||
GDScriptLanguageProtocol::get_singleton()->get_workspace().parse_script(path, p_content);
|
||||
|
|
|
|||
|
|
@ -31,6 +31,7 @@
|
|||
#ifndef GDSCRIPT_TEXT_DOCUMENT_H
|
||||
#define GDSCRIPT_TEXT_DOCUMENT_H
|
||||
|
||||
#include "core/os/file_access.h"
|
||||
#include "core/reference.h"
|
||||
#include "lsp.hpp"
|
||||
|
||||
|
|
@ -39,6 +40,8 @@ class GDScriptTextDocument : public Reference {
|
|||
protected:
|
||||
static void _bind_methods();
|
||||
|
||||
FileAccess *file_checker;
|
||||
|
||||
void didOpen(const Variant &p_param);
|
||||
void didChange(const Variant &p_param);
|
||||
|
||||
|
|
@ -50,11 +53,16 @@ private:
|
|||
public:
|
||||
Array documentSymbol(const Dictionary &p_params);
|
||||
Array completion(const Dictionary &p_params);
|
||||
Dictionary resolve(const Dictionary &p_params);
|
||||
Array foldingRange(const Dictionary &p_params);
|
||||
Array codeLens(const Dictionary &p_params);
|
||||
Variant documentLink(const Dictionary &p_params);
|
||||
Array colorPresentation(const Dictionary &p_params);
|
||||
Variant hover(const Dictionary &p_params);
|
||||
Array definition(const Dictionary &p_params);
|
||||
|
||||
GDScriptTextDocument();
|
||||
virtual ~GDScriptTextDocument();
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -32,6 +32,8 @@
|
|||
#include "../gdscript.h"
|
||||
#include "../gdscript_parser.h"
|
||||
#include "core/project_settings.h"
|
||||
#include "core/script_language.h"
|
||||
#include "editor/editor_help.h"
|
||||
#include "gdscript_language_protocol.h"
|
||||
|
||||
void GDScriptWorkspace::_bind_methods() {
|
||||
|
|
@ -59,12 +61,156 @@ void GDScriptWorkspace::remove_cache_parser(const String &p_path) {
|
|||
}
|
||||
}
|
||||
|
||||
const lsp::DocumentSymbol *GDScriptWorkspace::get_native_symbol(const String &p_class, const String &p_member) const {
|
||||
|
||||
StringName class_name = p_class;
|
||||
StringName end_pos;
|
||||
|
||||
while (class_name != end_pos) {
|
||||
if (const Map<StringName, lsp::DocumentSymbol>::Element *E = native_symbols.find(class_name)) {
|
||||
const lsp::DocumentSymbol &class_symbol = E->value();
|
||||
|
||||
if (p_member.empty()) {
|
||||
return &class_symbol;
|
||||
} else {
|
||||
for (int i = 0; i < class_symbol.children.size(); i++) {
|
||||
const lsp::DocumentSymbol &symbol = class_symbol.children[i];
|
||||
if (symbol.name == p_member) {
|
||||
return &symbol;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
class_name = ClassDB::get_parent_class(class_name);
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const lsp::DocumentSymbol *GDScriptWorkspace::get_script_symbol(const String &p_path) const {
|
||||
const Map<String, ExtendGDScriptParser *>::Element *S = scripts.find(p_path);
|
||||
if (S) {
|
||||
return &(S->get()->get_symbols());
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void GDScriptWorkspace::reload_all_workspace_scripts() {
|
||||
List<String> pathes;
|
||||
list_script_files("res://", pathes);
|
||||
for (List<String>::Element *E = pathes.front(); E; E = E->next()) {
|
||||
const String &path = E->get();
|
||||
Error err;
|
||||
String content = FileAccess::get_file_as_string(path, &err);
|
||||
ERR_CONTINUE(err != OK);
|
||||
err = parse_script(path, content);
|
||||
|
||||
if (err != OK) {
|
||||
Map<String, ExtendGDScriptParser *>::Element *S = parse_results.find(path);
|
||||
String err_msg = "Failed parse script " + path;
|
||||
if (S) {
|
||||
err_msg += "\n" + S->get()->get_error();
|
||||
}
|
||||
ERR_EXPLAIN(err_msg);
|
||||
ERR_CONTINUE(err != OK);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void GDScriptWorkspace::list_script_files(const String &p_root_dir, List<String> &r_files) {
|
||||
Error err;
|
||||
DirAccessRef dir = DirAccess::open(p_root_dir, &err);
|
||||
if (OK == err) {
|
||||
dir->list_dir_begin();
|
||||
String file_name = dir->get_next();
|
||||
while (file_name.length()) {
|
||||
if (dir->current_is_dir() && file_name != "." && file_name != ".." && file_name != "./") {
|
||||
list_script_files(p_root_dir.plus_file(file_name), r_files);
|
||||
} else if (file_name.ends_with(".gd")) {
|
||||
String script_file = p_root_dir.plus_file(file_name);
|
||||
r_files.push_back(script_file);
|
||||
}
|
||||
file_name = dir->get_next();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
ExtendGDScriptParser *GDScriptWorkspace::get_parse_successed_script(const String &p_path) {
|
||||
const Map<String, ExtendGDScriptParser *>::Element *S = scripts.find(p_path);
|
||||
if (!S) {
|
||||
parse_local_script(p_path);
|
||||
S = scripts.find(p_path);
|
||||
}
|
||||
if (S) {
|
||||
return S->get();
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
ExtendGDScriptParser *GDScriptWorkspace::get_parse_result(const String &p_path) {
|
||||
const Map<String, ExtendGDScriptParser *>::Element *S = scripts.find(p_path);
|
||||
if (!S) {
|
||||
S = parse_results.find(p_path);
|
||||
if (!S) {
|
||||
parse_local_script(p_path);
|
||||
S = scripts.find(p_path);
|
||||
}
|
||||
}
|
||||
if (S) {
|
||||
return S->get();
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
String GDScriptWorkspace::marked_documentation(const String &p_bbcode) {
|
||||
|
||||
String markdown = p_bbcode.strip_edges();
|
||||
|
||||
Vector<String> lines = markdown.split("\n");
|
||||
bool in_code_block = false;
|
||||
int code_block_indent = -1;
|
||||
|
||||
markdown = "";
|
||||
for (int i = 0; i < lines.size(); i++) {
|
||||
String line = lines[i];
|
||||
line = line.replace("[code]", "`");
|
||||
line = line.replace("[/code]", "`");
|
||||
line = line.replace("[i]", "*");
|
||||
line = line.replace("[/i]", "*");
|
||||
line = line.replace("[b]", "**");
|
||||
line = line.replace("[/b]", "**");
|
||||
line = line.replace("[u]", "__");
|
||||
line = line.replace("[/u]", "__");
|
||||
int block_start = line.find("[codeblock]");
|
||||
if (block_start != -1) {
|
||||
code_block_indent = block_start;
|
||||
in_code_block = true;
|
||||
line = "'''gdscript";
|
||||
line = "\n";
|
||||
} else if (in_code_block) {
|
||||
line = "\t" + line.substr(code_block_indent, line.length());
|
||||
} else {
|
||||
line = line.strip_edges();
|
||||
}
|
||||
if (in_code_block && line.find("[/codeblock]") != -1) {
|
||||
line = "'''\n";
|
||||
line = "\n";
|
||||
in_code_block = false;
|
||||
}
|
||||
if (!in_code_block && i < lines.size() - 1) {
|
||||
line += "\n";
|
||||
}
|
||||
markdown += line + "\n";
|
||||
}
|
||||
return markdown;
|
||||
}
|
||||
|
||||
Array GDScriptWorkspace::symbol(const Dictionary &p_params) {
|
||||
String query = p_params["query"];
|
||||
Array arr;
|
||||
if (!query.empty()) {
|
||||
for (Map<String, ExtendGDScriptParser *>::Element *E = scripts.front(); E; E = E->next()) {
|
||||
Vector<lsp::SymbolInformation> script_symbols;
|
||||
Vector<lsp::DocumentedSymbolInformation> script_symbols;
|
||||
E->get()->get_symbols().symbol_tree_as_list(E->key(), script_symbols);
|
||||
for (int i = 0; i < script_symbols.size(); ++i) {
|
||||
if (query.is_subsequence_ofi(script_symbols[i].name)) {
|
||||
|
|
@ -76,6 +222,102 @@ Array GDScriptWorkspace::symbol(const Dictionary &p_params) {
|
|||
return arr;
|
||||
}
|
||||
|
||||
Error GDScriptWorkspace::initialize() {
|
||||
if (initialized) return OK;
|
||||
|
||||
DocData *doc = EditorHelp::get_doc_data();
|
||||
for (Map<String, DocData::ClassDoc>::Element *E = doc->class_list.front(); E; E = E->next()) {
|
||||
|
||||
const DocData::ClassDoc &class_data = E->value();
|
||||
lsp::DocumentSymbol class_symbol;
|
||||
String class_name = E->key();
|
||||
class_symbol.name = class_name;
|
||||
class_symbol.kind = lsp::SymbolKind::Class;
|
||||
class_symbol.detail = String("<Native> class ") + class_name;
|
||||
if (!class_data.inherits.empty()) {
|
||||
class_symbol.detail += " extends " + class_data.inherits;
|
||||
}
|
||||
class_symbol.documentation = marked_documentation(class_data.brief_description) + "\n" + marked_documentation(class_data.description);
|
||||
|
||||
for (int i = 0; i < class_data.constants.size(); i++) {
|
||||
const DocData::ConstantDoc &const_data = class_data.constants[i];
|
||||
lsp::DocumentSymbol symbol;
|
||||
symbol.name = const_data.name;
|
||||
symbol.kind = lsp::SymbolKind::Constant;
|
||||
symbol.detail = "const " + class_name + "." + const_data.name;
|
||||
if (const_data.enumeration.length()) {
|
||||
symbol.detail += ": " + const_data.enumeration;
|
||||
}
|
||||
symbol.detail += " = " + const_data.value;
|
||||
symbol.documentation = marked_documentation(const_data.description);
|
||||
class_symbol.children.push_back(symbol);
|
||||
}
|
||||
|
||||
Vector<DocData::PropertyDoc> properties;
|
||||
properties.append_array(class_data.properties);
|
||||
const int theme_prop_start_idx = properties.size();
|
||||
properties.append_array(class_data.theme_properties);
|
||||
|
||||
for (int i = 0; i < class_data.properties.size(); i++) {
|
||||
const DocData::PropertyDoc &data = class_data.properties[i];
|
||||
lsp::DocumentSymbol symbol;
|
||||
symbol.name = data.name;
|
||||
symbol.kind = lsp::SymbolKind::Property;
|
||||
symbol.detail = String(i >= theme_prop_start_idx ? "<Theme> var" : "var") + " " + class_name + "." + data.name;
|
||||
if (data.enumeration.length()) {
|
||||
symbol.detail += ": " + data.enumeration;
|
||||
} else {
|
||||
symbol.detail += ": " + data.type;
|
||||
}
|
||||
symbol.documentation = marked_documentation(data.description);
|
||||
class_symbol.children.push_back(symbol);
|
||||
}
|
||||
|
||||
Vector<DocData::MethodDoc> methods_signals;
|
||||
methods_signals.append_array(class_data.methods);
|
||||
const int signal_start_idx = methods_signals.size();
|
||||
methods_signals.append_array(class_data.signals);
|
||||
|
||||
for (int i = 0; i < methods_signals.size(); i++) {
|
||||
const DocData::MethodDoc &data = methods_signals[i];
|
||||
|
||||
lsp::DocumentSymbol symbol;
|
||||
symbol.name = data.name;
|
||||
symbol.kind = i >= signal_start_idx ? lsp::SymbolKind::Event : lsp::SymbolKind::Method;
|
||||
|
||||
String params = "";
|
||||
bool arg_default_value_started = false;
|
||||
for (int j = 0; j < data.arguments.size(); j++) {
|
||||
const DocData::ArgumentDoc &arg = data.arguments[j];
|
||||
if (!arg_default_value_started && !arg.default_value.empty()) {
|
||||
arg_default_value_started = true;
|
||||
}
|
||||
String arg_str = arg.name + ": " + arg.type;
|
||||
if (arg_default_value_started) {
|
||||
arg_str += " = " + arg.default_value;
|
||||
}
|
||||
if (j < data.arguments.size() - 1) {
|
||||
arg_str += ", ";
|
||||
}
|
||||
params += arg_str;
|
||||
}
|
||||
if (data.qualifiers.find("vararg") != -1) {
|
||||
params += params.empty() ? "..." : ", ...";
|
||||
}
|
||||
|
||||
symbol.detail = "func " + class_name + "." + data.name + "(" + params + ") -> " + data.return_type;
|
||||
symbol.documentation = marked_documentation(data.description);
|
||||
class_symbol.children.push_back(symbol);
|
||||
}
|
||||
|
||||
native_symbols.insert(class_name, class_symbol);
|
||||
}
|
||||
|
||||
reload_all_workspace_scripts();
|
||||
|
||||
return OK;
|
||||
}
|
||||
|
||||
Error GDScriptWorkspace::parse_script(const String &p_path, const String &p_content) {
|
||||
ExtendGDScriptParser *parser = memnew(ExtendGDScriptParser);
|
||||
Error err = parser->parse(p_content, p_path);
|
||||
|
|
@ -98,6 +340,15 @@ Error GDScriptWorkspace::parse_script(const String &p_path, const String &p_cont
|
|||
return err;
|
||||
}
|
||||
|
||||
Error GDScriptWorkspace::parse_local_script(const String &p_path) {
|
||||
Error err;
|
||||
String content = FileAccess::get_file_as_string(p_path, &err);
|
||||
if (err == OK) {
|
||||
err = parse_script(p_path, content);
|
||||
}
|
||||
return err;
|
||||
}
|
||||
|
||||
String GDScriptWorkspace::get_file_path(const String &p_uri) const {
|
||||
String path = p_uri.replace("file://", "").http_unescape();
|
||||
path = path.replace(root + "/", "res://");
|
||||
|
|
@ -135,18 +386,77 @@ void GDScriptWorkspace::completion(const lsp::CompletionParams &p_params, List<S
|
|||
}
|
||||
}
|
||||
|
||||
const lsp::DocumentSymbol *GDScriptWorkspace::resolve_symbol(const lsp::TextDocumentPositionParams &p_doc_pos, const String &p_symbol_name, bool p_func_requred) {
|
||||
|
||||
const lsp::DocumentSymbol *symbol = NULL;
|
||||
|
||||
String path = get_file_path(p_doc_pos.textDocument.uri);
|
||||
if (const ExtendGDScriptParser *parser = get_parse_result(path)) {
|
||||
|
||||
String symbol_identifier = p_symbol_name;
|
||||
lsp::Position pos = p_doc_pos.position;
|
||||
if (symbol_identifier.empty()) {
|
||||
Vector2i offset;
|
||||
symbol_identifier = parser->get_identifier_under_position(p_doc_pos.position, offset);
|
||||
pos.character += offset.y;
|
||||
}
|
||||
|
||||
if (!symbol_identifier.empty()) {
|
||||
|
||||
if (ScriptServer::is_global_class(symbol_identifier)) {
|
||||
|
||||
String class_path = ScriptServer::get_global_class_path(symbol_identifier);
|
||||
symbol = get_script_symbol(class_path);
|
||||
|
||||
} else {
|
||||
|
||||
ScriptLanguage::LookupResult ret;
|
||||
if (OK == GDScriptLanguage::get_singleton()->lookup_code(parser->get_text_for_lookup_symbol(pos, symbol_identifier, p_func_requred), symbol_identifier, path, NULL, ret)) {
|
||||
|
||||
if (ret.type == ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION) {
|
||||
|
||||
String target_script_path = path;
|
||||
if (!ret.script.is_null()) {
|
||||
target_script_path = ret.script->get_path();
|
||||
}
|
||||
|
||||
if (const ExtendGDScriptParser *target_parser = get_parse_result(target_script_path)) {
|
||||
symbol = target_parser->get_symbol_defined_at_line(LINE_NUMBER_TO_INDEX(ret.location));
|
||||
}
|
||||
|
||||
} else {
|
||||
|
||||
String member = ret.class_member;
|
||||
if (member.empty() && symbol_identifier != ret.class_name) {
|
||||
member = symbol_identifier;
|
||||
}
|
||||
symbol = get_native_symbol(ret.class_name, member);
|
||||
}
|
||||
} else {
|
||||
symbol = parser->get_member_symbol(symbol_identifier);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return symbol;
|
||||
}
|
||||
|
||||
GDScriptWorkspace::GDScriptWorkspace() {
|
||||
ProjectSettings::get_singleton()->get_resource_path();
|
||||
}
|
||||
|
||||
GDScriptWorkspace::~GDScriptWorkspace() {
|
||||
Set<String> cached_parsers;
|
||||
|
||||
for (Map<String, ExtendGDScriptParser *>::Element *E = parse_results.front(); E; E = E->next()) {
|
||||
cached_parsers.insert(E->key());
|
||||
}
|
||||
|
||||
for (Map<String, ExtendGDScriptParser *>::Element *E = scripts.front(); E; E = E->next()) {
|
||||
cached_parsers.insert(E->key());
|
||||
}
|
||||
|
||||
for (Set<String>::Element *E = cached_parsers.front(); E; E = E->next()) {
|
||||
remove_cache_parser(E->get());
|
||||
}
|
||||
|
|
|
|||
|
|
@ -42,6 +42,17 @@ class GDScriptWorkspace : public Reference {
|
|||
protected:
|
||||
static void _bind_methods();
|
||||
void remove_cache_parser(const String &p_path);
|
||||
bool initialized = false;
|
||||
Map<StringName, lsp::DocumentSymbol> native_symbols;
|
||||
|
||||
const lsp::DocumentSymbol *get_native_symbol(const String &p_class, const String &p_member = "") const;
|
||||
const lsp::DocumentSymbol *get_script_symbol(const String &p_path) const;
|
||||
|
||||
void reload_all_workspace_scripts();
|
||||
|
||||
void list_script_files(const String &p_root_dir, List<String> &r_files);
|
||||
ExtendGDScriptParser *get_parse_successed_script(const String &p_path);
|
||||
ExtendGDScriptParser *get_parse_result(const String &p_path);
|
||||
|
||||
public:
|
||||
String root;
|
||||
|
|
@ -52,11 +63,15 @@ public:
|
|||
Array symbol(const Dictionary &p_params);
|
||||
|
||||
public:
|
||||
Error initialize();
|
||||
Error parse_script(const String &p_path, const String &p_content);
|
||||
Error parse_local_script(const String &p_path);
|
||||
String get_file_path(const String &p_uri) const;
|
||||
String get_file_uri(const String &p_path) const;
|
||||
void publish_diagnostics(const String &p_path);
|
||||
void completion(const lsp::CompletionParams &p_params, List<ScriptCodeCompletionOption> *r_options);
|
||||
const lsp::DocumentSymbol *resolve_symbol(const lsp::TextDocumentPositionParams &p_doc_pos, const String &p_symbol_name = "", bool p_func_requred = false);
|
||||
static String marked_documentation(const String &p_bbcode);
|
||||
|
||||
GDScriptWorkspace();
|
||||
~GDScriptWorkspace();
|
||||
|
|
|
|||
|
|
@ -609,6 +609,70 @@ struct Diagnostic {
|
|||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Describes the content type that a client supports in various
|
||||
* result literals like `Hover`, `ParameterInfo` or `CompletionItem`.
|
||||
*
|
||||
* Please note that `MarkupKinds` must not start with a `$`. This kinds
|
||||
* are reserved for internal usage.
|
||||
*/
|
||||
namespace MarkupKind {
|
||||
static const String PlainText = "plaintext";
|
||||
static const String Markdown = "markdown";
|
||||
}; // namespace MarkupKind
|
||||
|
||||
/**
|
||||
* A `MarkupContent` literal represents a string value which content is interpreted base on its
|
||||
* kind flag. Currently the protocol supports `plaintext` and `markdown` as markup kinds.
|
||||
*
|
||||
* If the kind is `markdown` then the value can contain fenced code blocks like in GitHub issues.
|
||||
* See https://help.github.com/articles/creating-and-highlighting-code-blocks/#syntax-highlighting
|
||||
*
|
||||
* Here is an example how such a string can be constructed using JavaScript / TypeScript:
|
||||
* ```typescript
|
||||
* let markdown: MarkdownContent = {
|
||||
* kind: MarkupKind.Markdown,
|
||||
* value: [
|
||||
* '# Header',
|
||||
* 'Some text',
|
||||
* '```typescript',
|
||||
* 'someCode();',
|
||||
* '```'
|
||||
* ].join('\n')
|
||||
* };
|
||||
* ```
|
||||
*
|
||||
* *Please Note* that clients might sanitize the return markdown. A client could decide to
|
||||
* remove HTML from the markdown to avoid script execution.
|
||||
*/
|
||||
struct MarkupContent {
|
||||
/**
|
||||
* The type of the Markup
|
||||
*/
|
||||
String kind;
|
||||
|
||||
/**
|
||||
* The content itself
|
||||
*/
|
||||
String value;
|
||||
|
||||
MarkupContent() {
|
||||
kind = MarkupKind::Markdown;
|
||||
}
|
||||
|
||||
MarkupContent(const String &p_value) {
|
||||
value = p_value;
|
||||
kind = MarkupKind::Markdown;
|
||||
}
|
||||
|
||||
Dictionary to_json() const {
|
||||
Dictionary dict;
|
||||
dict["kind"] = kind;
|
||||
dict["value"] = value;
|
||||
return dict;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* A symbol kind.
|
||||
*/
|
||||
|
|
@ -693,6 +757,18 @@ struct SymbolInformation {
|
|||
}
|
||||
};
|
||||
|
||||
struct DocumentedSymbolInformation : public SymbolInformation {
|
||||
/**
|
||||
* A human-readable string with additional information
|
||||
*/
|
||||
String detail;
|
||||
|
||||
/**
|
||||
* A human-readable string that represents a doc-comment.
|
||||
*/
|
||||
String documentation;
|
||||
};
|
||||
|
||||
/**
|
||||
* Represents programming constructs like variables, classes, interfaces etc. that appear in a document. Document symbols can be
|
||||
* hierarchical and they have two ranges: one that encloses its definition and one that points to its most interesting range,
|
||||
|
|
@ -711,6 +787,11 @@ struct DocumentSymbol {
|
|||
*/
|
||||
String detail;
|
||||
|
||||
/**
|
||||
* Documentation for this symbol
|
||||
*/
|
||||
String documentation;
|
||||
|
||||
/**
|
||||
* The kind of this symbol.
|
||||
*/
|
||||
|
|
@ -734,6 +815,9 @@ struct DocumentSymbol {
|
|||
*/
|
||||
Range selectionRange;
|
||||
|
||||
DocumentUri uri;
|
||||
String script_path;
|
||||
|
||||
/**
|
||||
* Children of this symbol, e.g. properties of a class.
|
||||
*/
|
||||
|
|
@ -756,19 +840,39 @@ struct DocumentSymbol {
|
|||
return dict;
|
||||
}
|
||||
|
||||
void symbol_tree_as_list(const String &p_uri, Vector<SymbolInformation> &r_list, const String &p_container = "") const {
|
||||
SymbolInformation si;
|
||||
si.name = name;
|
||||
void symbol_tree_as_list(const String &p_uri, Vector<DocumentedSymbolInformation> &r_list, const String &p_container = "", bool p_join_name = false) const {
|
||||
DocumentedSymbolInformation si;
|
||||
if (p_join_name && !p_container.empty()) {
|
||||
si.name = p_container + ">" + name;
|
||||
} else {
|
||||
si.name = name;
|
||||
}
|
||||
si.kind = kind;
|
||||
si.containerName = p_container;
|
||||
si.deprecated = deprecated;
|
||||
si.location.uri = p_uri;
|
||||
si.location.range = range;
|
||||
si.detail = detail;
|
||||
si.documentation = documentation;
|
||||
r_list.push_back(si);
|
||||
for (int i = 0; i < children.size(); i++) {
|
||||
children[i].symbol_tree_as_list(p_uri, r_list, name);
|
||||
children[i].symbol_tree_as_list(p_uri, r_list, si.name, p_join_name);
|
||||
}
|
||||
}
|
||||
|
||||
MarkupContent render() const {
|
||||
MarkupContent markdown;
|
||||
if (detail.length()) {
|
||||
markdown.value = "\t" + detail + "\n\n";
|
||||
}
|
||||
if (documentation.length()) {
|
||||
markdown.value += documentation + "\n\n";
|
||||
}
|
||||
if (script_path.length()) {
|
||||
markdown.value += "Defined in [" + script_path + "](" + uri + ")";
|
||||
}
|
||||
return markdown;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -895,7 +999,7 @@ struct CompletionItem {
|
|||
/**
|
||||
* A human-readable string that represents a doc-comment.
|
||||
*/
|
||||
String documentation;
|
||||
MarkupContent documentation;
|
||||
|
||||
/**
|
||||
* Indicates if this item is deprecated.
|
||||
|
|
@ -988,9 +1092,8 @@ struct CompletionItem {
|
|||
Dictionary dict;
|
||||
dict["label"] = label;
|
||||
dict["kind"] = kind;
|
||||
dict["kind"] = kind;
|
||||
dict["detail"] = detail;
|
||||
dict["documentation"] = documentation;
|
||||
dict["documentation"] = documentation.to_json();
|
||||
dict["deprecated"] = deprecated;
|
||||
dict["preselect"] = preselect;
|
||||
dict["sortText"] = sortText;
|
||||
|
|
@ -1001,6 +1104,27 @@ struct CompletionItem {
|
|||
dict["data"] = data;
|
||||
return dict;
|
||||
}
|
||||
|
||||
void load(const Dictionary &p_dict) {
|
||||
if (p_dict.has("label")) label = p_dict["label"];
|
||||
if (p_dict.has("kind")) kind = p_dict["kind"];
|
||||
if (p_dict.has("detail")) detail = p_dict["detail"];
|
||||
if (p_dict.has("documentation")) {
|
||||
Variant doc = p_dict["documentation"];
|
||||
if (doc.get_type() == Variant::STRING) {
|
||||
documentation.value = doc;
|
||||
} else if (doc.get_type() == Variant::DICTIONARY) {
|
||||
Dictionary v = doc;
|
||||
documentation.value = v["value"];
|
||||
}
|
||||
}
|
||||
if (p_dict.has("deprecated")) deprecated = p_dict["deprecated"];
|
||||
if (p_dict.has("preselect")) preselect = p_dict["preselect"];
|
||||
if (p_dict.has("sortText")) sortText = p_dict["sortText"];
|
||||
if (p_dict.has("filterText")) filterText = p_dict["filterText"];
|
||||
if (p_dict.has("insertText")) insertText = p_dict["insertText"];
|
||||
if (p_dict.has("data")) data = p_dict["data"];
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -1137,6 +1261,29 @@ struct CompletionParams : public TextDocumentPositionParams {
|
|||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* The result of a hover request.
|
||||
*/
|
||||
struct Hover {
|
||||
/**
|
||||
* The hover's content
|
||||
*/
|
||||
MarkupContent contents;
|
||||
|
||||
/**
|
||||
* An optional range is a range inside a text document
|
||||
* that is used to visualize a hover, e.g. by changing the background color.
|
||||
*/
|
||||
Range range;
|
||||
|
||||
Dictionary to_json() const {
|
||||
Dictionary dict;
|
||||
dict["range"] = range.to_json();
|
||||
dict["contents"] = contents.to_json();
|
||||
return dict;
|
||||
}
|
||||
};
|
||||
|
||||
struct ServerCapabilities {
|
||||
/**
|
||||
* Defines how text documents are synced. Is either a detailed structure defining each notification or
|
||||
|
|
@ -1162,7 +1309,7 @@ struct ServerCapabilities {
|
|||
/**
|
||||
* The server provides goto definition support.
|
||||
*/
|
||||
bool definitionProvider = false;
|
||||
bool definitionProvider = true;
|
||||
|
||||
/**
|
||||
* The server provides Goto Type Definition support.
|
||||
|
|
|
|||
Loading…
Reference in a new issue