mirror of
https://github.com/godotengine/godot
synced 2024-09-05 14:49:49 +00:00
Merge pull request #29780 from GodotExplorer/gdscript-lsp
Add Language Server Protocol for GDScript
This commit is contained in:
commit
46ad60385b
|
@ -9,3 +9,4 @@ env_gdscript.add_source_files(env.modules_sources, "*.cpp")
|
|||
|
||||
if env['tools']:
|
||||
env_gdscript.add_source_files(env.modules_sources, "./editor/*.cpp")
|
||||
env_gdscript.add_source_files(env.modules_sources, "./language_server/*.cpp")
|
||||
|
|
|
@ -8257,6 +8257,10 @@ int GDScriptParser::get_error_column() const {
|
|||
return error_column;
|
||||
}
|
||||
|
||||
bool GDScriptParser::has_error() const {
|
||||
return error_set;
|
||||
}
|
||||
|
||||
Error GDScriptParser::_parse(const String &p_base_path) {
|
||||
|
||||
base_path = p_base_path;
|
||||
|
|
|
@ -632,6 +632,7 @@ private:
|
|||
Error _parse(const String &p_base_path);
|
||||
|
||||
public:
|
||||
bool has_error() const;
|
||||
String get_error() const;
|
||||
int get_error_line() const;
|
||||
int get_error_column() const;
|
||||
|
|
759
modules/gdscript/language_server/gdscript_extend_parser.cpp
Normal file
759
modules/gdscript/language_server/gdscript_extend_parser.cpp
Normal file
|
@ -0,0 +1,759 @@
|
|||
/*************************************************************************/
|
||||
/* gdscript_extend_parser.cpp */
|
||||
/*************************************************************************/
|
||||
/* This file is part of: */
|
||||
/* GODOT ENGINE */
|
||||
/* https://godotengine.org */
|
||||
/*************************************************************************/
|
||||
/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */
|
||||
/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md) */
|
||||
/* */
|
||||
/* Permission is hereby granted, free of charge, to any person obtaining */
|
||||
/* a copy of this software and associated documentation files (the */
|
||||
/* "Software"), to deal in the Software without restriction, including */
|
||||
/* without limitation the rights to use, copy, modify, merge, publish, */
|
||||
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
||||
/* permit persons to whom the Software is furnished to do so, subject to */
|
||||
/* the following conditions: */
|
||||
/* */
|
||||
/* The above copyright notice and this permission notice shall be */
|
||||
/* included in all copies or substantial portions of the Software. */
|
||||
/* */
|
||||
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
||||
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
||||
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
||||
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
||||
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
||||
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
||||
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
||||
/*************************************************************************/
|
||||
|
||||
#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() {
|
||||
|
||||
diagnostics.clear();
|
||||
|
||||
if (has_error()) {
|
||||
lsp::Diagnostic diagnostic;
|
||||
diagnostic.severity = lsp::DiagnosticSeverity::Error;
|
||||
diagnostic.message = get_error();
|
||||
diagnostic.source = "gdscript";
|
||||
diagnostic.code = -1;
|
||||
lsp::Range range;
|
||||
lsp::Position pos;
|
||||
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();
|
||||
range.start = pos;
|
||||
range.end = range.start;
|
||||
range.end.character = line_text.strip_edges(false).length();
|
||||
diagnostic.range = range;
|
||||
diagnostics.push_back(diagnostic);
|
||||
}
|
||||
|
||||
const List<GDScriptWarning> &warnings = get_warnings();
|
||||
for (const List<GDScriptWarning>::Element *E = warnings.front(); E; E = E->next()) {
|
||||
const GDScriptWarning &warning = E->get();
|
||||
lsp::Diagnostic diagnostic;
|
||||
diagnostic.severity = lsp::DiagnosticSeverity::Warning;
|
||||
diagnostic.message = warning.get_message();
|
||||
diagnostic.source = "gdscript";
|
||||
diagnostic.code = warning.code;
|
||||
lsp::Range range;
|
||||
lsp::Position pos;
|
||||
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();
|
||||
range.start = pos;
|
||||
range.end = pos;
|
||||
range.end.character = line_text.strip_edges(false).length();
|
||||
diagnostic.range = range;
|
||||
diagnostics.push_back(diagnostic);
|
||||
}
|
||||
}
|
||||
|
||||
void ExtendGDScriptParser::update_symbols() {
|
||||
|
||||
members.clear();
|
||||
|
||||
const GDScriptParser::Node *head = get_parse_tree();
|
||||
if (const GDScriptParser::ClassNode *gdclass = dynamic_cast<const GDScriptParser::ClassNode *>(head)) {
|
||||
|
||||
parse_class_symbol(gdclass, class_symbol);
|
||||
|
||||
for (int i = 0; i < class_symbol.children.size(); i++) {
|
||||
const lsp::DocumentSymbol &symbol = class_symbol.children[i];
|
||||
members.set(symbol.name, &symbol);
|
||||
|
||||
// cache level one inner classes
|
||||
if (symbol.kind == lsp::SymbolKind::Class) {
|
||||
ClassMembers inner_class;
|
||||
for (int j = 0; j < symbol.children.size(); j++) {
|
||||
const lsp::DocumentSymbol &s = symbol.children[j];
|
||||
inner_class.set(s.name, &s);
|
||||
}
|
||||
inner_classes.set(symbol.name, inner_class);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
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.deprecated = false;
|
||||
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 = 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;
|
||||
bool is_root_class = &r_symbol == &class_symbol;
|
||||
r_symbol.documentation = parse_documentation_as_markdown(is_root_class ? 0 : LINE_NUMBER_TO_INDEX(p_class->line), is_root_class);
|
||||
|
||||
for (int i = 0; i < p_class->variables.size(); ++i) {
|
||||
|
||||
const GDScriptParser::ClassNode::Member &m = p_class->variables[i];
|
||||
|
||||
lsp::DocumentSymbol symbol;
|
||||
symbol.name = m.identifier;
|
||||
symbol.kind = lsp::SymbolKind::Variable;
|
||||
symbol.deprecated = false;
|
||||
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;
|
||||
if (m._export.type != Variant::NIL) {
|
||||
symbol.detail += "export ";
|
||||
}
|
||||
symbol.detail += "var " + m.identifier;
|
||||
if (m.data_type.kind != GDScriptParser::DataType::UNRESOLVED) {
|
||||
symbol.detail += ": " + m.data_type.to_string();
|
||||
}
|
||||
if (m.default_value.get_type() != Variant::NIL) {
|
||||
symbol.detail += " = " + JSON::print(m.default_value);
|
||||
}
|
||||
|
||||
symbol.documentation = parse_documentation_as_markdown(line);
|
||||
symbol.uri = uri;
|
||||
symbol.script_path = path;
|
||||
|
||||
r_symbol.children.push_back(symbol);
|
||||
}
|
||||
|
||||
for (int i = 0; i < p_class->_signals.size(); ++i) {
|
||||
const GDScriptParser::ClassNode::Signal &signal = p_class->_signals[i];
|
||||
|
||||
lsp::DocumentSymbol symbol;
|
||||
symbol.name = signal.name;
|
||||
symbol.kind = lsp::SymbolKind::Event;
|
||||
symbol.deprecated = false;
|
||||
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_as_markdown(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 = 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_as_markdown(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();
|
||||
}
|
||||
|
||||
String value_text;
|
||||
if (node->value.get_type() == Variant::OBJECT) {
|
||||
RES res = node->value;
|
||||
if (res.is_valid() && !res->get_path().empty()) {
|
||||
value_text = "preload(\"" + res->get_path() + "\")";
|
||||
if (symbol.documentation.empty()) {
|
||||
if (Map<String, ExtendGDScriptParser *>::Element *S = GDScriptLanguageProtocol::get_singleton()->get_workspace()->scripts.find(res->get_path())) {
|
||||
symbol.documentation = S->get()->class_symbol.documentation;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
value_text = JSON::print(node->value);
|
||||
}
|
||||
} else {
|
||||
value_text = JSON::print(node->value);
|
||||
}
|
||||
if (!value_text.empty()) {
|
||||
symbol.detail += " = " + value_text;
|
||||
}
|
||||
|
||||
r_symbol.children.push_back(symbol);
|
||||
}
|
||||
|
||||
for (int i = 0; i < p_class->functions.size(); ++i) {
|
||||
const GDScriptParser::FunctionNode *func = p_class->functions[i];
|
||||
lsp::DocumentSymbol symbol;
|
||||
parse_function_symbol(func, symbol);
|
||||
r_symbol.children.push_back(symbol);
|
||||
}
|
||||
|
||||
for (int i = 0; i < p_class->static_functions.size(); ++i) {
|
||||
const GDScriptParser::FunctionNode *func = p_class->static_functions[i];
|
||||
lsp::DocumentSymbol symbol;
|
||||
parse_function_symbol(func, symbol);
|
||||
r_symbol.children.push_back(symbol);
|
||||
}
|
||||
|
||||
for (int i = 0; i < p_class->subclasses.size(); ++i) {
|
||||
const GDScriptParser::ClassNode *subclass = p_class->subclasses[i];
|
||||
lsp::DocumentSymbol symbol;
|
||||
parse_class_symbol(subclass, symbol);
|
||||
r_symbol.children.push_back(symbol);
|
||||
}
|
||||
}
|
||||
|
||||
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 = "func " + p_func->name + "(";
|
||||
r_symbol.deprecated = false;
|
||||
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 = parse_documentation_as_markdown(line);
|
||||
r_symbol.uri = uri;
|
||||
r_symbol.script_path = path;
|
||||
|
||||
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 = 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 = parse_documentation_as_markdown(line);
|
||||
r_symbol.children.push_back(symbol);
|
||||
}
|
||||
}
|
||||
|
||||
String ExtendGDScriptParser::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];
|
||||
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());
|
||||
}
|
||||
|
||||
if (in_code_block && line.find("[/codeblock]") != -1) {
|
||||
line = "'''\n";
|
||||
line = "\n";
|
||||
in_code_block = false;
|
||||
}
|
||||
|
||||
if (!in_code_block) {
|
||||
line = line.strip_edges();
|
||||
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]", "__");
|
||||
line = line.replace("[method ", "`");
|
||||
line = line.replace("[member ", "`");
|
||||
line = line.replace("[signal ", "`");
|
||||
line = line.replace("[enum ", "`");
|
||||
line = line.replace("[constant ", "`");
|
||||
line = line.replace("[", "`");
|
||||
line = line.replace("]", "`");
|
||||
}
|
||||
|
||||
if (!in_code_block && i < lines.size() - 1) {
|
||||
line += "\n\n";
|
||||
} else if (i < lines.size() - 1) {
|
||||
line += "\n";
|
||||
}
|
||||
markdown += line;
|
||||
}
|
||||
return markdown;
|
||||
}
|
||||
|
||||
String ExtendGDScriptParser::parse_documentation(int p_line, bool p_docs_down) {
|
||||
ERR_FAIL_INDEX_V(p_line, lines.size(), String());
|
||||
|
||||
List<String> doc_lines;
|
||||
|
||||
if (!p_docs_down) { // 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()).strip_edges();
|
||||
if (inline_comment.length() > 1) {
|
||||
doc_lines.push_back(inline_comment.substr(1, inline_comment.length()));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int step = p_docs_down ? 1 : -1;
|
||||
int start_line = p_docs_down ? p_line : p_line - 1;
|
||||
for (int i = start_line; true; i += step) {
|
||||
|
||||
if (i < 0 || i >= lines.size()) break;
|
||||
|
||||
String line_comment = lines[i].strip_edges(true, false);
|
||||
if (line_comment.begins_with("#")) {
|
||||
line_comment = line_comment.substr(1, line_comment.length());
|
||||
if (p_docs_down) {
|
||||
doc_lines.push_back(line_comment);
|
||||
} else {
|
||||
doc_lines.push_front(line_comment);
|
||||
}
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
String doc;
|
||||
for (List<String>::Element *E = doc_lines.front(); E; E = E->next()) {
|
||||
doc += E->get() + "\n";
|
||||
}
|
||||
return doc;
|
||||
}
|
||||
|
||||
String ExtendGDScriptParser::get_text_for_completion(const lsp::Position &p_cursor) const {
|
||||
|
||||
String longthing;
|
||||
int len = lines.size();
|
||||
for (int i = 0; i < len; i++) {
|
||||
|
||||
if (i == p_cursor.line) {
|
||||
longthing += lines[i].substr(0, p_cursor.character);
|
||||
longthing += String::chr(0xFFFF); //not unicode, represents the cursor
|
||||
longthing += lines[i].substr(p_cursor.character, lines[i].size());
|
||||
} else {
|
||||
|
||||
longthing += lines[i];
|
||||
}
|
||||
|
||||
if (i != len - 1)
|
||||
longthing += "\n";
|
||||
}
|
||||
|
||||
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 + 1, lines[i].length());
|
||||
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;
|
||||
}
|
||||
|
||||
String ExtendGDScriptParser::parse_documentation_as_markdown(int p_line, bool p_docs_down) {
|
||||
return marked_documentation(parse_documentation(p_line, p_docs_down));
|
||||
}
|
||||
|
||||
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 String &p_subclass) const {
|
||||
|
||||
if (p_subclass.empty()) {
|
||||
const lsp::DocumentSymbol *const *ptr = members.getptr(p_name);
|
||||
if (ptr) {
|
||||
return *ptr;
|
||||
}
|
||||
} else {
|
||||
if (const ClassMembers *_class = inner_classes.getptr(p_subclass)) {
|
||||
const lsp::DocumentSymbol *const *ptr = _class->getptr(p_name);
|
||||
if (ptr) {
|
||||
return *ptr;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const Array &ExtendGDScriptParser::get_member_completions() {
|
||||
|
||||
if (member_completions.empty()) {
|
||||
|
||||
const String *name = members.next(NULL);
|
||||
while (name) {
|
||||
|
||||
const lsp::DocumentSymbol *symbol = members.get(*name);
|
||||
lsp::CompletionItem item = symbol->make_completion_item();
|
||||
item.data = JOIN_SYMBOLS(path, *name);
|
||||
member_completions.push_back(item.to_json());
|
||||
|
||||
name = members.next(name);
|
||||
}
|
||||
|
||||
const String *_class = inner_classes.next(NULL);
|
||||
while (_class) {
|
||||
|
||||
const ClassMembers *inner_class = inner_classes.getptr(*_class);
|
||||
const String *member_name = inner_class->next(NULL);
|
||||
while (member_name) {
|
||||
const lsp::DocumentSymbol *symbol = inner_class->get(*member_name);
|
||||
lsp::CompletionItem item = symbol->make_completion_item();
|
||||
item.data = JOIN_SYMBOLS(path, JOIN_SYMBOLS(*_class, *member_name));
|
||||
member_completions.push_back(item.to_json());
|
||||
|
||||
member_name = inner_class->next(member_name);
|
||||
}
|
||||
|
||||
_class = inner_classes.next(_class);
|
||||
}
|
||||
}
|
||||
|
||||
return member_completions;
|
||||
}
|
||||
|
||||
Dictionary ExtendGDScriptParser::dump_function_api(const GDScriptParser::FunctionNode *p_func) const {
|
||||
Dictionary func;
|
||||
ERR_FAIL_NULL_V(p_func, func);
|
||||
func["name"] = p_func->name;
|
||||
func["return_type"] = p_func->return_type.to_string();
|
||||
func["rpc_mode"] = p_func->rpc_mode;
|
||||
Array arguments;
|
||||
for (int i = 0; i < p_func->arguments.size(); i++) {
|
||||
Dictionary arg;
|
||||
arg["name"] = p_func->arguments[i];
|
||||
arg["type"] = 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) {
|
||||
arg["default_value"] = const_node->value;
|
||||
}
|
||||
}
|
||||
arguments.push_back(arg);
|
||||
}
|
||||
if (const lsp::DocumentSymbol *symbol = get_symbol_defined_at_line(LINE_NUMBER_TO_INDEX(p_func->line))) {
|
||||
func["signature"] = symbol->detail;
|
||||
func["description"] = symbol->documentation;
|
||||
}
|
||||
func["arguments"] = arguments;
|
||||
return func;
|
||||
}
|
||||
|
||||
Dictionary ExtendGDScriptParser::dump_class_api(const GDScriptParser::ClassNode *p_class) const {
|
||||
Dictionary class_api;
|
||||
|
||||
ERR_FAIL_NULL_V(p_class, class_api);
|
||||
|
||||
class_api["name"] = String(p_class->name);
|
||||
class_api["path"] = path;
|
||||
Array extends_class;
|
||||
for (int i = 0; i < p_class->extends_class.size(); i++) {
|
||||
extends_class.append(String(p_class->extends_class[i]));
|
||||
}
|
||||
class_api["extends_class"] = extends_class;
|
||||
class_api["extends_file"] = String(p_class->extends_file);
|
||||
class_api["icon"] = String(p_class->icon_path);
|
||||
|
||||
if (const lsp::DocumentSymbol *symbol = get_symbol_defined_at_line(LINE_NUMBER_TO_INDEX(p_class->line))) {
|
||||
class_api["signature"] = symbol->detail;
|
||||
class_api["description"] = symbol->documentation;
|
||||
}
|
||||
|
||||
Array subclasses;
|
||||
for (int i = 0; i < p_class->subclasses.size(); i++) {
|
||||
subclasses.push_back(dump_class_api(p_class->subclasses[i]));
|
||||
}
|
||||
class_api["sub_classes"] = subclasses;
|
||||
|
||||
Array constants;
|
||||
for (Map<StringName, GDScriptParser::ClassNode::Constant>::Element *E = p_class->constant_expressions.front(); E; E = E->next()) {
|
||||
|
||||
const GDScriptParser::ClassNode::Constant &c = E->value();
|
||||
const GDScriptParser::ConstantNode *node = dynamic_cast<const GDScriptParser::ConstantNode *>(c.expression);
|
||||
|
||||
Dictionary api;
|
||||
api["name"] = E->key();
|
||||
api["value"] = node->value;
|
||||
api["data_type"] = node->datatype.to_string();
|
||||
if (const lsp::DocumentSymbol *symbol = get_symbol_defined_at_line(LINE_NUMBER_TO_INDEX(node->line))) {
|
||||
api["signature"] = symbol->detail;
|
||||
api["description"] = symbol->documentation;
|
||||
}
|
||||
constants.push_back(api);
|
||||
}
|
||||
class_api["constants"] = constants;
|
||||
|
||||
Array members;
|
||||
for (int i = 0; i < p_class->variables.size(); ++i) {
|
||||
const GDScriptParser::ClassNode::Member &m = p_class->variables[i];
|
||||
Dictionary api;
|
||||
api["name"] = m.identifier;
|
||||
api["data_type"] = m.data_type.to_string();
|
||||
api["default_value"] = m.default_value;
|
||||
api["setter"] = String(m.setter);
|
||||
api["getter"] = String(m.getter);
|
||||
api["export"] = m._export.type != Variant::NIL;
|
||||
if (const lsp::DocumentSymbol *symbol = get_symbol_defined_at_line(LINE_NUMBER_TO_INDEX(m.line))) {
|
||||
api["signature"] = symbol->detail;
|
||||
api["description"] = symbol->documentation;
|
||||
}
|
||||
members.push_back(api);
|
||||
}
|
||||
class_api["members"] = members;
|
||||
|
||||
Array signals;
|
||||
for (int i = 0; i < p_class->_signals.size(); ++i) {
|
||||
const GDScriptParser::ClassNode::Signal &signal = p_class->_signals[i];
|
||||
Dictionary api;
|
||||
api["name"] = signal.name;
|
||||
Array args;
|
||||
for (int j = 0; j < signal.arguments.size(); j++) {
|
||||
args.append(signal.arguments[j]);
|
||||
}
|
||||
api["arguments"] = args;
|
||||
if (const lsp::DocumentSymbol *symbol = get_symbol_defined_at_line(LINE_NUMBER_TO_INDEX(signal.line))) {
|
||||
api["signature"] = symbol->detail;
|
||||
api["description"] = symbol->documentation;
|
||||
}
|
||||
signals.push_back(api);
|
||||
}
|
||||
class_api["signals"] = signals;
|
||||
|
||||
Array methods;
|
||||
for (int i = 0; i < p_class->functions.size(); ++i) {
|
||||
methods.append(dump_function_api(p_class->functions[i]));
|
||||
}
|
||||
class_api["methods"] = methods;
|
||||
|
||||
Array static_functions;
|
||||
for (int i = 0; i < p_class->static_functions.size(); ++i) {
|
||||
static_functions.append(dump_function_api(p_class->functions[i]));
|
||||
}
|
||||
class_api["static_functions"] = static_functions;
|
||||
|
||||
return class_api;
|
||||
}
|
||||
|
||||
Dictionary ExtendGDScriptParser::generate_api() const {
|
||||
|
||||
Dictionary api;
|
||||
const GDScriptParser::Node *head = get_parse_tree();
|
||||
if (const GDScriptParser::ClassNode *gdclass = dynamic_cast<const GDScriptParser::ClassNode *>(head)) {
|
||||
api = dump_class_api(gdclass);
|
||||
}
|
||||
return api;
|
||||
}
|
||||
|
||||
Error ExtendGDScriptParser::parse(const String &p_code, const String &p_path) {
|
||||
path = p_path;
|
||||
lines = p_code.split("\n");
|
||||
|
||||
Error err = GDScriptParser::parse(p_code, p_path.get_base_dir(), false, p_path, false, NULL, false);
|
||||
update_diagnostics();
|
||||
update_symbols();
|
||||
return err;
|
||||
}
|
103
modules/gdscript/language_server/gdscript_extend_parser.h
Normal file
103
modules/gdscript/language_server/gdscript_extend_parser.h
Normal file
|
@ -0,0 +1,103 @@
|
|||
/*************************************************************************/
|
||||
/* gdscript_extend_parser.h */
|
||||
/*************************************************************************/
|
||||
/* This file is part of: */
|
||||
/* GODOT ENGINE */
|
||||
/* https://godotengine.org */
|
||||
/*************************************************************************/
|
||||
/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */
|
||||
/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md) */
|
||||
/* */
|
||||
/* Permission is hereby granted, free of charge, to any person obtaining */
|
||||
/* a copy of this software and associated documentation files (the */
|
||||
/* "Software"), to deal in the Software without restriction, including */
|
||||
/* without limitation the rights to use, copy, modify, merge, publish, */
|
||||
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
||||
/* permit persons to whom the Software is furnished to do so, subject to */
|
||||
/* the following conditions: */
|
||||
/* */
|
||||
/* The above copyright notice and this permission notice shall be */
|
||||
/* included in all copies or substantial portions of the Software. */
|
||||
/* */
|
||||
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
||||
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
||||
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
||||
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
||||
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
||||
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
||||
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
||||
/*************************************************************************/
|
||||
|
||||
#ifndef GDSCRIPT_EXTEND_PARSER_H
|
||||
#define GDSCRIPT_EXTEND_PARSER_H
|
||||
|
||||
#include "../gdscript_parser.h"
|
||||
#include "core/variant.h"
|
||||
#include "lsp.hpp"
|
||||
|
||||
#ifndef LINE_NUMBER_TO_INDEX
|
||||
#define LINE_NUMBER_TO_INDEX(p_line) ((p_line)-1)
|
||||
#endif
|
||||
|
||||
#ifndef SYMBOL_SEPERATOR
|
||||
#define SYMBOL_SEPERATOR "::"
|
||||
#endif
|
||||
|
||||
#ifndef JOIN_SYMBOLS
|
||||
#define JOIN_SYMBOLS(p_path, name) ((p_path) + SYMBOL_SEPERATOR + (name))
|
||||
#endif
|
||||
|
||||
typedef HashMap<String, const lsp::DocumentSymbol *> ClassMembers;
|
||||
|
||||
class ExtendGDScriptParser : public GDScriptParser {
|
||||
|
||||
String path;
|
||||
Vector<String> lines;
|
||||
|
||||
lsp::DocumentSymbol class_symbol;
|
||||
Vector<lsp::Diagnostic> diagnostics;
|
||||
ClassMembers members;
|
||||
HashMap<String, ClassMembers> inner_classes;
|
||||
|
||||
void update_diagnostics();
|
||||
|
||||
void update_symbols();
|
||||
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);
|
||||
|
||||
Dictionary dump_function_api(const GDScriptParser::FunctionNode *p_func) const;
|
||||
Dictionary dump_class_api(const GDScriptParser::ClassNode *p_class) const;
|
||||
|
||||
String parse_documentation(int p_line, bool p_docs_down = false);
|
||||
const lsp::DocumentSymbol *search_symbol_defined_at_line(int p_line, const lsp::DocumentSymbol &p_parent) const;
|
||||
|
||||
Array member_completions;
|
||||
|
||||
String parse_documentation_as_markdown(int p_line, bool p_docs_down = false);
|
||||
|
||||
public:
|
||||
static String marked_documentation(const String &p_bbcode);
|
||||
|
||||
public:
|
||||
_FORCE_INLINE_ const String &get_path() const { return path; }
|
||||
_FORCE_INLINE_ const Vector<String> &get_lines() const { return lines; }
|
||||
_FORCE_INLINE_ const lsp::DocumentSymbol &get_symbols() const { return class_symbol; }
|
||||
_FORCE_INLINE_ const Vector<lsp::Diagnostic> &get_diagnostics() const { return diagnostics; }
|
||||
_FORCE_INLINE_ const ClassMembers &get_members() const { return members; }
|
||||
_FORCE_INLINE_ const HashMap<String, ClassMembers> &get_inner_classes() const { return inner_classes; }
|
||||
|
||||
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 String &p_subclass = "") const;
|
||||
|
||||
const Array &get_member_completions();
|
||||
Dictionary generate_api() const;
|
||||
|
||||
Error parse(const String &p_code, const String &p_path);
|
||||
};
|
||||
|
||||
#endif
|
211
modules/gdscript/language_server/gdscript_language_protocol.cpp
Normal file
211
modules/gdscript/language_server/gdscript_language_protocol.cpp
Normal file
|
@ -0,0 +1,211 @@
|
|||
/*************************************************************************/
|
||||
/* gdscript_language_protocol.cpp */
|
||||
/*************************************************************************/
|
||||
/* This file is part of: */
|
||||
/* GODOT ENGINE */
|
||||
/* https://godotengine.org */
|
||||
/*************************************************************************/
|
||||
/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */
|
||||
/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md) */
|
||||
/* */
|
||||
/* Permission is hereby granted, free of charge, to any person obtaining */
|
||||
/* a copy of this software and associated documentation files (the */
|
||||
/* "Software"), to deal in the Software without restriction, including */
|
||||
/* without limitation the rights to use, copy, modify, merge, publish, */
|
||||
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
||||
/* permit persons to whom the Software is furnished to do so, subject to */
|
||||
/* the following conditions: */
|
||||
/* */
|
||||
/* The above copyright notice and this permission notice shall be */
|
||||
/* included in all copies or substantial portions of the Software. */
|
||||
/* */
|
||||
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
||||
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
||||
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
||||
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
||||
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
||||
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
||||
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
||||
/*************************************************************************/
|
||||
|
||||
#include "gdscript_language_protocol.h"
|
||||
#include "core/io/json.h"
|
||||
#include "core/os/copymem.h"
|
||||
#include "core/project_settings.h"
|
||||
#include "editor/editor_node.h"
|
||||
|
||||
GDScriptLanguageProtocol *GDScriptLanguageProtocol::singleton = NULL;
|
||||
|
||||
void GDScriptLanguageProtocol::on_data_received(int p_id) {
|
||||
lastest_client_id = p_id;
|
||||
Ref<WebSocketPeer> peer = server->get_peer(p_id);
|
||||
PoolByteArray data;
|
||||
if (OK == peer->get_packet_buffer(data)) {
|
||||
String message;
|
||||
message.parse_utf8((const char *)data.read().ptr(), data.size());
|
||||
if (message.begins_with("Content-Length:")) return;
|
||||
String output = process_message(message);
|
||||
if (!output.empty()) {
|
||||
CharString charstr = output.utf8();
|
||||
peer->put_packet((const uint8_t *)charstr.ptr(), charstr.length());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void GDScriptLanguageProtocol::on_client_connected(int p_id, const String &p_protocal) {
|
||||
clients.set(p_id, server->get_peer(p_id));
|
||||
}
|
||||
|
||||
void GDScriptLanguageProtocol::on_client_disconnected(int p_id, bool p_was_clean_close) {
|
||||
clients.erase(p_id);
|
||||
}
|
||||
|
||||
String GDScriptLanguageProtocol::process_message(const String &p_text) {
|
||||
String ret = process_string(p_text);
|
||||
if (ret.empty()) {
|
||||
return ret;
|
||||
} else {
|
||||
return format_output(ret);
|
||||
}
|
||||
}
|
||||
|
||||
String GDScriptLanguageProtocol::format_output(const String &p_text) {
|
||||
|
||||
String header = "Content-Length: ";
|
||||
CharString charstr = p_text.utf8();
|
||||
size_t len = charstr.length();
|
||||
header += itos(len);
|
||||
header += "\r\n\r\n";
|
||||
|
||||
return header + p_text;
|
||||
}
|
||||
|
||||
void GDScriptLanguageProtocol::_bind_methods() {
|
||||
ClassDB::bind_method(D_METHOD("initialize", "params"), &GDScriptLanguageProtocol::initialize);
|
||||
ClassDB::bind_method(D_METHOD("initialized", "params"), &GDScriptLanguageProtocol::initialized);
|
||||
ClassDB::bind_method(D_METHOD("on_data_received"), &GDScriptLanguageProtocol::on_data_received);
|
||||
ClassDB::bind_method(D_METHOD("on_client_connected"), &GDScriptLanguageProtocol::on_client_connected);
|
||||
ClassDB::bind_method(D_METHOD("on_client_disconnected"), &GDScriptLanguageProtocol::on_client_disconnected);
|
||||
ClassDB::bind_method(D_METHOD("notify_all_clients", "p_method", "p_params"), &GDScriptLanguageProtocol::notify_all_clients, DEFVAL(Variant()));
|
||||
ClassDB::bind_method(D_METHOD("notify_client", "p_method", "p_params", "p_client"), &GDScriptLanguageProtocol::notify_client, DEFVAL(Variant()), DEFVAL(-1));
|
||||
ClassDB::bind_method(D_METHOD("is_smart_resolve_enabled"), &GDScriptLanguageProtocol::is_smart_resolve_enabled);
|
||||
ClassDB::bind_method(D_METHOD("get_text_document"), &GDScriptLanguageProtocol::get_text_document);
|
||||
ClassDB::bind_method(D_METHOD("get_workspace"), &GDScriptLanguageProtocol::get_workspace);
|
||||
ClassDB::bind_method(D_METHOD("is_initialized"), &GDScriptLanguageProtocol::is_initialized);
|
||||
}
|
||||
|
||||
Dictionary GDScriptLanguageProtocol::initialize(const Dictionary &p_params) {
|
||||
|
||||
lsp::InitializeResult ret;
|
||||
|
||||
String root_uri = p_params["rootUri"];
|
||||
String root = p_params["rootPath"];
|
||||
bool is_same_workspace = root == workspace->root;
|
||||
is_same_workspace = root.to_lower() == workspace->root.to_lower();
|
||||
#ifdef WINDOWS_ENABLED
|
||||
is_same_workspace = root.replace("\\", "/").to_lower() == workspace->root.to_lower();
|
||||
#endif
|
||||
|
||||
if (root_uri.length() && is_same_workspace) {
|
||||
workspace->root_uri = root_uri;
|
||||
} else {
|
||||
|
||||
workspace->root_uri = "file://" + workspace->root;
|
||||
|
||||
Dictionary params;
|
||||
params["path"] = workspace->root;
|
||||
Dictionary request = make_notification("gdscrip_client/changeWorkspace", params);
|
||||
if (Ref<WebSocketPeer> *peer = clients.getptr(lastest_client_id)) {
|
||||
String msg = JSON::print(request);
|
||||
msg = format_output(msg);
|
||||
CharString charstr = msg.utf8();
|
||||
(*peer)->put_packet((const uint8_t *)charstr.ptr(), charstr.length());
|
||||
}
|
||||
}
|
||||
|
||||
if (!_initialized) {
|
||||
workspace->initialize();
|
||||
text_document->initialize();
|
||||
_initialized = true;
|
||||
}
|
||||
|
||||
return ret.to_json();
|
||||
}
|
||||
|
||||
void GDScriptLanguageProtocol::initialized(const Variant &p_params) {
|
||||
}
|
||||
|
||||
void GDScriptLanguageProtocol::poll() {
|
||||
server->poll();
|
||||
}
|
||||
|
||||
Error GDScriptLanguageProtocol::start(int p_port) {
|
||||
if (server == NULL) {
|
||||
server = dynamic_cast<WebSocketServer *>(ClassDB::instance("WebSocketServer"));
|
||||
server->set_buffers(8192, 1024, 8192, 1024); // 8mb should be way more than enough
|
||||
server->connect("data_received", this, "on_data_received");
|
||||
server->connect("client_connected", this, "on_client_connected");
|
||||
server->connect("client_disconnected", this, "on_client_disconnected");
|
||||
}
|
||||
return server->listen(p_port);
|
||||
}
|
||||
|
||||
void GDScriptLanguageProtocol::stop() {
|
||||
server->stop();
|
||||
}
|
||||
|
||||
void GDScriptLanguageProtocol::notify_all_clients(const String &p_method, const Variant &p_params) {
|
||||
|
||||
Dictionary message = make_notification(p_method, p_params);
|
||||
String msg = JSON::print(message);
|
||||
msg = format_output(msg);
|
||||
CharString charstr = msg.utf8();
|
||||
const int *p_id = clients.next(NULL);
|
||||
while (p_id != NULL) {
|
||||
Ref<WebSocketPeer> peer = clients.get(*p_id);
|
||||
(*peer)->put_packet((const uint8_t *)charstr.ptr(), charstr.length());
|
||||
p_id = clients.next(p_id);
|
||||
}
|
||||
}
|
||||
|
||||
void GDScriptLanguageProtocol::notify_client(const String &p_method, const Variant &p_params, int p_client) {
|
||||
|
||||
if (p_client == -1) {
|
||||
p_client = lastest_client_id;
|
||||
}
|
||||
|
||||
Ref<WebSocketPeer> *peer = clients.getptr(p_client);
|
||||
ERR_FAIL_COND(peer == NULL);
|
||||
|
||||
Dictionary message = make_notification(p_method, p_params);
|
||||
String msg = JSON::print(message);
|
||||
msg = format_output(msg);
|
||||
CharString charstr = msg.utf8();
|
||||
|
||||
(*peer)->put_packet((const uint8_t *)charstr.ptr(), charstr.length());
|
||||
}
|
||||
|
||||
bool GDScriptLanguageProtocol::is_smart_resolve_enabled() const {
|
||||
return bool(_EDITOR_GET("network/language_server/enable_smart_resolve"));
|
||||
}
|
||||
|
||||
bool GDScriptLanguageProtocol::is_goto_native_symbols_enabled() const {
|
||||
return bool(_EDITOR_GET("network/language_server/show_native_symbols_in_editor"));
|
||||
}
|
||||
|
||||
GDScriptLanguageProtocol::GDScriptLanguageProtocol() {
|
||||
server = NULL;
|
||||
singleton = this;
|
||||
_initialized = false;
|
||||
workspace.instance();
|
||||
text_document.instance();
|
||||
set_scope("textDocument", text_document.ptr());
|
||||
set_scope("completionItem", text_document.ptr());
|
||||
set_scope("workspace", workspace.ptr());
|
||||
workspace->root = ProjectSettings::get_singleton()->get_resource_path();
|
||||
}
|
||||
|
||||
GDScriptLanguageProtocol::~GDScriptLanguageProtocol() {
|
||||
memdelete(server);
|
||||
server = NULL;
|
||||
}
|
|
@ -0,0 +1,93 @@
|
|||
/*************************************************************************/
|
||||
/* gdscript_language_protocol.h */
|
||||
/*************************************************************************/
|
||||
/* This file is part of: */
|
||||
/* GODOT ENGINE */
|
||||
/* https://godotengine.org */
|
||||
/*************************************************************************/
|
||||
/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */
|
||||
/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md) */
|
||||
/* */
|
||||
/* Permission is hereby granted, free of charge, to any person obtaining */
|
||||
/* a copy of this software and associated documentation files (the */
|
||||
/* "Software"), to deal in the Software without restriction, including */
|
||||
/* without limitation the rights to use, copy, modify, merge, publish, */
|
||||
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
||||
/* permit persons to whom the Software is furnished to do so, subject to */
|
||||
/* the following conditions: */
|
||||
/* */
|
||||
/* The above copyright notice and this permission notice shall be */
|
||||
/* included in all copies or substantial portions of the Software. */
|
||||
/* */
|
||||
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
||||
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
||||
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
||||
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
||||
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
||||
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
||||
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
||||
/*************************************************************************/
|
||||
|
||||
#ifndef GDSCRIPT_PROTOCAL_SERVER_H
|
||||
#define GDSCRIPT_PROTOCAL_SERVER_H
|
||||
|
||||
#include "gdscript_text_document.h"
|
||||
#include "gdscript_workspace.h"
|
||||
#include "lsp.hpp"
|
||||
#include "modules/jsonrpc/jsonrpc.h"
|
||||
#include "modules/websocket/websocket_peer.h"
|
||||
#include "modules/websocket/websocket_server.h"
|
||||
|
||||
class GDScriptLanguageProtocol : public JSONRPC {
|
||||
GDCLASS(GDScriptLanguageProtocol, JSONRPC)
|
||||
|
||||
enum LSPErrorCode {
|
||||
RequestCancelled = -32800,
|
||||
ContentModified = -32801,
|
||||
};
|
||||
|
||||
static GDScriptLanguageProtocol *singleton;
|
||||
|
||||
HashMap<int, Ref<WebSocketPeer> > clients;
|
||||
WebSocketServer *server;
|
||||
int lastest_client_id;
|
||||
|
||||
Ref<GDScriptTextDocument> text_document;
|
||||
Ref<GDScriptWorkspace> workspace;
|
||||
|
||||
void on_data_received(int p_id);
|
||||
void on_client_connected(int p_id, const String &p_protocal);
|
||||
void on_client_disconnected(int p_id, bool p_was_clean_close);
|
||||
|
||||
String process_message(const String &p_text);
|
||||
String format_output(const String &p_text);
|
||||
|
||||
bool _initialized;
|
||||
|
||||
protected:
|
||||
static void _bind_methods();
|
||||
|
||||
Dictionary initialize(const Dictionary &p_params);
|
||||
void initialized(const Variant &p_params);
|
||||
|
||||
public:
|
||||
_FORCE_INLINE_ static GDScriptLanguageProtocol *get_singleton() { return singleton; }
|
||||
_FORCE_INLINE_ Ref<GDScriptWorkspace> get_workspace() { return workspace; }
|
||||
_FORCE_INLINE_ Ref<GDScriptTextDocument> get_text_document() { return text_document; }
|
||||
_FORCE_INLINE_ bool is_initialized() const { return _initialized; }
|
||||
|
||||
void poll();
|
||||
Error start(int p_port);
|
||||
void stop();
|
||||
|
||||
void notify_all_clients(const String &p_method, const Variant &p_params = Variant());
|
||||
void notify_client(const String &p_method, const Variant &p_params = Variant(), int p_client = -1);
|
||||
|
||||
bool is_smart_resolve_enabled() const;
|
||||
bool is_goto_native_symbols_enabled() const;
|
||||
|
||||
GDScriptLanguageProtocol();
|
||||
~GDScriptLanguageProtocol();
|
||||
};
|
||||
|
||||
#endif
|
|
@ -0,0 +1,88 @@
|
|||
/*************************************************************************/
|
||||
/* gdscript_language_server.cpp */
|
||||
/*************************************************************************/
|
||||
/* This file is part of: */
|
||||
/* GODOT ENGINE */
|
||||
/* https://godotengine.org */
|
||||
/*************************************************************************/
|
||||
/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */
|
||||
/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md) */
|
||||
/* */
|
||||
/* Permission is hereby granted, free of charge, to any person obtaining */
|
||||
/* a copy of this software and associated documentation files (the */
|
||||
/* "Software"), to deal in the Software without restriction, including */
|
||||
/* without limitation the rights to use, copy, modify, merge, publish, */
|
||||
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
||||
/* permit persons to whom the Software is furnished to do so, subject to */
|
||||
/* the following conditions: */
|
||||
/* */
|
||||
/* The above copyright notice and this permission notice shall be */
|
||||
/* included in all copies or substantial portions of the Software. */
|
||||
/* */
|
||||
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
||||
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
||||
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
||||
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
||||
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
||||
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
||||
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
||||
/*************************************************************************/
|
||||
|
||||
#include "gdscript_language_server.h"
|
||||
#include "core/os/file_access.h"
|
||||
#include "core/os/os.h"
|
||||
#include "editor/editor_node.h"
|
||||
|
||||
GDScriptLanguageServer::GDScriptLanguageServer() {
|
||||
thread = NULL;
|
||||
thread_exit = false;
|
||||
_EDITOR_DEF("network/language_server/remote_port", 6008);
|
||||
_EDITOR_DEF("network/language_server/enable_smart_resolve", false);
|
||||
_EDITOR_DEF("network/language_server/show_native_symbols_in_editor", false);
|
||||
}
|
||||
|
||||
void GDScriptLanguageServer::_notification(int p_what) {
|
||||
|
||||
switch (p_what) {
|
||||
case NOTIFICATION_ENTER_TREE:
|
||||
start();
|
||||
break;
|
||||
case NOTIFICATION_EXIT_TREE:
|
||||
stop();
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void GDScriptLanguageServer::thread_main(void *p_userdata) {
|
||||
GDScriptLanguageServer *self = static_cast<GDScriptLanguageServer *>(p_userdata);
|
||||
while (!self->thread_exit) {
|
||||
self->protocol.poll();
|
||||
OS::get_singleton()->delay_usec(10);
|
||||
}
|
||||
}
|
||||
|
||||
void GDScriptLanguageServer::start() {
|
||||
int port = (int)_EDITOR_GET("network/language_server/remote_port");
|
||||
if (protocol.start(port) == OK) {
|
||||
EditorNode::get_log()->add_message("** GDScript Language Server Started **");
|
||||
ERR_FAIL_COND(thread != NULL || thread_exit);
|
||||
thread_exit = false;
|
||||
thread = Thread::create(GDScriptLanguageServer::thread_main, this);
|
||||
}
|
||||
}
|
||||
|
||||
void GDScriptLanguageServer::stop() {
|
||||
ERR_FAIL_COND(NULL == thread || thread_exit);
|
||||
thread_exit = true;
|
||||
Thread::wait_to_finish(thread);
|
||||
memdelete(thread);
|
||||
thread = NULL;
|
||||
protocol.stop();
|
||||
EditorNode::get_log()->add_message("** GDScript Language Server Stopped **");
|
||||
}
|
||||
|
||||
void register_lsp_types() {
|
||||
ClassDB::register_class<GDScriptLanguageProtocol>();
|
||||
ClassDB::register_class<GDScriptTextDocument>();
|
||||
ClassDB::register_class<GDScriptWorkspace>();
|
||||
}
|
60
modules/gdscript/language_server/gdscript_language_server.h
Normal file
60
modules/gdscript/language_server/gdscript_language_server.h
Normal file
|
@ -0,0 +1,60 @@
|
|||
/*************************************************************************/
|
||||
/* gdscript_language_server.h */
|
||||
/*************************************************************************/
|
||||
/* This file is part of: */
|
||||
/* GODOT ENGINE */
|
||||
/* https://godotengine.org */
|
||||
/*************************************************************************/
|
||||
/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */
|
||||
/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md) */
|
||||
/* */
|
||||
/* Permission is hereby granted, free of charge, to any person obtaining */
|
||||
/* a copy of this software and associated documentation files (the */
|
||||
/* "Software"), to deal in the Software without restriction, including */
|
||||
/* without limitation the rights to use, copy, modify, merge, publish, */
|
||||
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
||||
/* permit persons to whom the Software is furnished to do so, subject to */
|
||||
/* the following conditions: */
|
||||
/* */
|
||||
/* The above copyright notice and this permission notice shall be */
|
||||
/* included in all copies or substantial portions of the Software. */
|
||||
/* */
|
||||
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
||||
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
||||
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
||||
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
||||
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
||||
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
||||
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
||||
/*************************************************************************/
|
||||
|
||||
#ifndef GDSCRIPT_LANGUAGE_SERVER_H
|
||||
#define GDSCRIPT_LANGUAGE_SERVER_H
|
||||
|
||||
#include "../gdscript_parser.h"
|
||||
#include "editor/editor_plugin.h"
|
||||
#include "gdscript_language_protocol.h"
|
||||
|
||||
class GDScriptLanguageServer : public EditorPlugin {
|
||||
GDCLASS(GDScriptLanguageServer, EditorPlugin);
|
||||
|
||||
GDScriptLanguageProtocol protocol;
|
||||
|
||||
Thread *thread;
|
||||
bool thread_exit;
|
||||
static void thread_main(void *p_userdata);
|
||||
|
||||
private:
|
||||
void _notification(int p_what);
|
||||
void _iteration();
|
||||
|
||||
public:
|
||||
Error parse_script_file(const String &p_path);
|
||||
GDScriptLanguageServer();
|
||||
void start();
|
||||
void stop();
|
||||
};
|
||||
|
||||
void register_lsp_types();
|
||||
|
||||
#endif // GDSCRIPT_LANGUAGE_SERVER_H
|
391
modules/gdscript/language_server/gdscript_text_document.cpp
Normal file
391
modules/gdscript/language_server/gdscript_text_document.cpp
Normal file
|
@ -0,0 +1,391 @@
|
|||
/*************************************************************************/
|
||||
/* gdscript_text_document.cpp */
|
||||
/*************************************************************************/
|
||||
/* This file is part of: */
|
||||
/* GODOT ENGINE */
|
||||
/* https://godotengine.org */
|
||||
/*************************************************************************/
|
||||
/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */
|
||||
/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md) */
|
||||
/* */
|
||||
/* Permission is hereby granted, free of charge, to any person obtaining */
|
||||
/* a copy of this software and associated documentation files (the */
|
||||
/* "Software"), to deal in the Software without restriction, including */
|
||||
/* without limitation the rights to use, copy, modify, merge, publish, */
|
||||
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
||||
/* permit persons to whom the Software is furnished to do so, subject to */
|
||||
/* the following conditions: */
|
||||
/* */
|
||||
/* The above copyright notice and this permission notice shall be */
|
||||
/* included in all copies or substantial portions of the Software. */
|
||||
/* */
|
||||
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
||||
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
||||
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
||||
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
||||
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
||||
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
||||
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
||||
/*************************************************************************/
|
||||
|
||||
#include "gdscript_text_document.h"
|
||||
#include "../gdscript.h"
|
||||
#include "core/os/os.h"
|
||||
#include "editor/editor_settings.h"
|
||||
#include "editor/plugins/script_text_editor.h"
|
||||
#include "gdscript_extend_parser.h"
|
||||
#include "gdscript_language_protocol.h"
|
||||
|
||||
void GDScriptTextDocument::_bind_methods() {
|
||||
ClassDB::bind_method(D_METHOD("didOpen"), &GDScriptTextDocument::didOpen);
|
||||
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);
|
||||
ClassDB::bind_method(D_METHOD("show_native_symbol_in_editor"), &GDScriptTextDocument::show_native_symbol_in_editor);
|
||||
}
|
||||
|
||||
void GDScriptTextDocument::didOpen(const Variant &p_param) {
|
||||
lsp::TextDocumentItem doc = load_document_item(p_param);
|
||||
sync_script_content(doc.uri, doc.text);
|
||||
}
|
||||
|
||||
void GDScriptTextDocument::didChange(const Variant &p_param) {
|
||||
lsp::TextDocumentItem doc = load_document_item(p_param);
|
||||
Dictionary dict = p_param;
|
||||
Array contentChanges = dict["contentChanges"];
|
||||
for (int i = 0; i < contentChanges.size(); ++i) {
|
||||
lsp::TextDocumentContentChangeEvent evt;
|
||||
evt.load(contentChanges[i]);
|
||||
doc.text = evt.text;
|
||||
}
|
||||
sync_script_content(doc.uri, doc.text);
|
||||
}
|
||||
|
||||
lsp::TextDocumentItem GDScriptTextDocument::load_document_item(const Variant &p_param) {
|
||||
lsp::TextDocumentItem doc;
|
||||
Dictionary params = p_param;
|
||||
doc.load(params["textDocument"]);
|
||||
return doc;
|
||||
}
|
||||
|
||||
void GDScriptTextDocument::initialize() {
|
||||
|
||||
if (GDScriptLanguageProtocol::get_singleton()->is_smart_resolve_enabled()) {
|
||||
|
||||
const HashMap<StringName, ClassMembers> &native_members = GDScriptLanguageProtocol::get_singleton()->get_workspace()->native_members;
|
||||
|
||||
const StringName *class_ptr = native_members.next(NULL);
|
||||
while (class_ptr) {
|
||||
|
||||
const ClassMembers &members = native_members.get(*class_ptr);
|
||||
|
||||
const String *name = members.next(NULL);
|
||||
while (name) {
|
||||
|
||||
const lsp::DocumentSymbol *symbol = members.get(*name);
|
||||
lsp::CompletionItem item = symbol->make_completion_item();
|
||||
item.data = JOIN_SYMBOLS(String(*class_ptr), *name);
|
||||
native_member_completions.push_back(item.to_json());
|
||||
|
||||
name = members.next(name);
|
||||
}
|
||||
|
||||
class_ptr = native_members.next(class_ptr);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Array GDScriptTextDocument::documentSymbol(const Dictionary &p_params) {
|
||||
Dictionary params = p_params["textDocument"];
|
||||
String uri = params["uri"];
|
||||
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::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());
|
||||
}
|
||||
}
|
||||
return arr;
|
||||
}
|
||||
|
||||
Array GDScriptTextDocument::completion(const Dictionary &p_params) {
|
||||
|
||||
Array arr;
|
||||
|
||||
lsp::CompletionParams params;
|
||||
params.load(p_params);
|
||||
Dictionary request_data = params.to_json();
|
||||
|
||||
List<ScriptCodeCompletionOption> options;
|
||||
GDScriptLanguageProtocol::get_singleton()->get_workspace()->completion(params, &options);
|
||||
|
||||
if (!options.empty()) {
|
||||
|
||||
int i = 0;
|
||||
arr.resize(options.size());
|
||||
|
||||
for (const List<ScriptCodeCompletionOption>::Element *E = options.front(); E; E = E->next()) {
|
||||
|
||||
const ScriptCodeCompletionOption &option = E->get();
|
||||
lsp::CompletionItem item;
|
||||
item.label = option.display;
|
||||
item.data = request_data;
|
||||
|
||||
switch (option.kind) {
|
||||
case ScriptCodeCompletionOption::KIND_ENUM:
|
||||
item.kind = lsp::CompletionItemKind::Enum;
|
||||
break;
|
||||
case ScriptCodeCompletionOption::KIND_CLASS:
|
||||
item.kind = lsp::CompletionItemKind::Class;
|
||||
break;
|
||||
case ScriptCodeCompletionOption::KIND_MEMBER:
|
||||
item.kind = lsp::CompletionItemKind::Property;
|
||||
break;
|
||||
case ScriptCodeCompletionOption::KIND_FUNCTION:
|
||||
item.kind = lsp::CompletionItemKind::Method;
|
||||
break;
|
||||
case ScriptCodeCompletionOption::KIND_SIGNAL:
|
||||
item.kind = lsp::CompletionItemKind::Event;
|
||||
break;
|
||||
case ScriptCodeCompletionOption::KIND_CONSTANT:
|
||||
item.kind = lsp::CompletionItemKind::Constant;
|
||||
break;
|
||||
case ScriptCodeCompletionOption::KIND_VARIABLE:
|
||||
item.kind = lsp::CompletionItemKind::Variable;
|
||||
break;
|
||||
case ScriptCodeCompletionOption::KIND_FILE_PATH:
|
||||
item.kind = lsp::CompletionItemKind::File;
|
||||
break;
|
||||
case ScriptCodeCompletionOption::KIND_NODE_PATH:
|
||||
item.kind = lsp::CompletionItemKind::Snippet;
|
||||
break;
|
||||
case ScriptCodeCompletionOption::KIND_PLAIN_TEXT:
|
||||
item.kind = lsp::CompletionItemKind::Text;
|
||||
break;
|
||||
}
|
||||
|
||||
arr[i] = item.to_json();
|
||||
i++;
|
||||
}
|
||||
} else if (GDScriptLanguageProtocol::get_singleton()->is_smart_resolve_enabled()) {
|
||||
|
||||
arr = native_member_completions.duplicate();
|
||||
|
||||
for (Map<String, ExtendGDScriptParser *>::Element *E = GDScriptLanguageProtocol::get_singleton()->get_workspace()->scripts.front(); E; E = E->next()) {
|
||||
|
||||
ExtendGDScriptParser *script = E->get();
|
||||
const Array &items = script->get_member_completions();
|
||||
|
||||
const int start_size = arr.size();
|
||||
arr.resize(start_size + items.size());
|
||||
for (int i = start_size; i < arr.size(); i++) {
|
||||
arr[i] = items[i - start_size];
|
||||
}
|
||||
}
|
||||
}
|
||||
return arr;
|
||||
}
|
||||
|
||||
Dictionary GDScriptTextDocument::resolve(const Dictionary &p_params) {
|
||||
|
||||
lsp::CompletionItem item;
|
||||
item.load(p_params);
|
||||
|
||||
lsp::CompletionParams params;
|
||||
Variant data = p_params["data"];
|
||||
|
||||
const lsp::DocumentSymbol *symbol = NULL;
|
||||
|
||||
if (data.get_type() == Variant::DICTIONARY) {
|
||||
|
||||
params.load(p_params["data"]);
|
||||
symbol = GDScriptLanguageProtocol::get_singleton()->get_workspace()->resolve_symbol(params, item.label, item.kind == lsp::CompletionItemKind::Method || item.kind == lsp::CompletionItemKind::Function);
|
||||
|
||||
} else if (data.get_type() == Variant::STRING) {
|
||||
|
||||
String query = data;
|
||||
|
||||
Vector<String> param_symbols = query.split(SYMBOL_SEPERATOR, false);
|
||||
|
||||
if (param_symbols.size() >= 2) {
|
||||
|
||||
String class_ = param_symbols[0];
|
||||
StringName class_name = class_;
|
||||
String member_name = param_symbols[param_symbols.size() - 1];
|
||||
String inner_class_name;
|
||||
if (param_symbols.size() >= 3) {
|
||||
inner_class_name = param_symbols[1];
|
||||
}
|
||||
|
||||
if (const ClassMembers *members = GDScriptLanguageProtocol::get_singleton()->get_workspace()->native_members.getptr(class_name)) {
|
||||
if (const lsp::DocumentSymbol *const *member = members->getptr(member_name)) {
|
||||
symbol = *member;
|
||||
}
|
||||
}
|
||||
|
||||
if (!symbol) {
|
||||
if (const Map<String, ExtendGDScriptParser *>::Element *E = GDScriptLanguageProtocol::get_singleton()->get_workspace()->scripts.find(class_name)) {
|
||||
symbol = E->get()->get_member_symbol(member_name, inner_class_name);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (symbol) {
|
||||
item.documentation = symbol->render();
|
||||
}
|
||||
|
||||
if ((item.kind == lsp::CompletionItemKind::Method || item.kind == lsp::CompletionItemKind::Function) && !item.label.ends_with("):")) {
|
||||
item.insertText = item.label + "(";
|
||||
if (symbol && symbol->detail.find(",") == -1) {
|
||||
item.insertText += ")";
|
||||
}
|
||||
} else if (item.kind == lsp::CompletionItemKind::Event) {
|
||||
if (params.context.triggerKind == lsp::CompletionTriggerKind::TriggerCharacter && (params.context.triggerCharacter == "(")) {
|
||||
const String quote_style = EDITOR_DEF("text_editor/completion/use_single_quotes", false) ? "'" : "\"";
|
||||
item.insertText = quote_style + item.label + quote_style;
|
||||
}
|
||||
}
|
||||
|
||||
return item.to_json(true);
|
||||
}
|
||||
|
||||
Array GDScriptTextDocument::foldingRange(const Dictionary &p_params) {
|
||||
Dictionary params = p_params["textDocument"];
|
||||
String path = params["uri"];
|
||||
Array arr;
|
||||
return arr;
|
||||
}
|
||||
|
||||
Array GDScriptTextDocument::codeLens(const Dictionary &p_params) {
|
||||
Array arr;
|
||||
return arr;
|
||||
}
|
||||
|
||||
Variant GDScriptTextDocument::documentLink(const Dictionary &p_params) {
|
||||
Variant ret;
|
||||
return ret;
|
||||
}
|
||||
|
||||
Array GDScriptTextDocument::colorPresentation(const Dictionary &p_params) {
|
||||
Array arr;
|
||||
return arr;
|
||||
}
|
||||
|
||||
Variant GDScriptTextDocument::hover(const Dictionary &p_params) {
|
||||
|
||||
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();
|
||||
return hover.to_json();
|
||||
|
||||
} else if (GDScriptLanguageProtocol::get_singleton()->is_smart_resolve_enabled()) {
|
||||
|
||||
Dictionary ret;
|
||||
Array contents;
|
||||
List<const lsp::DocumentSymbol *> list;
|
||||
GDScriptLanguageProtocol::get_singleton()->get_workspace()->resolve_related_symbols(params, list);
|
||||
for (List<const lsp::DocumentSymbol *>::Element *E = list.front(); E; E = E->next()) {
|
||||
if (const lsp::DocumentSymbol *s = E->get()) {
|
||||
contents.push_back(s->render().value);
|
||||
}
|
||||
}
|
||||
ret["contents"] = contents;
|
||||
return ret;
|
||||
}
|
||||
|
||||
return Variant();
|
||||
}
|
||||
|
||||
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());
|
||||
} else if (!symbol->native_class.empty() && GDScriptLanguageProtocol::get_singleton()->is_goto_native_symbols_enabled()) {
|
||||
String id;
|
||||
switch (symbol->kind) {
|
||||
case lsp::SymbolKind::Class:
|
||||
id = "class_name:" + symbol->name;
|
||||
break;
|
||||
case lsp::SymbolKind::Constant:
|
||||
id = "class_constant:" + symbol->native_class + ":" + symbol->name;
|
||||
break;
|
||||
case lsp::SymbolKind::Property:
|
||||
case lsp::SymbolKind::Variable:
|
||||
id = "class_property:" + symbol->native_class + ":" + symbol->name;
|
||||
break;
|
||||
case lsp::SymbolKind::Enum:
|
||||
id = "class_enum:" + symbol->native_class + ":" + symbol->name;
|
||||
break;
|
||||
case lsp::SymbolKind::Method:
|
||||
case lsp::SymbolKind::Function:
|
||||
id = "class_method:" + symbol->native_class + ":" + symbol->name;
|
||||
break;
|
||||
default:
|
||||
id = "class_global:" + symbol->native_class + ":" + symbol->name;
|
||||
break;
|
||||
}
|
||||
call_deferred("show_native_symbol_in_editor", id);
|
||||
}
|
||||
} else if (GDScriptLanguageProtocol::get_singleton()->is_smart_resolve_enabled()) {
|
||||
|
||||
List<const lsp::DocumentSymbol *> list;
|
||||
GDScriptLanguageProtocol::get_singleton()->get_workspace()->resolve_related_symbols(params, list);
|
||||
for (List<const lsp::DocumentSymbol *>::Element *E = list.front(); E; E = E->next()) {
|
||||
|
||||
if (const lsp::DocumentSymbol *s = E->get()) {
|
||||
if (!s->uri.empty()) {
|
||||
lsp::Location location;
|
||||
location.uri = s->uri;
|
||||
location.range = s->range;
|
||||
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);
|
||||
}
|
||||
|
||||
void GDScriptTextDocument::show_native_symbol_in_editor(const String &p_symbol_id) {
|
||||
ScriptEditor::get_singleton()->call_deferred("_help_class_goto", p_symbol_id);
|
||||
OS::get_singleton()->move_window_to_foreground();
|
||||
}
|
73
modules/gdscript/language_server/gdscript_text_document.h
Normal file
73
modules/gdscript/language_server/gdscript_text_document.h
Normal file
|
@ -0,0 +1,73 @@
|
|||
/*************************************************************************/
|
||||
/* gdscript_text_document.h */
|
||||
/*************************************************************************/
|
||||
/* This file is part of: */
|
||||
/* GODOT ENGINE */
|
||||
/* https://godotengine.org */
|
||||
/*************************************************************************/
|
||||
/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */
|
||||
/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md) */
|
||||
/* */
|
||||
/* Permission is hereby granted, free of charge, to any person obtaining */
|
||||
/* a copy of this software and associated documentation files (the */
|
||||
/* "Software"), to deal in the Software without restriction, including */
|
||||
/* without limitation the rights to use, copy, modify, merge, publish, */
|
||||
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
||||
/* permit persons to whom the Software is furnished to do so, subject to */
|
||||
/* the following conditions: */
|
||||
/* */
|
||||
/* The above copyright notice and this permission notice shall be */
|
||||
/* included in all copies or substantial portions of the Software. */
|
||||
/* */
|
||||
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
||||
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
||||
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
||||
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
||||
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
||||
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
||||
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
||||
/*************************************************************************/
|
||||
|
||||
#ifndef GDSCRIPT_TEXT_DOCUMENT_H
|
||||
#define GDSCRIPT_TEXT_DOCUMENT_H
|
||||
|
||||
#include "core/os/file_access.h"
|
||||
#include "core/reference.h"
|
||||
#include "lsp.hpp"
|
||||
|
||||
class GDScriptTextDocument : public Reference {
|
||||
GDCLASS(GDScriptTextDocument, Reference)
|
||||
protected:
|
||||
static void _bind_methods();
|
||||
|
||||
FileAccess *file_checker;
|
||||
|
||||
void didOpen(const Variant &p_param);
|
||||
void didChange(const Variant &p_param);
|
||||
|
||||
void sync_script_content(const String &p_path, const String &p_content);
|
||||
void show_native_symbol_in_editor(const String &p_symbol_id);
|
||||
|
||||
Array native_member_completions;
|
||||
|
||||
private:
|
||||
lsp::TextDocumentItem load_document_item(const Variant &p_param);
|
||||
|
||||
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);
|
||||
|
||||
void initialize();
|
||||
|
||||
GDScriptTextDocument();
|
||||
virtual ~GDScriptTextDocument();
|
||||
};
|
||||
|
||||
#endif
|
504
modules/gdscript/language_server/gdscript_workspace.cpp
Normal file
504
modules/gdscript/language_server/gdscript_workspace.cpp
Normal file
|
@ -0,0 +1,504 @@
|
|||
/*************************************************************************/
|
||||
/* gdscript_workspace.cpp */
|
||||
/*************************************************************************/
|
||||
/* This file is part of: */
|
||||
/* GODOT ENGINE */
|
||||
/* https://godotengine.org */
|
||||
/*************************************************************************/
|
||||
/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */
|
||||
/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md) */
|
||||
/* */
|
||||
/* Permission is hereby granted, free of charge, to any person obtaining */
|
||||
/* a copy of this software and associated documentation files (the */
|
||||
/* "Software"), to deal in the Software without restriction, including */
|
||||
/* without limitation the rights to use, copy, modify, merge, publish, */
|
||||
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
||||
/* permit persons to whom the Software is furnished to do so, subject to */
|
||||
/* the following conditions: */
|
||||
/* */
|
||||
/* The above copyright notice and this permission notice shall be */
|
||||
/* included in all copies or substantial portions of the Software. */
|
||||
/* */
|
||||
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
||||
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
||||
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
||||
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
||||
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
||||
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
||||
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
||||
/*************************************************************************/
|
||||
|
||||
#include "gdscript_workspace.h"
|
||||
#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() {
|
||||
ClassDB::bind_method(D_METHOD("symbol"), &GDScriptWorkspace::symbol);
|
||||
ClassDB::bind_method(D_METHOD("parse_script", "p_path", "p_content"), &GDScriptWorkspace::parse_script);
|
||||
ClassDB::bind_method(D_METHOD("parse_local_script", "p_path"), &GDScriptWorkspace::parse_local_script);
|
||||
ClassDB::bind_method(D_METHOD("get_file_path", "p_uri"), &GDScriptWorkspace::get_file_path);
|
||||
ClassDB::bind_method(D_METHOD("get_file_uri", "p_path"), &GDScriptWorkspace::get_file_uri);
|
||||
ClassDB::bind_method(D_METHOD("publish_diagnostics", "p_path"), &GDScriptWorkspace::publish_diagnostics);
|
||||
ClassDB::bind_method(D_METHOD("generate_script_api", "p_path"), &GDScriptWorkspace::generate_script_api);
|
||||
}
|
||||
|
||||
void GDScriptWorkspace::remove_cache_parser(const String &p_path) {
|
||||
Map<String, ExtendGDScriptParser *>::Element *parser = parse_results.find(p_path);
|
||||
Map<String, ExtendGDScriptParser *>::Element *script = scripts.find(p_path);
|
||||
if (parser && script) {
|
||||
if (script->get() && script->get() == script->get()) {
|
||||
memdelete(script->get());
|
||||
} else {
|
||||
memdelete(script->get());
|
||||
memdelete(parser->get());
|
||||
}
|
||||
parse_results.erase(p_path);
|
||||
scripts.erase(p_path);
|
||||
} else if (parser) {
|
||||
memdelete(parser->get());
|
||||
parse_results.erase(p_path);
|
||||
} else if (script) {
|
||||
memdelete(script->get());
|
||||
scripts.erase(p_path);
|
||||
}
|
||||
}
|
||||
|
||||
const lsp::DocumentSymbol *GDScriptWorkspace::get_native_symbol(const String &p_class, const String &p_member) const {
|
||||
|
||||
StringName class_name = p_class;
|
||||
StringName empty;
|
||||
|
||||
while (class_name != empty) {
|
||||
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 = parse_results.find(p_path);
|
||||
if (!S) {
|
||||
parse_local_script(p_path);
|
||||
S = parse_results.find(p_path);
|
||||
}
|
||||
if (S) {
|
||||
return S->get();
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
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::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)) {
|
||||
arr.push_back(script_symbols[i].to_json());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
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.native_class = 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 = ExtendGDScriptParser::marked_documentation(class_data.brief_description) + "\n" + ExtendGDScriptParser::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.native_class = class_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 = ExtendGDScriptParser::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.native_class = class_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 = ExtendGDScriptParser::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.native_class = class_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 = ExtendGDScriptParser::marked_documentation(data.description);
|
||||
class_symbol.children.push_back(symbol);
|
||||
}
|
||||
|
||||
native_symbols.insert(class_name, class_symbol);
|
||||
}
|
||||
|
||||
reload_all_workspace_scripts();
|
||||
|
||||
if (GDScriptLanguageProtocol::get_singleton()->is_smart_resolve_enabled()) {
|
||||
for (Map<StringName, lsp::DocumentSymbol>::Element *E = native_symbols.front(); E; E = E->next()) {
|
||||
ClassMembers members;
|
||||
const lsp::DocumentSymbol &class_symbol = E->get();
|
||||
for (int i = 0; i < class_symbol.children.size(); i++) {
|
||||
const lsp::DocumentSymbol &symbol = class_symbol.children[i];
|
||||
members.set(symbol.name, &symbol);
|
||||
}
|
||||
native_members.set(E->key(), members);
|
||||
}
|
||||
|
||||
// cache member completions
|
||||
for (Map<String, ExtendGDScriptParser *>::Element *S = scripts.front(); S; S = S->next()) {
|
||||
S->get()->get_member_completions();
|
||||
}
|
||||
}
|
||||
|
||||
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);
|
||||
Map<String, ExtendGDScriptParser *>::Element *last_parser = parse_results.find(p_path);
|
||||
Map<String, ExtendGDScriptParser *>::Element *last_script = scripts.find(p_path);
|
||||
|
||||
if (err == OK) {
|
||||
|
||||
remove_cache_parser(p_path);
|
||||
parse_results[p_path] = parser;
|
||||
scripts[p_path] = parser;
|
||||
|
||||
} else {
|
||||
if (last_parser && last_script && last_parser->get() != last_script->get()) {
|
||||
memdelete(last_parser->get());
|
||||
}
|
||||
parse_results[p_path] = parser;
|
||||
}
|
||||
|
||||
publish_diagnostics(p_path);
|
||||
|
||||
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;
|
||||
path = path.replace(root_uri + "/", "res://");
|
||||
path = path.http_unescape();
|
||||
return path;
|
||||
}
|
||||
|
||||
String GDScriptWorkspace::get_file_uri(const String &p_path) const {
|
||||
String uri = p_path;
|
||||
uri = uri.replace("res://", root_uri + "/");
|
||||
return uri;
|
||||
}
|
||||
|
||||
void GDScriptWorkspace::publish_diagnostics(const String &p_path) {
|
||||
Dictionary params;
|
||||
Array errors;
|
||||
const Map<String, ExtendGDScriptParser *>::Element *ele = parse_results.find(p_path);
|
||||
if (ele) {
|
||||
const Vector<lsp::Diagnostic> &list = ele->get()->get_diagnostics();
|
||||
errors.resize(list.size());
|
||||
for (int i = 0; i < list.size(); ++i) {
|
||||
errors[i] = list[i].to_json();
|
||||
}
|
||||
}
|
||||
params["diagnostics"] = errors;
|
||||
params["uri"] = get_file_uri(p_path);
|
||||
GDScriptLanguageProtocol::get_singleton()->notify_client("textDocument/publishDiagnostics", params);
|
||||
}
|
||||
|
||||
void GDScriptWorkspace::completion(const lsp::CompletionParams &p_params, List<ScriptCodeCompletionOption> *r_options) {
|
||||
|
||||
String path = get_file_path(p_params.textDocument.uri);
|
||||
String call_hint;
|
||||
bool forced = false;
|
||||
|
||||
if (const ExtendGDScriptParser *parser = get_parse_result(path)) {
|
||||
String code = parser->get_text_for_completion(p_params.position);
|
||||
GDScriptLanguage::get_singleton()->complete_code(code, path, NULL, r_options, forced, call_hint);
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
Vector<String> identifier_parts = symbol_identifier.split("(");
|
||||
if (identifier_parts.size()) {
|
||||
symbol_identifier = identifier_parts[0];
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
void GDScriptWorkspace::resolve_related_symbols(const lsp::TextDocumentPositionParams &p_doc_pos, List<const lsp::DocumentSymbol *> &r_list) {
|
||||
|
||||
String path = get_file_path(p_doc_pos.textDocument.uri);
|
||||
if (const ExtendGDScriptParser *parser = get_parse_result(path)) {
|
||||
|
||||
String symbol_identifier;
|
||||
Vector2i offset;
|
||||
symbol_identifier = parser->get_identifier_under_position(p_doc_pos.position, offset);
|
||||
|
||||
const StringName *class_ptr = native_members.next(NULL);
|
||||
while (class_ptr) {
|
||||
const ClassMembers &members = native_members.get(*class_ptr);
|
||||
if (const lsp::DocumentSymbol *const *symbol = members.getptr(symbol_identifier)) {
|
||||
r_list.push_back(*symbol);
|
||||
}
|
||||
class_ptr = native_members.next(class_ptr);
|
||||
}
|
||||
|
||||
for (Map<String, ExtendGDScriptParser *>::Element *E = scripts.front(); E; E = E->next()) {
|
||||
const ExtendGDScriptParser *script = E->get();
|
||||
const ClassMembers &members = script->get_members();
|
||||
if (const lsp::DocumentSymbol *const *symbol = members.getptr(symbol_identifier)) {
|
||||
r_list.push_back(*symbol);
|
||||
}
|
||||
|
||||
const HashMap<String, ClassMembers> &inner_classes = script->get_inner_classes();
|
||||
const String *_class = inner_classes.next(NULL);
|
||||
while (_class) {
|
||||
|
||||
const ClassMembers *inner_class = inner_classes.getptr(*_class);
|
||||
if (const lsp::DocumentSymbol *const *symbol = inner_class->getptr(symbol_identifier)) {
|
||||
r_list.push_back(*symbol);
|
||||
}
|
||||
|
||||
_class = inner_classes.next(_class);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Dictionary GDScriptWorkspace::generate_script_api(const String &p_path) {
|
||||
Dictionary api;
|
||||
if (const ExtendGDScriptParser *parser = get_parse_successed_script(p_path)) {
|
||||
api = parser->generate_api();
|
||||
}
|
||||
return api;
|
||||
}
|
||||
|
||||
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());
|
||||
}
|
||||
}
|
91
modules/gdscript/language_server/gdscript_workspace.h
Normal file
91
modules/gdscript/language_server/gdscript_workspace.h
Normal file
|
@ -0,0 +1,91 @@
|
|||
/*************************************************************************/
|
||||
/* gdscript_workspace.h */
|
||||
/*************************************************************************/
|
||||
/* This file is part of: */
|
||||
/* GODOT ENGINE */
|
||||
/* https://godotengine.org */
|
||||
/*************************************************************************/
|
||||
/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */
|
||||
/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md) */
|
||||
/* */
|
||||
/* Permission is hereby granted, free of charge, to any person obtaining */
|
||||
/* a copy of this software and associated documentation files (the */
|
||||
/* "Software"), to deal in the Software without restriction, including */
|
||||
/* without limitation the rights to use, copy, modify, merge, publish, */
|
||||
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
||||
/* permit persons to whom the Software is furnished to do so, subject to */
|
||||
/* the following conditions: */
|
||||
/* */
|
||||
/* The above copyright notice and this permission notice shall be */
|
||||
/* included in all copies or substantial portions of the Software. */
|
||||
/* */
|
||||
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
||||
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
||||
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
||||
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
||||
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
||||
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
||||
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
||||
/*************************************************************************/
|
||||
|
||||
#ifndef GDSCRIPT_WORKSPACE_H
|
||||
#define GDSCRIPT_WORKSPACE_H
|
||||
|
||||
#include "../gdscript_parser.h"
|
||||
#include "core/variant.h"
|
||||
#include "gdscript_extend_parser.h"
|
||||
#include "lsp.hpp"
|
||||
|
||||
class GDScriptWorkspace : public Reference {
|
||||
GDCLASS(GDScriptWorkspace, 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();
|
||||
|
||||
ExtendGDScriptParser *get_parse_successed_script(const String &p_path);
|
||||
ExtendGDScriptParser *get_parse_result(const String &p_path);
|
||||
|
||||
void strip_flat_symbols(const String &p_branch);
|
||||
void list_script_files(const String &p_root_dir, List<String> &r_files);
|
||||
|
||||
public:
|
||||
String root;
|
||||
String root_uri;
|
||||
|
||||
Map<String, ExtendGDScriptParser *> scripts;
|
||||
Map<String, ExtendGDScriptParser *> parse_results;
|
||||
HashMap<StringName, ClassMembers> native_members;
|
||||
|
||||
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);
|
||||
void resolve_related_symbols(const lsp::TextDocumentPositionParams &p_doc_pos, List<const lsp::DocumentSymbol *> &r_list);
|
||||
|
||||
Dictionary generate_script_api(const String &p_path);
|
||||
|
||||
GDScriptWorkspace();
|
||||
~GDScriptWorkspace();
|
||||
};
|
||||
|
||||
#endif
|
1506
modules/gdscript/language_server/lsp.hpp
Normal file
1506
modules/gdscript/language_server/lsp.hpp
Normal file
File diff suppressed because it is too large
Load diff
|
@ -37,6 +37,7 @@
|
|||
#include "editor/gdscript_highlighter.h"
|
||||
#include "gdscript.h"
|
||||
#include "gdscript_tokenizer.h"
|
||||
#include "language_server/gdscript_language_server.h"
|
||||
|
||||
GDScriptLanguage *script_language_gd = NULL;
|
||||
Ref<ResourceFormatLoaderGDScript> resource_loader_gd;
|
||||
|
@ -44,6 +45,7 @@ Ref<ResourceFormatSaverGDScript> resource_saver_gd;
|
|||
|
||||
#ifdef TOOLS_ENABLED
|
||||
|
||||
#include "core/engine.h"
|
||||
#include "editor/editor_export.h"
|
||||
#include "editor/editor_node.h"
|
||||
#include "editor/editor_settings.h"
|
||||
|
@ -134,6 +136,11 @@ static void _editor_init() {
|
|||
Ref<EditorExportGDScript> gd_export;
|
||||
gd_export.instance();
|
||||
EditorExport::get_singleton()->add_export_plugin(gd_export);
|
||||
|
||||
register_lsp_types();
|
||||
GDScriptLanguageServer *lsp_plugin = memnew(GDScriptLanguageServer);
|
||||
EditorNode::get_singleton()->add_editor_plugin(lsp_plugin);
|
||||
Engine::get_singleton()->add_singleton(Engine::Singleton("GDScriptLanguageProtocol", GDScriptLanguageProtocol::get_singleton()));
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
7
modules/jsonrpc/SCsub
Normal file
7
modules/jsonrpc/SCsub
Normal file
|
@ -0,0 +1,7 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
Import('env')
|
||||
Import('env_modules')
|
||||
|
||||
env_jsonrpc = env_modules.Clone()
|
||||
env_jsonrpc.add_source_files(env.modules_sources, "*.cpp")
|
5
modules/jsonrpc/config.py
Normal file
5
modules/jsonrpc/config.py
Normal file
|
@ -0,0 +1,5 @@
|
|||
def can_build(env, platform):
|
||||
return True
|
||||
|
||||
def configure(env):
|
||||
pass
|
171
modules/jsonrpc/jsonrpc.cpp
Normal file
171
modules/jsonrpc/jsonrpc.cpp
Normal file
|
@ -0,0 +1,171 @@
|
|||
/*************************************************************************/
|
||||
/* jsonrpc.cpp */
|
||||
/*************************************************************************/
|
||||
/* This file is part of: */
|
||||
/* GODOT ENGINE */
|
||||
/* https://godotengine.org */
|
||||
/*************************************************************************/
|
||||
/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */
|
||||
/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md) */
|
||||
/* */
|
||||
/* Permission is hereby granted, free of charge, to any person obtaining */
|
||||
/* a copy of this software and associated documentation files (the */
|
||||
/* "Software"), to deal in the Software without restriction, including */
|
||||
/* without limitation the rights to use, copy, modify, merge, publish, */
|
||||
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
||||
/* permit persons to whom the Software is furnished to do so, subject to */
|
||||
/* the following conditions: */
|
||||
/* */
|
||||
/* The above copyright notice and this permission notice shall be */
|
||||
/* included in all copies or substantial portions of the Software. */
|
||||
/* */
|
||||
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
||||
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
||||
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
||||
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
||||
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
||||
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
||||
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
||||
/*************************************************************************/
|
||||
|
||||
#include "jsonrpc.h"
|
||||
#include "core/io/json.h"
|
||||
|
||||
JSONRPC::JSONRPC() {
|
||||
}
|
||||
|
||||
JSONRPC::~JSONRPC() {
|
||||
}
|
||||
|
||||
void JSONRPC::_bind_methods() {
|
||||
ClassDB::bind_method(D_METHOD("set_scope", "scope", "target"), &JSONRPC::set_scope);
|
||||
ClassDB::bind_method(D_METHOD("process_action", "action", "recurse"), &JSONRPC::process_action, DEFVAL(false));
|
||||
ClassDB::bind_method(D_METHOD("process_string", "action"), &JSONRPC::process_string);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("make_request", "method", "params", "id"), &JSONRPC::make_request);
|
||||
ClassDB::bind_method(D_METHOD("make_response", "result", "id"), &JSONRPC::make_response);
|
||||
ClassDB::bind_method(D_METHOD("make_notification", "method", "params"), &JSONRPC::make_notification);
|
||||
ClassDB::bind_method(D_METHOD("make_response_error", "code", "message", "id"), &JSONRPC::make_response_error, DEFVAL(Variant()));
|
||||
|
||||
BIND_ENUM_CONSTANT(ParseError)
|
||||
BIND_ENUM_CONSTANT(InvalidRequest)
|
||||
BIND_ENUM_CONSTANT(MethodNotFound)
|
||||
BIND_ENUM_CONSTANT(InvalidParams)
|
||||
BIND_ENUM_CONSTANT(InternalError)
|
||||
}
|
||||
|
||||
Dictionary JSONRPC::make_response_error(int p_code, const String &p_message, const Variant &p_id) const {
|
||||
Dictionary dict;
|
||||
dict["jsonrpc"] = "2.0";
|
||||
|
||||
Dictionary err;
|
||||
err["code"] = p_code;
|
||||
err["message"] = p_message;
|
||||
|
||||
dict["error"] = err;
|
||||
dict["id"] = p_id;
|
||||
|
||||
return dict;
|
||||
}
|
||||
|
||||
Dictionary JSONRPC::make_response(const Variant &p_value, const Variant &p_id) {
|
||||
Dictionary dict;
|
||||
dict["jsonrpc"] = "2.0";
|
||||
dict["id"] = p_id;
|
||||
dict["result"] = p_value;
|
||||
return dict;
|
||||
}
|
||||
|
||||
Dictionary JSONRPC::make_notification(const String &p_method, const Variant &p_params) {
|
||||
Dictionary dict;
|
||||
dict["jsonrpc"] = "2.0";
|
||||
dict["method"] = p_method;
|
||||
dict["params"] = p_params;
|
||||
return dict;
|
||||
}
|
||||
|
||||
Dictionary JSONRPC::make_request(const String &p_method, const Variant &p_params, const Variant &p_id) {
|
||||
Dictionary dict;
|
||||
dict["jsonrpc"] = "2.0";
|
||||
dict["method"] = p_method;
|
||||
dict["params"] = p_params;
|
||||
dict["id"] = p_id;
|
||||
return dict;
|
||||
}
|
||||
|
||||
Variant JSONRPC::process_action(const Variant &p_action, bool p_process_arr_elements) {
|
||||
Variant ret;
|
||||
if (p_action.get_type() == Variant::DICTIONARY) {
|
||||
Dictionary dict = p_action;
|
||||
String method = dict.get("method", "");
|
||||
Array args;
|
||||
if (dict.has("params")) {
|
||||
Variant params = dict.get("params", Variant());
|
||||
if (params.get_type() == Variant::ARRAY) {
|
||||
args = params;
|
||||
} else {
|
||||
args.push_back(params);
|
||||
}
|
||||
}
|
||||
|
||||
Object *object = this;
|
||||
if (method_scopes.has(method.get_base_dir())) {
|
||||
object = method_scopes[method.get_base_dir()];
|
||||
method = method.get_file();
|
||||
}
|
||||
|
||||
Variant id;
|
||||
if (dict.has("id")) {
|
||||
id = dict["id"];
|
||||
}
|
||||
|
||||
if (object == NULL || !object->has_method(method)) {
|
||||
ret = make_response_error(JSONRPC::MethodNotFound, "Method not found", id);
|
||||
} else {
|
||||
Variant call_ret = object->callv(method, args);
|
||||
if (id.get_type() != Variant::NIL) {
|
||||
ret = make_response(call_ret, id);
|
||||
}
|
||||
}
|
||||
} else if (p_action.get_type() == Variant::ARRAY && p_process_arr_elements) {
|
||||
Array arr = p_action;
|
||||
int size = arr.size();
|
||||
if (size) {
|
||||
Array arr_ret;
|
||||
for (int i = 0; i < size; i++) {
|
||||
const Variant &var = arr.get(i);
|
||||
arr_ret.push_back(process_action(var));
|
||||
}
|
||||
ret = arr_ret;
|
||||
} else {
|
||||
ret = make_response_error(JSONRPC::InvalidRequest, "Invalid Request");
|
||||
}
|
||||
} else {
|
||||
ret = make_response_error(JSONRPC::InvalidRequest, "Invalid Request");
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
String JSONRPC::process_string(const String &p_input) {
|
||||
|
||||
if (p_input.empty()) return String();
|
||||
|
||||
Variant ret;
|
||||
Variant input;
|
||||
String err_message;
|
||||
int err_line;
|
||||
if (OK != JSON::parse(p_input, input, err_message, err_line)) {
|
||||
ret = make_response_error(JSONRPC::ParseError, "Parse error");
|
||||
} else {
|
||||
ret = process_action(input, true);
|
||||
}
|
||||
|
||||
if (ret.get_type() == Variant::NIL) {
|
||||
return "";
|
||||
}
|
||||
return JSON::print(ret);
|
||||
}
|
||||
|
||||
void JSONRPC::set_scope(const String &p_scope, Object *p_obj) {
|
||||
method_scopes[p_scope] = p_obj;
|
||||
}
|
70
modules/jsonrpc/jsonrpc.h
Normal file
70
modules/jsonrpc/jsonrpc.h
Normal file
|
@ -0,0 +1,70 @@
|
|||
/*************************************************************************/
|
||||
/* jsonrpc.h */
|
||||
/*************************************************************************/
|
||||
/* This file is part of: */
|
||||
/* GODOT ENGINE */
|
||||
/* https://godotengine.org */
|
||||
/*************************************************************************/
|
||||
/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */
|
||||
/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md) */
|
||||
/* */
|
||||
/* Permission is hereby granted, free of charge, to any person obtaining */
|
||||
/* a copy of this software and associated documentation files (the */
|
||||
/* "Software"), to deal in the Software without restriction, including */
|
||||
/* without limitation the rights to use, copy, modify, merge, publish, */
|
||||
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
||||
/* permit persons to whom the Software is furnished to do so, subject to */
|
||||
/* the following conditions: */
|
||||
/* */
|
||||
/* The above copyright notice and this permission notice shall be */
|
||||
/* included in all copies or substantial portions of the Software. */
|
||||
/* */
|
||||
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
||||
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
||||
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
||||
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
||||
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
||||
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
||||
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
||||
/*************************************************************************/
|
||||
|
||||
#ifndef GODOT_JSON_RPC_H
|
||||
#define GODOT_JSON_RPC_H
|
||||
|
||||
#include "core/object.h"
|
||||
#include "core/variant.h"
|
||||
|
||||
class JSONRPC : public Object {
|
||||
GDCLASS(JSONRPC, Object)
|
||||
|
||||
Map<String, Object *> method_scopes;
|
||||
|
||||
protected:
|
||||
static void _bind_methods();
|
||||
|
||||
public:
|
||||
JSONRPC();
|
||||
~JSONRPC();
|
||||
|
||||
enum ErrorCode {
|
||||
ParseError = -32700,
|
||||
InvalidRequest = -32600,
|
||||
MethodNotFound = -32601,
|
||||
InvalidParams = -32602,
|
||||
InternalError = -32603,
|
||||
};
|
||||
|
||||
Dictionary make_response_error(int p_code, const String &p_message, const Variant &p_id = Variant()) const;
|
||||
Dictionary make_response(const Variant &p_value, const Variant &p_id);
|
||||
Dictionary make_notification(const String &p_method, const Variant &p_params);
|
||||
Dictionary make_request(const String &p_method, const Variant &p_params, const Variant &p_id);
|
||||
|
||||
Variant process_action(const Variant &p_action, bool p_process_arr_elements = false);
|
||||
String process_string(const String &p_input);
|
||||
|
||||
void set_scope(const String &p_scope, Object *p_obj);
|
||||
};
|
||||
|
||||
VARIANT_ENUM_CAST(JSONRPC::ErrorCode);
|
||||
|
||||
#endif
|
40
modules/jsonrpc/register_types.cpp
Normal file
40
modules/jsonrpc/register_types.cpp
Normal file
|
@ -0,0 +1,40 @@
|
|||
/*************************************************************************/
|
||||
/* register_types.cpp */
|
||||
/*************************************************************************/
|
||||
/* This file is part of: */
|
||||
/* GODOT ENGINE */
|
||||
/* https://godotengine.org */
|
||||
/*************************************************************************/
|
||||
/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */
|
||||
/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md) */
|
||||
/* */
|
||||
/* Permission is hereby granted, free of charge, to any person obtaining */
|
||||
/* a copy of this software and associated documentation files (the */
|
||||
/* "Software"), to deal in the Software without restriction, including */
|
||||
/* without limitation the rights to use, copy, modify, merge, publish, */
|
||||
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
||||
/* permit persons to whom the Software is furnished to do so, subject to */
|
||||
/* the following conditions: */
|
||||
/* */
|
||||
/* The above copyright notice and this permission notice shall be */
|
||||
/* included in all copies or substantial portions of the Software. */
|
||||
/* */
|
||||
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
||||
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
||||
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
||||
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
||||
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
||||
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
||||
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
||||
/*************************************************************************/
|
||||
|
||||
#include "register_types.h"
|
||||
#include "core/class_db.h"
|
||||
#include "jsonrpc.h"
|
||||
|
||||
void register_jsonrpc_types() {
|
||||
ClassDB::register_class<JSONRPC>();
|
||||
}
|
||||
|
||||
void unregister_jsonrpc_types() {
|
||||
}
|
32
modules/jsonrpc/register_types.h
Normal file
32
modules/jsonrpc/register_types.h
Normal file
|
@ -0,0 +1,32 @@
|
|||
/*************************************************************************/
|
||||
/* register_types.h */
|
||||
/*************************************************************************/
|
||||
/* This file is part of: */
|
||||
/* GODOT ENGINE */
|
||||
/* https://godotengine.org */
|
||||
/*************************************************************************/
|
||||
/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */
|
||||
/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md) */
|
||||
/* */
|
||||
/* Permission is hereby granted, free of charge, to any person obtaining */
|
||||
/* a copy of this software and associated documentation files (the */
|
||||
/* "Software"), to deal in the Software without restriction, including */
|
||||
/* without limitation the rights to use, copy, modify, merge, publish, */
|
||||
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
||||
/* permit persons to whom the Software is furnished to do so, subject to */
|
||||
/* the following conditions: */
|
||||
/* */
|
||||
/* The above copyright notice and this permission notice shall be */
|
||||
/* included in all copies or substantial portions of the Software. */
|
||||
/* */
|
||||
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
||||
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
||||
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
||||
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
||||
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
||||
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
||||
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
||||
/*************************************************************************/
|
||||
|
||||
void register_jsonrpc_types();
|
||||
void unregister_jsonrpc_types();
|
Loading…
Reference in a new issue