diff options
Diffstat (limited to 'modules')
45 files changed, 2179 insertions, 712 deletions
diff --git a/modules/gdscript/doc_classes/@GDScript.xml b/modules/gdscript/doc_classes/@GDScript.xml index 4f1a256ec9..18045e323c 100644 --- a/modules/gdscript/doc_classes/@GDScript.xml +++ b/modules/gdscript/doc_classes/@GDScript.xml @@ -57,11 +57,12 @@ [/codeblock] </description> </method> - <method name="convert"> + <method name="convert" is_deprecated="true"> <return type="Variant" /> <param index="0" name="what" type="Variant" /> <param index="1" name="type" type="int" /> <description> + [i]Deprecated.[/i] Use [method @GlobalScope.type_convert] instead. Converts [param what] to [param type] in the best way possible. The [param type] uses the [enum Variant.Type] values. [codeblock] var a = [4, 2.5, 1.2] diff --git a/modules/gdscript/editor/gdscript_docgen.cpp b/modules/gdscript/editor/gdscript_docgen.cpp index 1aecfc6de1..0b440274c0 100644 --- a/modules/gdscript/editor/gdscript_docgen.cpp +++ b/modules/gdscript/editor/gdscript_docgen.cpp @@ -87,7 +87,7 @@ static void _doctype_from_gdtype(const GDType &p_gdtype, String &r_type, String case GDType::SCRIPT: if (p_gdtype.script_type.is_valid()) { if (p_gdtype.script_type->get_global_name() != StringName()) { - r_type = _get_script_path(p_gdtype.script_type->get_global_name()); + r_type = p_gdtype.script_type->get_global_name(); return; } if (!p_gdtype.script_type->get_path().is_empty()) { @@ -129,10 +129,10 @@ void GDScriptDocGen::generate_docs(GDScript *p_script, const GDP::ClassNode *p_c DocData::ClassDoc &doc = p_script->doc; doc.script_path = _get_script_path(p_script->get_script_path()); - if (p_script->name.is_empty()) { + if (p_script->local_name == StringName()) { doc.name = doc.script_path; } else { - doc.name = p_script->name; + doc.name = p_script->local_name; } if (p_script->_owner) { @@ -204,6 +204,9 @@ void GDScriptDocGen::generate_docs(GDScript *p_script, const GDP::ClassNode *p_c if (m_func->return_type) { _doctype_from_gdtype(m_func->return_type->get_datatype(), method_doc.return_type, method_doc.return_enum, true); + } else if (!m_func->body->has_return) { + // If no `return` statement, then return type is `void`, not `Variant`. + method_doc.return_type = "void"; } else { method_doc.return_type = "Variant"; } diff --git a/modules/gdscript/gdscript.cpp b/modules/gdscript/gdscript.cpp index ccbcb3ee96..62d2c14c17 100644 --- a/modules/gdscript/gdscript.cpp +++ b/modules/gdscript/gdscript.cpp @@ -254,7 +254,7 @@ Ref<Script> GDScript::get_base_script() const { } StringName GDScript::get_global_name() const { - return name; + return global_name; } StringName GDScript::get_instance_base_type() const { @@ -284,27 +284,9 @@ void GDScript::_get_script_method_list(List<MethodInfo> *r_list, bool p_include_ const GDScript *current = this; while (current) { for (const KeyValue<StringName, GDScriptFunction *> &E : current->member_functions) { - GDScriptFunction *func = E.value; - MethodInfo mi; - mi.name = E.key; - - if (func->is_static()) { - mi.flags |= METHOD_FLAG_STATIC; - } - - for (int i = 0; i < func->get_argument_count(); i++) { - PropertyInfo arginfo = func->get_argument_type(i); -#ifdef TOOLS_ENABLED - arginfo.name = func->get_argument_name(i); -#endif - mi.arguments.push_back(arginfo); - } -#ifdef TOOLS_ENABLED - mi.default_arguments.append_array(func->get_default_arg_values()); -#endif - mi.return_val = func->get_return_type(); - r_list->push_back(mi); + r_list->push_back(E.value->get_method_info()); } + if (!p_include_base) { return; } @@ -323,10 +305,9 @@ void GDScript::_get_script_property_list(List<PropertyInfo> *r_list, bool p_incl while (sptr) { Vector<_GDScriptMemberSort> msort; - for (const KeyValue<StringName, PropertyInfo> &E : sptr->member_info) { + for (const KeyValue<StringName, MemberInfo> &E : sptr->member_indices) { _GDScriptMemberSort ms; - ERR_CONTINUE(!sptr->member_indices.has(E.key)); - ms.index = sptr->member_indices[E.key].index; + ms.index = E.value.index; ms.name = E.key; msort.push_back(ms); } @@ -334,7 +315,7 @@ void GDScript::_get_script_property_list(List<PropertyInfo> *r_list, bool p_incl msort.sort(); msort.reverse(); for (int i = 0; i < msort.size(); i++) { - props.push_front(sptr->member_info[msort[i].name]); + props.push_front(sptr->member_indices[msort[i].name].property_info); } #ifdef TOOLS_ENABLED @@ -368,15 +349,7 @@ MethodInfo GDScript::get_method_info(const StringName &p_method) const { return MethodInfo(); } - GDScriptFunction *func = E->value; - MethodInfo mi; - mi.name = E->key; - for (int i = 0; i < func->get_argument_count(); i++) { - mi.arguments.push_back(func->get_argument_type(i)); - } - - mi.return_val = func->get_return_type(); - return mi; + return E->value->get_method_info(); } bool GDScript::get_property_default_value(const StringName &p_property, Variant &r_value) const { @@ -557,13 +530,7 @@ bool GDScript::_update_exports(bool *r_err, bool p_recursive_call, PlaceHolderSc member_default_values_cache[member.variable->identifier->name] = default_value; } break; case GDScriptParser::ClassNode::Member::SIGNAL: { - // TODO: Cache this in parser to avoid loops like this. - Vector<StringName> parameters_names; - parameters_names.resize(member.signal->parameters.size()); - for (int j = 0; j < member.signal->parameters.size(); j++) { - parameters_names.write[j] = member.signal->parameters[j]->identifier->name; - } - _signals[member.signal->identifier->name] = parameters_names; + _signals[member.signal->identifier->name] = member.signal->method_info; } break; case GDScriptParser::ClassNode::Member::GROUP: { members_cache.push_back(member.annotation->export_info); @@ -977,22 +944,26 @@ bool GDScript::_set(const StringName &p_name, const Variant &p_value) { void GDScript::_get_property_list(List<PropertyInfo> *p_properties) const { p_properties->push_back(PropertyInfo(Variant::STRING, "script/source", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR | PROPERTY_USAGE_INTERNAL)); - List<PropertyInfo> property_list; - + List<const GDScript *> classes; const GDScript *top = this; while (top) { - for (const KeyValue<StringName, MemberInfo> &E : top->static_variables_indices) { - PropertyInfo pi = PropertyInfo(E.value.data_type); - pi.name = E.key; - pi.usage |= PROPERTY_USAGE_SCRIPT_VARIABLE; // For the script (as a class) it is a non-static property. - property_list.push_back(pi); - } - + classes.push_back(top); top = top->_base; } - for (const List<PropertyInfo>::Element *E = property_list.back(); E; E = E->prev()) { - p_properties->push_back(E->get()); + for (const List<const GDScript *>::Element *E = classes.back(); E; E = E->prev()) { + Vector<_GDScriptMemberSort> msort; + for (const KeyValue<StringName, MemberInfo> &F : E->get()->static_variables_indices) { + _GDScriptMemberSort ms; + ms.index = F.value.index; + ms.name = F.key; + msort.push_back(ms); + } + msort.sort(); + + for (int i = 0; i < msort.size(); i++) { + p_properties->push_back(E->get()->static_variables_indices[msort[i].name].property_info); + } } } @@ -1110,7 +1081,7 @@ GDScript *GDScript::find_class(const String &p_qualified_name) { Vector<String> class_names; GDScript *result = nullptr; // Empty initial name means start here. - if (first.is_empty() || first == name) { + if (first.is_empty() || first == global_name) { class_names = p_qualified_name.split("::"); result = this; } else if (p_qualified_name.begins_with(get_root_script()->path)) { @@ -1245,15 +1216,8 @@ bool GDScript::has_script_signal(const StringName &p_signal) const { } void GDScript::_get_script_signal_list(List<MethodInfo> *r_list, bool p_include_base) const { - for (const KeyValue<StringName, Vector<StringName>> &E : _signals) { - MethodInfo mi; - mi.name = E.key; - for (int i = 0; i < E.value.size(); i++) { - PropertyInfo arg; - arg.name = E.value[i]; - mi.arguments.push_back(arg); - } - r_list->push_back(mi); + for (const KeyValue<StringName, MethodInfo> &E : _signals) { + r_list->push_back(E.value); } if (!p_include_base) { @@ -1274,21 +1238,6 @@ void GDScript::get_script_signal_list(List<MethodInfo> *r_signals) const { _get_script_signal_list(r_signals, true); } -String GDScript::_get_gdscript_reference_class_name(const GDScript *p_gdscript) { - ERR_FAIL_NULL_V(p_gdscript, String()); - - String class_name; - while (p_gdscript) { - if (class_name.is_empty()) { - class_name = p_gdscript->get_script_class_name(); - } else { - class_name = p_gdscript->get_script_class_name() + "." + class_name; - } - p_gdscript = p_gdscript->_owner; - } - return class_name; -} - GDScript *GDScript::_get_gdscript_from_variant(const Variant &p_variant) { Object *obj = p_variant; if (obj == nullptr || obj->get_instance_id().is_null()) { @@ -1399,29 +1348,13 @@ void GDScript::_save_orphaned_subclasses(ClearData *p_clear_data) { } } -void GDScript::_init_rpc_methods_properties() { - // Copy the base rpc methods so we don't mask their IDs. - rpc_config.clear(); - if (base.is_valid()) { - rpc_config = base->rpc_config.duplicate(); - } - - // RPC Methods - for (KeyValue<StringName, GDScriptFunction *> &E : member_functions) { - Variant config = E.value->get_rpc_config(); - if (config.get_type() != Variant::NIL) { - rpc_config[E.value->get_name()] = config; - } - } -} - #ifdef DEBUG_ENABLED String GDScript::debug_get_script_name(const Ref<Script> &p_script) { if (p_script.is_valid()) { Ref<GDScript> gdscript = p_script; if (gdscript.is_valid()) { - if (!gdscript->get_script_class_name().is_empty()) { - return gdscript->get_script_class_name(); + if (gdscript->get_local_name() != StringName()) { + return gdscript->get_local_name(); } return gdscript->get_fully_qualified_name().get_file(); } @@ -1667,7 +1600,7 @@ bool GDScriptInstance::get(const StringName &p_name, Variant &r_ret) const { } { - HashMap<StringName, Vector<StringName>>::ConstIterator E = sptr->_signals.find(p_name); + HashMap<StringName, MethodInfo>::ConstIterator E = sptr->_signals.find(p_name); if (E) { r_ret = Signal(this->owner, E->key); return true; @@ -1717,11 +1650,11 @@ bool GDScriptInstance::get(const StringName &p_name, Variant &r_ret) const { Variant::Type GDScriptInstance::get_property_type(const StringName &p_name, bool *r_is_valid) const { const GDScript *sptr = script.ptr(); while (sptr) { - if (sptr->member_info.has(p_name)) { + if (sptr->member_indices.has(p_name)) { if (r_is_valid) { *r_is_valid = true; } - return sptr->member_info[p_name].type; + return sptr->member_indices[p_name].property_info.type; } sptr = sptr->_base; } @@ -1798,10 +1731,9 @@ void GDScriptInstance::get_property_list(List<PropertyInfo> *p_properties) const //instance a fake script for editing the values Vector<_GDScriptMemberSort> msort; - for (const KeyValue<StringName, PropertyInfo> &F : sptr->member_info) { + for (const KeyValue<StringName, GDScript::MemberInfo> &F : sptr->member_indices) { _GDScriptMemberSort ms; - ERR_CONTINUE(!sptr->member_indices.has(F.key)); - ms.index = sptr->member_indices[F.key].index; + ms.index = F.value.index; ms.name = F.key; msort.push_back(ms); } @@ -1809,7 +1741,7 @@ void GDScriptInstance::get_property_list(List<PropertyInfo> *p_properties) const msort.sort(); msort.reverse(); for (int i = 0; i < msort.size(); i++) { - props.push_front(sptr->member_info[msort[i].name]); + props.push_front(sptr->member_indices[msort[i].name].property_info); } #ifdef TOOLS_ENABLED @@ -1872,12 +1804,7 @@ void GDScriptInstance::get_method_list(List<MethodInfo> *p_list) const { const GDScript *sptr = script.ptr(); while (sptr) { for (const KeyValue<StringName, GDScriptFunction *> &E : sptr->member_functions) { - MethodInfo mi; - mi.name = E.key; - for (int i = 0; i < E.value->get_argument_count(); i++) { - mi.arguments.push_back(PropertyInfo(Variant::NIL, "arg" + itos(i))); - } - p_list->push_back(mi); + p_list->push_back(E.value->get_method_info()); } sptr = sptr->_base; } diff --git a/modules/gdscript/gdscript.h b/modules/gdscript/gdscript.h index 0ba007683c..2fd2ec236a 100644 --- a/modules/gdscript/gdscript.h +++ b/modules/gdscript/gdscript.h @@ -69,6 +69,7 @@ class GDScript : public Script { StringName setter; StringName getter; GDScriptDataType data_type; + PropertyInfo property_info; }; struct ClearData { @@ -100,7 +101,7 @@ class GDScript : public Script { HashMap<StringName, GDScriptFunction *> member_functions; HashMap<StringName, MemberInfo> member_indices; //members are just indices to the instantiated script. HashMap<StringName, Ref<GDScript>> subclasses; - HashMap<StringName, Vector<StringName>> _signals; + HashMap<StringName, MethodInfo> _signals; Dictionary rpc_config; #ifdef TOOLS_ENABLED @@ -126,8 +127,6 @@ class GDScript : public Script { void _add_doc(const DocData::ClassDoc &p_inner_class); #endif - HashMap<StringName, PropertyInfo> member_info; - GDScriptFunction *implicit_initializer = nullptr; GDScriptFunction *initializer = nullptr; //direct pointer to new , faster to locate GDScriptFunction *implicit_ready = nullptr; @@ -142,7 +141,8 @@ class GDScript : public Script { //exported members String source; String path; - String name; + StringName local_name; // Inner class identifier or `class_name`. + StringName global_name; // `class_name`. String fully_qualified_name; String simplified_icon_path; SelfList<GDScript> script_list; @@ -168,15 +168,11 @@ class GDScript : public Script { bool _update_exports(bool *r_err = nullptr, bool p_recursive_call = false, PlaceHolderScriptInstance *p_instance_to_update = nullptr); void _save_orphaned_subclasses(GDScript::ClearData *p_clear_data); - void _init_rpc_methods_properties(); void _get_script_property_list(List<PropertyInfo> *r_list, bool p_include_base) const; void _get_script_method_list(List<MethodInfo> *r_list, bool p_include_base) const; void _get_script_signal_list(List<MethodInfo> *r_list, bool p_include_base) const; - // This method will map the class name from "RefCounted" to "MyClass.InnerClass". - static String _get_gdscript_reference_class_name(const GDScript *p_gdscript); - GDScript *_get_gdscript_from_variant(const Variant &p_variant); void _get_dependencies(RBSet<GDScript *> &p_dependencies, const GDScript *p_except); @@ -194,6 +190,8 @@ public: static String debug_get_script_name(const Ref<Script> &p_script); #endif + _FORCE_INLINE_ StringName get_local_name() const { return local_name; } + void clear(GDScript::ClearData *p_clear_data = nullptr); virtual bool is_valid() const override { return valid; } @@ -214,7 +212,6 @@ public: } const HashMap<StringName, GDScriptFunction *> &get_member_functions() const { return member_functions; } const Ref<GDScriptNativeClass> &get_native() const { return native; } - const String &get_script_class_name() const { return name; } RBSet<GDScript *> get_dependencies(); RBSet<GDScript *> get_inverted_dependencies(); diff --git a/modules/gdscript/gdscript_analyzer.cpp b/modules/gdscript/gdscript_analyzer.cpp index 18c69467dc..7b3d31f4a8 100644 --- a/modules/gdscript/gdscript_analyzer.cpp +++ b/modules/gdscript/gdscript_analyzer.cpp @@ -1000,10 +1000,16 @@ void GDScriptAnalyzer::resolve_class_member(GDScriptParser::ClassNode *p_class, GDScriptParser::ParameterNode *param = member.signal->parameters[j]; GDScriptParser::DataType param_type = type_from_metatype(resolve_datatype(param->datatype_specifier)); param->set_datatype(param_type); - mi.arguments.push_back(PropertyInfo(param_type.builtin_type, param->identifier->name)); - // TODO: add signal parameter default values +#ifdef DEBUG_ENABLED + if (param->datatype_specifier == nullptr) { + parser->push_warning(param, GDScriptWarning::UNTYPED_DECLARATION, "Parameter", param->identifier->name); + } +#endif + mi.arguments.push_back(param_type.to_property_info(param->identifier->name)); + // Signals do not support parameter default values. } member.signal->set_datatype(make_signal_type(mi)); + member.signal->method_info = mi; // Apply annotations. for (GDScriptParser::AnnotationNode *&E : member.signal->annotations) { @@ -1278,17 +1284,15 @@ void GDScriptAnalyzer::resolve_class_body(GDScriptParser::ClassNode *p_class, co } else if (member.type == GDScriptParser::ClassNode::Member::VARIABLE && member.variable->property != GDScriptParser::VariableNode::PROP_NONE) { if (member.variable->property == GDScriptParser::VariableNode::PROP_INLINE) { if (member.variable->getter != nullptr) { - member.variable->getter->set_datatype(member.variable->datatype); + member.variable->getter->return_type = member.variable->datatype_specifier; + member.variable->getter->set_datatype(member.get_datatype()); resolve_function_body(member.variable->getter); } if (member.variable->setter != nullptr) { - resolve_function_signature(member.variable->setter); - - if (member.variable->setter->parameters.size() > 0) { - member.variable->setter->parameters[0]->datatype_specifier = member.variable->datatype_specifier; - member.variable->setter->parameters[0]->set_datatype(member.get_datatype()); - } + ERR_CONTINUE(member.variable->setter->parameters.is_empty()); + member.variable->setter->parameters[0]->datatype_specifier = member.variable->datatype_specifier; + member.variable->setter->parameters[0]->set_datatype(member.get_datatype()); resolve_function_body(member.variable->setter); } @@ -1592,21 +1596,26 @@ void GDScriptAnalyzer::resolve_function_signature(GDScriptParser::FunctionNode * int default_value_count = 0; #endif // TOOLS_ENABLED +#ifdef DEBUG_ENABLED + String function_visible_name = function_name; + if (function_name == StringName()) { + function_visible_name = p_is_lambda ? "<anonymous lambda>" : "<unknown function>"; + } +#endif + for (int i = 0; i < p_function->parameters.size(); i++) { resolve_parameter(p_function->parameters[i]); #ifdef DEBUG_ENABLED if (p_function->parameters[i]->usages == 0 && !String(p_function->parameters[i]->identifier->name).begins_with("_")) { - String visible_name = function_name; - if (function_name == StringName()) { - visible_name = p_is_lambda ? "<anonymous lambda>" : "<unknown function>"; - } - parser->push_warning(p_function->parameters[i]->identifier, GDScriptWarning::UNUSED_PARAMETER, visible_name, p_function->parameters[i]->identifier->name); + parser->push_warning(p_function->parameters[i]->identifier, GDScriptWarning::UNUSED_PARAMETER, function_visible_name, p_function->parameters[i]->identifier->name); } is_shadowing(p_function->parameters[i]->identifier, "function parameter", true); #endif // DEBUG_ENABLED -#ifdef TOOLS_ENABLED + if (p_function->parameters[i]->initializer) { +#ifdef TOOLS_ENABLED default_value_count++; +#endif // TOOLS_ENABLED if (p_function->parameters[i]->initializer->is_constant) { p_function->default_arg_values.push_back(p_function->parameters[i]->initializer->reduced_value); @@ -1614,7 +1623,6 @@ void GDScriptAnalyzer::resolve_function_signature(GDScriptParser::FunctionNode * p_function->default_arg_values.push_back(Variant()); // Prevent shift. } } -#endif // TOOLS_ENABLED } if (!p_is_lambda && function_name == GDScriptLanguage::get_singleton()->strings._init) { @@ -1714,6 +1722,12 @@ void GDScriptAnalyzer::resolve_function_signature(GDScriptParser::FunctionNode * #endif // TOOLS_ENABLED } +#ifdef DEBUG_ENABLED + if (p_function->return_type == nullptr) { + parser->push_warning(p_function, GDScriptWarning::UNTYPED_DECLARATION, "Function", function_visible_name); + } +#endif + if (p_function->get_datatype().is_resolving()) { p_function->set_datatype(prev_datatype); } @@ -1917,6 +1931,13 @@ void GDScriptAnalyzer::resolve_assignable(GDScriptParser::AssignableNode *p_assi } } +#ifdef DEBUG_ENABLED + if (!has_specified_type && !p_assignable->infer_datatype && !is_constant) { + const bool is_parameter = p_assignable->type == GDScriptParser::Node::PARAMETER; + parser->push_warning(p_assignable, GDScriptWarning::UNTYPED_DECLARATION, is_parameter ? "Parameter" : "Variable", p_assignable->identifier->name); + } +#endif + type.is_constant = is_constant; type.is_read_only = false; p_assignable->set_datatype(type); @@ -2127,13 +2148,18 @@ void GDScriptAnalyzer::resolve_for(GDScriptParser::ForNode *p_for) { #endif } #ifdef DEBUG_ENABLED - } else { + } else if (variable_type.is_hard_type()) { parser->push_warning(p_for->datatype_specifier, GDScriptWarning::REDUNDANT_FOR_VARIABLE_TYPE, p_for->variable->name, variable_type.to_string(), specified_type.to_string()); #endif } p_for->variable->set_datatype(specified_type); } else { p_for->variable->set_datatype(variable_type); +#ifdef DEBUG_ENABLED + if (!variable_type.is_hard_type()) { + parser->push_warning(p_for->variable, GDScriptWarning::UNTYPED_DECLARATION, R"("for" iterator variable)", p_for->variable->name); + } +#endif } } diff --git a/modules/gdscript/gdscript_byte_codegen.cpp b/modules/gdscript/gdscript_byte_codegen.cpp index af7862efc5..8394fce9b3 100644 --- a/modules/gdscript/gdscript_byte_codegen.cpp +++ b/modules/gdscript/gdscript_byte_codegen.cpp @@ -35,9 +35,6 @@ #include "core/debugger/engine_debugger.h" uint32_t GDScriptByteCodeGenerator::add_parameter(const StringName &p_name, bool p_is_optional, const GDScriptDataType &p_type) { -#ifdef TOOLS_ENABLED - function->arg_names.push_back(p_name); -#endif function->_argument_count++; function->argument_types.push_back(p_type); if (p_is_optional) { diff --git a/modules/gdscript/gdscript_compiler.cpp b/modules/gdscript/gdscript_compiler.cpp index 985eb97b29..fae7861539 100644 --- a/modules/gdscript/gdscript_compiler.cpp +++ b/modules/gdscript/gdscript_compiler.cpp @@ -2165,8 +2165,14 @@ GDScriptFunction *GDScriptCompiler::_parse_function(Error &r_error, GDScript *p_ } } + MethodInfo method_info; + codegen.function_name = func_name; + method_info.name = func_name; codegen.is_static = is_static; + if (is_static) { + method_info.flags |= METHOD_FLAG_STATIC; + } codegen.generator->write_start(p_script, func_name, is_static, rpc_config, return_type); int optional_parameters = 0; @@ -2178,10 +2184,14 @@ GDScriptFunction *GDScriptCompiler::_parse_function(Error &r_error, GDScript *p_ uint32_t par_addr = codegen.generator->add_parameter(parameter->identifier->name, parameter->initializer != nullptr, par_type); codegen.parameters[parameter->identifier->name] = GDScriptCodeGenerator::Address(GDScriptCodeGenerator::Address::FUNCTION_PARAMETER, par_addr, par_type); + method_info.arguments.push_back(parameter->get_datatype().to_property_info(parameter->identifier->name)); + if (parameter->initializer != nullptr) { optional_parameters++; } } + + method_info.default_arguments.append_array(p_func->default_arg_values); } // Parse initializer if applies. @@ -2335,20 +2345,20 @@ GDScriptFunction *GDScriptCompiler::_parse_function(Error &r_error, GDScript *p_ } if (p_func) { - // if no return statement -> return type is void not unresolved Variant + // If no `return` statement, then return type is `void`, not `Variant`. if (p_func->body->has_return) { gd_function->return_type = _gdtype_from_datatype(p_func->get_datatype(), p_script); + method_info.return_val = p_func->get_datatype().to_property_info(String()); } else { gd_function->return_type = GDScriptDataType(); gd_function->return_type.has_type = true; gd_function->return_type.kind = GDScriptDataType::BUILTIN; gd_function->return_type.builtin_type = Variant::NIL; } -#ifdef TOOLS_ENABLED - gd_function->default_arg_values = p_func->default_arg_values; -#endif } + gd_function->method_info = method_info; + if (!is_implicit_initializer && !is_implicit_ready && !p_for_lambda) { p_script->member_functions[func_name] = gd_function; } @@ -2503,7 +2513,10 @@ Error GDScriptCompiler::_parse_setter_getter(GDScript *p_script, const GDScriptP return err; } -Error GDScriptCompiler::_populate_class_members(GDScript *p_script, const GDScriptParser::ClassNode *p_class, bool p_keep_state) { +// Prepares given script, and inner class scripts, for compilation. It populates class members and initializes method +// RPC info for its base classes first, then for itself, then for inner classes. +// Warning: this function cannot initiate compilation of other classes, or it will result in cyclic dependency issues. +Error GDScriptCompiler::_prepare_compilation(GDScript *p_script, const GDScriptParser::ClassNode *p_class, bool p_keep_state) { if (parsed_classes.has(p_script)) { return OK; } @@ -2554,7 +2567,6 @@ Error GDScriptCompiler::_populate_class_members(GDScript *p_script, const GDScri p_script->member_functions.clear(); p_script->member_indices.clear(); - p_script->member_info.clear(); p_script->static_variables_indices.clear(); p_script->static_variables.clear(); p_script->_signals.clear(); @@ -2562,14 +2574,15 @@ Error GDScriptCompiler::_populate_class_members(GDScript *p_script, const GDScri p_script->implicit_initializer = nullptr; p_script->implicit_ready = nullptr; p_script->static_initializer = nullptr; + p_script->rpc_config.clear(); p_script->clearing = false; p_script->tool = parser->is_tool(); - if (!p_script->name.is_empty()) { - if (ClassDB::class_exists(p_script->name) && ClassDB::is_class_exposed(p_script->name)) { - _set_error("The class '" + p_script->name + "' shadows a native class", p_class); + if (p_script->local_name != StringName()) { + if (ClassDB::class_exists(p_script->local_name) && ClassDB::is_class_exposed(p_script->local_name)) { + _set_error(vformat(R"(The class "%s" shadows a native class)", p_script->local_name), p_class); return ERR_ALREADY_EXISTS; } } @@ -2592,7 +2605,7 @@ Error GDScriptCompiler::_populate_class_members(GDScript *p_script, const GDScri } if (main_script->has_class(base.ptr())) { - Error err = _populate_class_members(base.ptr(), p_class->base_type.class_type, p_keep_state); + Error err = _prepare_compilation(base.ptr(), p_class->base_type.class_type, p_keep_state); if (err) { return err; } @@ -2611,7 +2624,7 @@ Error GDScriptCompiler::_populate_class_members(GDScript *p_script, const GDScri return ERR_COMPILATION_FAILED; } - err = _populate_class_members(base.ptr(), p_class->base_type.class_type, p_keep_state); + err = _prepare_compilation(base.ptr(), p_class->base_type.class_type, p_keep_state); if (err) { _set_error(vformat(R"(Could not populate class members of base class "%s" in "%s".)", base->fully_qualified_name, base->path), nullptr); return err; @@ -2628,6 +2641,12 @@ Error GDScriptCompiler::_populate_class_members(GDScript *p_script, const GDScri } break; } + // Duplicate RPC information from base GDScript + // Base script isn't valid because it should not have been compiled yet, but the reference contains relevant info. + if (base_type.kind == GDScriptDataType::GDSCRIPT && p_script->base.is_valid()) { + p_script->rpc_config = p_script->base->rpc_config.duplicate(); + } + for (int i = 0; i < p_class->members.size(); i++) { const GDScriptParser::ClassNode::Member &member = p_class->members[i]; switch (member.type) { @@ -2636,7 +2655,6 @@ Error GDScriptCompiler::_populate_class_members(GDScript *p_script, const GDScri StringName name = variable->identifier->name; GDScript::MemberInfo minfo; - minfo.index = p_script->member_indices.size(); switch (variable->property) { case GDScriptParser::VariableNode::PROP_NONE: break; // Nothing to do. @@ -2659,8 +2677,7 @@ Error GDScriptCompiler::_populate_class_members(GDScript *p_script, const GDScri } minfo.data_type = _gdtype_from_datatype(variable->get_datatype(), p_script); - PropertyInfo prop_info = minfo.data_type; - prop_info.name = name; + PropertyInfo prop_info = variable->get_datatype().to_property_info(name); PropertyInfo export_info = variable->export_info; if (variable->exported) { @@ -2670,16 +2687,16 @@ Error GDScriptCompiler::_populate_class_members(GDScript *p_script, const GDScri } prop_info.hint = export_info.hint; prop_info.hint_string = export_info.hint_string; - prop_info.usage = export_info.usage | PROPERTY_USAGE_SCRIPT_VARIABLE; - } else { - prop_info.usage = PROPERTY_USAGE_SCRIPT_VARIABLE; + prop_info.usage = export_info.usage; } + prop_info.usage |= PROPERTY_USAGE_SCRIPT_VARIABLE; + minfo.property_info = prop_info; if (variable->is_static) { minfo.index = p_script->static_variables_indices.size(); p_script->static_variables_indices[name] = minfo; } else { - p_script->member_info[name] = prop_info; + minfo.index = p_script->member_indices.size(); p_script->member_indices[name] = minfo; p_script->members.insert(name); } @@ -2712,12 +2729,7 @@ Error GDScriptCompiler::_populate_class_members(GDScript *p_script, const GDScri const GDScriptParser::SignalNode *signal = member.signal; StringName name = signal->identifier->name; - Vector<StringName> parameters_names; - parameters_names.resize(signal->parameters.size()); - for (int j = 0; j < signal->parameters.size(); j++) { - parameters_names.write[j] = signal->parameters[j]->identifier->name; - } - p_script->_signals[name] = parameters_names; + p_script->_signals[name] = signal->method_info; } break; case GDScriptParser::ClassNode::Member::ENUM: { @@ -2740,12 +2752,20 @@ Error GDScriptCompiler::_populate_class_members(GDScript *p_script, const GDScri prop_info.name = annotation->export_info.name; prop_info.usage = annotation->export_info.usage; prop_info.hint_string = annotation->export_info.hint_string; + minfo.property_info = prop_info; - p_script->member_info[name] = prop_info; p_script->member_indices[name] = minfo; p_script->members.insert(Variant()); } break; + case GDScriptParser::ClassNode::Member::FUNCTION: { + const GDScriptParser::FunctionNode *function_n = member.function; + + Variant config = function_n->rpc_config; + if (config.get_type() != Variant::NIL) { + p_script->rpc_config[function_n->identifier->name] = config; + } + } break; default: break; // Nothing to do here. } @@ -2756,7 +2776,7 @@ Error GDScriptCompiler::_populate_class_members(GDScript *p_script, const GDScri parsed_classes.insert(p_script); parsing_classes.erase(p_script); - // Populate sub-classes. + // Populate inner classes. for (int i = 0; i < p_class->members.size(); i++) { const GDScriptParser::ClassNode::Member &member = p_class->members[i]; if (member.type != member.CLASS) { @@ -2769,7 +2789,7 @@ Error GDScriptCompiler::_populate_class_members(GDScript *p_script, const GDScri // Subclass might still be parsing, just skip it if (!parsing_classes.has(subclass_ptr)) { - Error err = _populate_class_members(subclass_ptr, inner_class, p_keep_state); + Error err = _prepare_compilation(subclass_ptr, inner_class, p_keep_state); if (err) { return err; } @@ -2905,8 +2925,6 @@ Error GDScriptCompiler::_compile_class(GDScript *p_script, const GDScriptParser: has_static_data = has_static_data || inner_class->has_static_data; } - p_script->_init_rpc_methods_properties(); - p_script->valid = true; return OK; } @@ -2927,7 +2945,8 @@ void GDScriptCompiler::convert_to_initializer_type(Variant &p_variant, const GDS void GDScriptCompiler::make_scripts(GDScript *p_script, const GDScriptParser::ClassNode *p_class, bool p_keep_state) { p_script->fully_qualified_name = p_class->fqcn; - p_script->name = p_class->identifier ? p_class->identifier->name : ""; + p_script->local_name = p_class->identifier ? p_class->identifier->name : StringName(); + p_script->global_name = p_class->get_global_name(); p_script->simplified_icon_path = p_class->simplified_icon_path; HashMap<StringName, Ref<GDScript>> old_subclasses; @@ -2979,7 +2998,7 @@ Error GDScriptCompiler::compile(const GDScriptParser *p_parser, GDScript *p_scri make_scripts(p_script, root, p_keep_state); main_script->_owner = nullptr; - Error err = _populate_class_members(main_script, parser->get_tree(), p_keep_state); + Error err = _prepare_compilation(main_script, parser->get_tree(), p_keep_state); if (err) { return err; diff --git a/modules/gdscript/gdscript_compiler.h b/modules/gdscript/gdscript_compiler.h index 2f522da4ea..1882471331 100644 --- a/modules/gdscript/gdscript_compiler.h +++ b/modules/gdscript/gdscript_compiler.h @@ -135,7 +135,7 @@ class GDScriptCompiler { GDScriptFunction *_parse_function(Error &r_error, GDScript *p_script, const GDScriptParser::ClassNode *p_class, const GDScriptParser::FunctionNode *p_func, bool p_for_ready = false, bool p_for_lambda = false); GDScriptFunction *_make_static_initializer(Error &r_error, GDScript *p_script, const GDScriptParser::ClassNode *p_class); Error _parse_setter_getter(GDScript *p_script, const GDScriptParser::ClassNode *p_class, const GDScriptParser::VariableNode *p_variable, bool p_is_setter); - Error _populate_class_members(GDScript *p_script, const GDScriptParser::ClassNode *p_class, bool p_keep_state); + Error _prepare_compilation(GDScript *p_script, const GDScriptParser::ClassNode *p_class, bool p_keep_state); Error _compile_class(GDScript *p_script, const GDScriptParser::ClassNode *p_class, bool p_keep_state); int err_line = 0; int err_column = 0; diff --git a/modules/gdscript/gdscript_editor.cpp b/modules/gdscript/gdscript_editor.cpp index 6cad3b2b90..5e626f0520 100644 --- a/modules/gdscript/gdscript_editor.cpp +++ b/modules/gdscript/gdscript_editor.cpp @@ -1459,8 +1459,13 @@ static bool _guess_expression_type(GDScriptParser::CompletionContext &p_context, if (p_expression->is_constant) { // Already has a value, so just use that. r_type = _type_from_variant(p_expression->reduced_value); - if (p_expression->get_datatype().kind == GDScriptParser::DataType::ENUM) { - r_type.type = p_expression->get_datatype(); + switch (p_expression->get_datatype().kind) { + case GDScriptParser::DataType::ENUM: + case GDScriptParser::DataType::CLASS: + r_type.type = p_expression->get_datatype(); + break; + default: + break; } found = true; } else { diff --git a/modules/gdscript/gdscript_function.cpp b/modules/gdscript/gdscript_function.cpp index a6b4dc7981..4f5a65a709 100644 --- a/modules/gdscript/gdscript_function.cpp +++ b/modules/gdscript/gdscript_function.cpp @@ -32,14 +32,6 @@ #include "gdscript.h" -const int *GDScriptFunction::get_code() const { - return _code_ptr; -} - -int GDScriptFunction::get_code_size() const { - return _code_size; -} - Variant GDScriptFunction::get_constant(int p_idx) const { ERR_FAIL_INDEX_V(p_idx, constants.size(), "<errconst>"); return constants[p_idx]; @@ -50,32 +42,6 @@ StringName GDScriptFunction::get_global_name(int p_idx) const { return global_names[p_idx]; } -int GDScriptFunction::get_default_argument_count() const { - return _default_arg_count; -} - -int GDScriptFunction::get_default_argument_addr(int p_idx) const { - ERR_FAIL_INDEX_V(p_idx, default_arguments.size(), -1); - return default_arguments[p_idx]; -} - -GDScriptDataType GDScriptFunction::get_return_type() const { - return return_type; -} - -GDScriptDataType GDScriptFunction::get_argument_type(int p_idx) const { - ERR_FAIL_INDEX_V(p_idx, argument_types.size(), GDScriptDataType()); - return argument_types[p_idx]; -} - -StringName GDScriptFunction::get_name() const { - return name; -} - -int GDScriptFunction::get_max_stack_size() const { - return _stack_size; -} - struct _GDFKC { int order = 0; List<int> pos; @@ -161,9 +127,7 @@ GDScriptFunction::~GDScriptFunction() { return_type.script_type_ref = Ref<Script>(); #ifdef DEBUG_ENABLED - MutexLock lock(GDScriptLanguage::get_singleton()->mutex); - GDScriptLanguage::get_singleton()->function_list.remove(&function_list); #endif } diff --git a/modules/gdscript/gdscript_function.h b/modules/gdscript/gdscript_function.h index 5230773c13..31da70f9ae 100644 --- a/modules/gdscript/gdscript_function.h +++ b/modules/gdscript/gdscript_function.h @@ -147,33 +147,6 @@ public: return false; } - operator PropertyInfo() const { - PropertyInfo info; - info.usage = PROPERTY_USAGE_NONE; - if (has_type) { - switch (kind) { - case UNINITIALIZED: - break; - case BUILTIN: { - info.type = builtin_type; - } break; - case NATIVE: { - info.type = Variant::OBJECT; - info.class_name = native_type; - } break; - case SCRIPT: - case GDSCRIPT: { - info.type = Variant::OBJECT; - info.class_name = script_type->get_instance_base_type(); - } break; - } - } else { - info.type = Variant::NIL; - info.usage |= PROPERTY_USAGE_NIL_IS_VARIANT; - } - return info; - } - void set_container_element_type(const GDScriptDataType &p_element_type) { container_element_type = memnew(GDScriptDataType(p_element_type)); } @@ -437,59 +410,32 @@ private: friend class GDScript; friend class GDScriptCompiler; friend class GDScriptByteCodeGenerator; + friend class GDScriptLanguage; + StringName name; StringName source; + bool _static = false; + Vector<GDScriptDataType> argument_types; + GDScriptDataType return_type; + MethodInfo method_info; + Variant rpc_config; - mutable Variant nil; - mutable Variant *_constants_ptr = nullptr; - int _constant_count = 0; - const StringName *_global_names_ptr = nullptr; - int _global_names_count = 0; - const int *_default_arg_ptr = nullptr; - int _default_arg_count = 0; - int _operator_funcs_count = 0; - const Variant::ValidatedOperatorEvaluator *_operator_funcs_ptr = nullptr; - int _setters_count = 0; - const Variant::ValidatedSetter *_setters_ptr = nullptr; - int _getters_count = 0; - const Variant::ValidatedGetter *_getters_ptr = nullptr; - int _keyed_setters_count = 0; - const Variant::ValidatedKeyedSetter *_keyed_setters_ptr = nullptr; - int _keyed_getters_count = 0; - const Variant::ValidatedKeyedGetter *_keyed_getters_ptr = nullptr; - int _indexed_setters_count = 0; - const Variant::ValidatedIndexedSetter *_indexed_setters_ptr = nullptr; - int _indexed_getters_count = 0; - const Variant::ValidatedIndexedGetter *_indexed_getters_ptr = nullptr; - int _builtin_methods_count = 0; - const Variant::ValidatedBuiltInMethod *_builtin_methods_ptr = nullptr; - int _constructors_count = 0; - const Variant::ValidatedConstructor *_constructors_ptr = nullptr; - int _utilities_count = 0; - const Variant::ValidatedUtilityFunction *_utilities_ptr = nullptr; - int _gds_utilities_count = 0; - const GDScriptUtilityFunctions::FunctionPtr *_gds_utilities_ptr = nullptr; - int _methods_count = 0; - MethodBind **_methods_ptr = nullptr; - int _lambdas_count = 0; - GDScriptFunction **_lambdas_ptr = nullptr; - int *_code_ptr = nullptr; - int _code_size = 0; + GDScript *_script = nullptr; + int _initial_line = 0; int _argument_count = 0; int _stack_size = 0; int _instruction_args_size = 0; int _ptrcall_args_size = 0; - int _initial_line = 0; - bool _static = false; - Variant rpc_config; - - GDScript *_script = nullptr; + SelfList<GDScriptFunction> function_list{ this }; + mutable Variant nil; + HashMap<int, Variant::Type> temporary_slots; + List<StackDebug> stack_debug; - StringName name; + Vector<int> code; + Vector<int> default_arguments; Vector<Variant> constants; Vector<StringName> global_names; - Vector<int> default_arguments; Vector<Variant::ValidatedOperatorEvaluator> operator_funcs; Vector<Variant::ValidatedSetter> setters; Vector<Variant::ValidatedGetter> getters; @@ -503,18 +449,47 @@ private: Vector<GDScriptUtilityFunctions::FunctionPtr> gds_utilities; Vector<MethodBind *> methods; Vector<GDScriptFunction *> lambdas; - Vector<int> code; - Vector<GDScriptDataType> argument_types; - GDScriptDataType return_type; - HashMap<int, Variant::Type> temporary_slots; + int _code_size = 0; + int _default_arg_count = 0; + int _constant_count = 0; + int _global_names_count = 0; + int _operator_funcs_count = 0; + int _setters_count = 0; + int _getters_count = 0; + int _keyed_setters_count = 0; + int _keyed_getters_count = 0; + int _indexed_setters_count = 0; + int _indexed_getters_count = 0; + int _builtin_methods_count = 0; + int _constructors_count = 0; + int _utilities_count = 0; + int _gds_utilities_count = 0; + int _methods_count = 0; + int _lambdas_count = 0; -#ifdef TOOLS_ENABLED - Vector<StringName> arg_names; - Vector<Variant> default_arg_values; -#endif + int *_code_ptr = nullptr; + const int *_default_arg_ptr = nullptr; + mutable Variant *_constants_ptr = nullptr; + const StringName *_global_names_ptr = nullptr; + const Variant::ValidatedOperatorEvaluator *_operator_funcs_ptr = nullptr; + const Variant::ValidatedSetter *_setters_ptr = nullptr; + const Variant::ValidatedGetter *_getters_ptr = nullptr; + const Variant::ValidatedKeyedSetter *_keyed_setters_ptr = nullptr; + const Variant::ValidatedKeyedGetter *_keyed_getters_ptr = nullptr; + const Variant::ValidatedIndexedSetter *_indexed_setters_ptr = nullptr; + const Variant::ValidatedIndexedGetter *_indexed_getters_ptr = nullptr; + const Variant::ValidatedBuiltInMethod *_builtin_methods_ptr = nullptr; + const Variant::ValidatedConstructor *_constructors_ptr = nullptr; + const Variant::ValidatedUtilityFunction *_utilities_ptr = nullptr; + const GDScriptUtilityFunctions::FunctionPtr *_gds_utilities_ptr = nullptr; + MethodBind **_methods_ptr = nullptr; + GDScriptFunction **_lambdas_ptr = nullptr; #ifdef DEBUG_ENABLED + CharString func_cname; + const char *_func_cname = nullptr; + Vector<String> operator_names; Vector<String> setter_names; Vector<String> getter_names; @@ -522,20 +497,6 @@ private: Vector<String> constructors_names; Vector<String> utilities_names; Vector<String> gds_utilities_names; -#endif - - List<StackDebug> stack_debug; - - Variant _get_default_variant_for_data_type(const GDScriptDataType &p_data_type); - - _FORCE_INLINE_ String _get_call_error(const Callable::CallError &p_err, const String &p_where, const Variant **argptrs) const; - - friend class GDScriptLanguage; - - SelfList<GDScriptFunction> function_list{ this }; -#ifdef DEBUG_ENABLED - CharString func_cname; - const char *_func_cname = nullptr; struct Profile { StringName signature; @@ -549,9 +510,11 @@ private: uint64_t last_frame_self_time = 0; uint64_t last_frame_total_time = 0; } profile; - #endif + _FORCE_INLINE_ String _get_call_error(const Callable::CallError &p_err, const String &p_where, const Variant **argptrs) const; + Variant _get_default_variant_for_data_type(const GDScriptDataType &p_data_type); + public: static constexpr int MAX_CALL_DEPTH = 2048; // Limit to try to avoid crash because of a stack overflow. @@ -571,51 +534,24 @@ public: Variant result; }; + _FORCE_INLINE_ StringName get_name() const { return name; } + _FORCE_INLINE_ StringName get_source() const { return source; } + _FORCE_INLINE_ GDScript *get_script() const { return _script; } _FORCE_INLINE_ bool is_static() const { return _static; } + _FORCE_INLINE_ MethodInfo get_method_info() const { return method_info; } + _FORCE_INLINE_ Variant get_rpc_config() const { return rpc_config; } + _FORCE_INLINE_ int get_max_stack_size() const { return _stack_size; } - const int *get_code() const; //used for debug - int get_code_size() const; Variant get_constant(int p_idx) const; StringName get_global_name(int p_idx) const; - StringName get_name() const; - int get_max_stack_size() const; - int get_default_argument_count() const; - int get_default_argument_addr(int p_idx) const; - GDScriptDataType get_return_type() const; - GDScriptDataType get_argument_type(int p_idx) const; - GDScript *get_script() const { return _script; } - StringName get_source() const { return source; } - - void debug_get_stack_member_state(int p_line, List<Pair<StringName, int>> *r_stackvars) const; - - _FORCE_INLINE_ bool is_empty() const { return _code_size == 0; } - - int get_argument_count() const { return _argument_count; } - StringName get_argument_name(int p_idx) const { -#ifdef TOOLS_ENABLED - ERR_FAIL_INDEX_V(p_idx, arg_names.size(), StringName()); - return arg_names[p_idx]; -#else - return StringName(); -#endif - } - Variant get_default_argument(int p_idx) const { - ERR_FAIL_INDEX_V(p_idx, default_arguments.size(), Variant()); - return default_arguments[p_idx]; - } -#ifdef TOOLS_ENABLED - const Vector<Variant> &get_default_arg_values() const { - return default_arg_values; - } -#endif // TOOLS_ENABLED Variant call(GDScriptInstance *p_instance, const Variant **p_args, int p_argcount, Callable::CallError &r_err, CallState *p_state = nullptr); + void debug_get_stack_member_state(int p_line, List<Pair<StringName, int>> *r_stackvars) const; #ifdef DEBUG_ENABLED void disassemble(const Vector<String> &p_code_lines) const; #endif - _FORCE_INLINE_ const Variant get_rpc_config() const { return rpc_config; } GDScriptFunction(); ~GDScriptFunction(); }; diff --git a/modules/gdscript/gdscript_parser.cpp b/modules/gdscript/gdscript_parser.cpp index a0d02b12b5..52c1a5b141 100644 --- a/modules/gdscript/gdscript_parser.cpp +++ b/modules/gdscript/gdscript_parser.cpp @@ -4112,6 +4112,8 @@ bool GDScriptParser::export_annotations(const AnnotationNode *p_annotation, Node } variable->export_info.hint_string = enum_hint_string; + variable->export_info.usage |= PROPERTY_USAGE_CLASS_IS_ENUM; + variable->export_info.class_name = String(export_type.native_type).replace("::", "."); } break; default: push_error(R"(Export type can only be built-in, a resource, a node, or an enum.)", variable); @@ -4370,6 +4372,104 @@ String GDScriptParser::DataType::to_string() const { ERR_FAIL_V_MSG("<unresolved type>", "Kind set outside the enum range."); } +PropertyInfo GDScriptParser::DataType::to_property_info(const String &p_name) const { + PropertyInfo result; + result.name = p_name; + result.usage = PROPERTY_USAGE_NONE; + + if (!is_hard_type()) { + result.usage |= PROPERTY_USAGE_NIL_IS_VARIANT; + return result; + } + + switch (kind) { + case BUILTIN: + result.type = builtin_type; + if (builtin_type == Variant::ARRAY && has_container_element_type()) { + const DataType *elem_type = container_element_type; + switch (elem_type->kind) { + case BUILTIN: + result.hint = PROPERTY_HINT_ARRAY_TYPE; + result.hint_string = Variant::get_type_name(elem_type->builtin_type); + break; + case NATIVE: + result.hint = PROPERTY_HINT_ARRAY_TYPE; + result.hint_string = elem_type->native_type; + break; + case SCRIPT: + result.hint = PROPERTY_HINT_ARRAY_TYPE; + if (elem_type->script_type.is_valid() && elem_type->script_type->get_global_name() != StringName()) { + result.hint_string = elem_type->script_type->get_global_name(); + } else { + result.hint_string = elem_type->native_type; + } + break; + case CLASS: + result.hint = PROPERTY_HINT_ARRAY_TYPE; + if (elem_type->class_type != nullptr && elem_type->class_type->get_global_name() != StringName()) { + result.hint_string = elem_type->class_type->get_global_name(); + } else { + result.hint_string = elem_type->native_type; + } + break; + case ENUM: + result.hint = PROPERTY_HINT_ARRAY_TYPE; + result.hint_string = String(elem_type->native_type).replace("::", "."); + break; + case VARIANT: + case RESOLVING: + case UNRESOLVED: + break; + } + } + break; + case NATIVE: + result.type = Variant::OBJECT; + if (is_meta_type) { + result.class_name = GDScriptNativeClass::get_class_static(); + } else { + result.class_name = native_type; + } + break; + case SCRIPT: + result.type = Variant::OBJECT; + if (is_meta_type) { + result.class_name = script_type.is_valid() ? script_type->get_class() : Script::get_class_static(); + } else if (script_type.is_valid() && script_type->get_global_name() != StringName()) { + result.class_name = script_type->get_global_name(); + } else { + result.class_name = native_type; + } + break; + case CLASS: + result.type = Variant::OBJECT; + if (is_meta_type) { + result.class_name = GDScript::get_class_static(); + } else if (class_type != nullptr && class_type->get_global_name() != StringName()) { + result.class_name = class_type->get_global_name(); + } else { + result.class_name = native_type; + } + break; + case ENUM: + if (is_meta_type) { + result.type = Variant::DICTIONARY; + } else { + result.type = Variant::INT; + result.usage |= PROPERTY_USAGE_CLASS_IS_ENUM; + result.class_name = String(native_type).replace("::", "."); + } + break; + case VARIANT: + case RESOLVING: + case UNRESOLVED: + result.usage |= PROPERTY_USAGE_NIL_IS_VARIANT; + break; + } + + return result; +} + static Variant::Type _variant_type_to_typed_array_element_type(Variant::Type p_type) { switch (p_type) { case Variant::PACKED_BYTE_ARRAY: diff --git a/modules/gdscript/gdscript_parser.h b/modules/gdscript/gdscript_parser.h index 9690784cba..27d4d0fb47 100644 --- a/modules/gdscript/gdscript_parser.h +++ b/modules/gdscript/gdscript_parser.h @@ -147,7 +147,9 @@ public: _FORCE_INLINE_ bool has_no_type() const { return type_source == UNDETECTED; } _FORCE_INLINE_ bool is_variant() const { return kind == VARIANT || kind == RESOLVING || kind == UNRESOLVED; } _FORCE_INLINE_ bool is_hard_type() const { return type_source > INFERRED; } + String to_string() const; + PropertyInfo to_property_info(const String &p_name) const; _FORCE_INLINE_ void set_container_element_type(const DataType &p_type) { container_element_type = memnew(DataType(p_type)); @@ -749,6 +751,10 @@ public: bool resolved_interface = false; bool resolved_body = false; + StringName get_global_name() const { + return (outer == nullptr && identifier != nullptr) ? identifier->name : StringName(); + } + Member get_member(const StringName &p_name) const { return members[members_indices[p_name]]; } @@ -836,8 +842,8 @@ public: Variant rpc_config; MethodInfo info; LambdaNode *source_lambda = nullptr; -#ifdef TOOLS_ENABLED Vector<Variant> default_arg_values; +#ifdef TOOLS_ENABLED MemberDocData doc_data; #endif // TOOLS_ENABLED @@ -1026,6 +1032,7 @@ public: IdentifierNode *identifier = nullptr; Vector<ParameterNode *> parameters; HashMap<StringName, int> parameters_indices; + MethodInfo method_info; #ifdef TOOLS_ENABLED MemberDocData doc_data; #endif // TOOLS_ENABLED diff --git a/modules/gdscript/gdscript_utility_functions.cpp b/modules/gdscript/gdscript_utility_functions.cpp index 030950267d..39cf9d79c8 100644 --- a/modules/gdscript/gdscript_utility_functions.cpp +++ b/modules/gdscript/gdscript_utility_functions.cpp @@ -85,6 +85,7 @@ #endif struct GDScriptUtilityFunctionsDefinitions { +#ifndef DISABLE_DEPRECATED static inline void convert(Variant *r_ret, const Variant **p_args, int p_arg_count, Callable::CallError &r_error) { VALIDATE_ARG_COUNT(2); VALIDATE_ARG_INT(1); @@ -100,6 +101,7 @@ struct GDScriptUtilityFunctionsDefinitions { Variant::construct(Variant::Type(type), *r_ret, p_args, 1, r_error); } } +#endif // DISABLE_DEPRECATED static inline void type_exists(Variant *r_ret, const Variant **p_args, int p_arg_count, Callable::CallError &r_error) { VALIDATE_ARG_COUNT(1); @@ -277,7 +279,7 @@ struct GDScriptUtilityFunctionsDefinitions { Vector<StringName> sname; while (p->_owner) { - sname.push_back(p->name); + sname.push_back(p->local_name); p = p->_owner; } sname.reverse(); @@ -703,7 +705,9 @@ static void _register_function(const String &p_name, const MethodInfo &p_method_ PropertyInfo(Variant::NIL, m_name, PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_NIL_IS_VARIANT) void GDScriptUtilityFunctions::register_functions() { +#ifndef DISABLE_DEPRECATED REGISTER_VARIANT_FUNC(convert, true, VARARG("what"), ARG("type", Variant::INT)); +#endif // DISABLE_DEPRECATED REGISTER_FUNC(type_exists, true, Variant::BOOL, ARG("type", Variant::STRING_NAME)); REGISTER_FUNC(_char, true, Variant::STRING, ARG("char", Variant::INT)); REGISTER_VARARG_FUNC(range, false, Variant::ARRAY); diff --git a/modules/gdscript/gdscript_vm.cpp b/modules/gdscript/gdscript_vm.cpp index 1ddd54b323..a7dc0b6d59 100644 --- a/modules/gdscript/gdscript_vm.cpp +++ b/modules/gdscript/gdscript_vm.cpp @@ -466,8 +466,8 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a err_file = "<built-in>"; } String err_func = name; - if (p_instance && ObjectDB::get_instance(p_instance->owner_id) != nullptr && p_instance->script->is_valid() && !p_instance->script->name.is_empty()) { - err_func = p_instance->script->name + "." + err_func; + if (p_instance && ObjectDB::get_instance(p_instance->owner_id) != nullptr && p_instance->script->is_valid() && p_instance->script->local_name != StringName()) { + err_func = p_instance->script->local_name.operator String() + "." + err_func; } int err_line = _initial_line; const char *err_text = "Stack overflow. Check for infinite recursion in your script."; @@ -3649,8 +3649,8 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a err_file = "<built-in>"; } String err_func = name; - if (instance_valid_with_script && !p_instance->script->name.is_empty()) { - err_func = p_instance->script->name + "." + err_func; + if (instance_valid_with_script && p_instance->script->local_name != StringName()) { + err_func = p_instance->script->local_name.operator String() + "." + err_func; } int err_line = line; if (err_text.is_empty()) { diff --git a/modules/gdscript/gdscript_warning.cpp b/modules/gdscript/gdscript_warning.cpp index 4fec445995..fcc6ea34de 100644 --- a/modules/gdscript/gdscript_warning.cpp +++ b/modules/gdscript/gdscript_warning.cpp @@ -88,6 +88,12 @@ String GDScriptWarning::get_message() const { case FUNCTION_USED_AS_PROPERTY: CHECK_SYMBOLS(2); return vformat(R"(The property "%s" was not found in base "%s" but there's a method with the same name. Did you mean to call it?)", symbols[0], symbols[1]); + case UNTYPED_DECLARATION: + CHECK_SYMBOLS(2); + if (symbols[0] == "Function") { + return vformat(R"*(%s "%s()" has no static return type.)*", symbols[0], symbols[1]); + } + return vformat(R"(%s "%s" has no static type.)", symbols[0], symbols[1]); case UNSAFE_PROPERTY_ACCESS: CHECK_SYMBOLS(2); return vformat(R"(The property "%s" is not present on the inferred type "%s" (but may be present on a subtype).)", symbols[0], symbols[1]); @@ -208,6 +214,7 @@ String GDScriptWarning::get_name_from_code(Code p_code) { "PROPERTY_USED_AS_FUNCTION", "CONSTANT_USED_AS_FUNCTION", "FUNCTION_USED_AS_PROPERTY", + "UNTYPED_DECLARATION", "UNSAFE_PROPERTY_ACCESS", "UNSAFE_METHOD_ACCESS", "UNSAFE_CAST", diff --git a/modules/gdscript/gdscript_warning.h b/modules/gdscript/gdscript_warning.h index 73e12eb20e..a26cfaf72c 100644 --- a/modules/gdscript/gdscript_warning.h +++ b/modules/gdscript/gdscript_warning.h @@ -64,6 +64,7 @@ public: PROPERTY_USED_AS_FUNCTION, // Function not found, but there's a property with the same name. CONSTANT_USED_AS_FUNCTION, // Function not found, but there's a constant with the same name. FUNCTION_USED_AS_PROPERTY, // Property not found, but there's a function with the same name. + UNTYPED_DECLARATION, // Variable/parameter/function has no static type, explicitly specified or inferred (`:=`). UNSAFE_PROPERTY_ACCESS, // Property not found in the detected type (but can be in subtypes). UNSAFE_METHOD_ACCESS, // Function not found in the detected type (but can be in subtypes). UNSAFE_CAST, // Cast used in an unknown type. @@ -112,6 +113,7 @@ public: WARN, // PROPERTY_USED_AS_FUNCTION WARN, // CONSTANT_USED_AS_FUNCTION WARN, // FUNCTION_USED_AS_PROPERTY + IGNORE, // UNTYPED_DECLARATION // Static typing is optional, we don't want to spam warnings. IGNORE, // UNSAFE_PROPERTY_ACCESS // Too common in untyped scenarios. IGNORE, // UNSAFE_METHOD_ACCESS // Too common in untyped scenarios. IGNORE, // UNSAFE_CAST // Too common in untyped scenarios. diff --git a/modules/gdscript/language_server/gdscript_extend_parser.cpp b/modules/gdscript/language_server/gdscript_extend_parser.cpp index 3a5a54e275..362f253a99 100644 --- a/modules/gdscript/language_server/gdscript_extend_parser.cpp +++ b/modules/gdscript/language_server/gdscript_extend_parser.cpp @@ -32,9 +32,94 @@ #include "../gdscript.h" #include "../gdscript_analyzer.h" +#include "editor/editor_settings.h" #include "gdscript_language_protocol.h" #include "gdscript_workspace.h" +int get_indent_size() { + if (EditorSettings::get_singleton()) { + return EditorSettings::get_singleton()->get_setting("text_editor/behavior/indent/size"); + } else { + return 4; + } +} + +lsp::Position GodotPosition::to_lsp(const Vector<String> &p_lines) const { + lsp::Position res; + + // Special case: `line = 0` -> root class (range covers everything). + if (this->line <= 0) { + return res; + } + // Special case: `line = p_lines.size() + 1` -> root class (range covers everything). + if (this->line >= p_lines.size() + 1) { + res.line = p_lines.size(); + return res; + } + res.line = this->line - 1; + // Note: character outside of `pos_line.length()-1` is valid. + res.character = this->column - 1; + + String pos_line = p_lines[res.line]; + if (pos_line.contains("\t")) { + int tab_size = get_indent_size(); + + int in_col = 1; + int res_char = 0; + + while (res_char < pos_line.size() && in_col < this->column) { + if (pos_line[res_char] == '\t') { + in_col += tab_size; + res_char++; + } else { + in_col++; + res_char++; + } + } + + res.character = res_char; + } + + return res; +} + +GodotPosition GodotPosition::from_lsp(const lsp::Position p_pos, const Vector<String> &p_lines) { + GodotPosition res(p_pos.line + 1, p_pos.character + 1); + + // Line outside of actual text is valid (-> pos/cursor at end of text). + if (res.line > p_lines.size()) { + return res; + } + + String line = p_lines[p_pos.line]; + int tabs_before_char = 0; + for (int i = 0; i < p_pos.character && i < line.length(); i++) { + if (line[i] == '\t') { + tabs_before_char++; + } + } + + if (tabs_before_char > 0) { + int tab_size = get_indent_size(); + res.column += tabs_before_char * (tab_size - 1); + } + + return res; +} + +lsp::Range GodotRange::to_lsp(const Vector<String> &p_lines) const { + lsp::Range res; + res.start = start.to_lsp(p_lines); + res.end = end.to_lsp(p_lines); + return res; +} + +GodotRange GodotRange::from_lsp(const lsp::Range &p_range, const Vector<String> &p_lines) { + GodotPosition start = GodotPosition::from_lsp(p_range.start, p_lines); + GodotPosition end = GodotPosition::from_lsp(p_range.end, p_lines); + return GodotRange(start, end); +} + void ExtendGDScriptParser::update_diagnostics() { diagnostics.clear(); @@ -90,7 +175,7 @@ void ExtendGDScriptParser::update_symbols() { const lsp::DocumentSymbol &symbol = class_symbol.children[i]; members.insert(symbol.name, &symbol); - // cache level one inner classes + // Cache level one inner classes. if (symbol.kind == lsp::SymbolKind::Class) { ClassMembers inner_class; for (int j = 0; j < symbol.children.size(); j++) { @@ -126,10 +211,7 @@ void ExtendGDScriptParser::update_document_links(const String &p_code) { String value = const_val; lsp::DocumentLink link; link.target = GDScriptLanguageProtocol::get_singleton()->get_workspace()->get_file_uri(scr_path); - link.range.start.line = LINE_NUMBER_TO_INDEX(token.start_line); - link.range.end.line = LINE_NUMBER_TO_INDEX(token.end_line); - link.range.start.character = LINE_NUMBER_TO_INDEX(token.start_column); - link.range.end.character = LINE_NUMBER_TO_INDEX(token.end_column); + link.range = GodotRange(GodotPosition(token.start_line, token.start_column), GodotPosition(token.end_line, token.end_column)).to_lsp(this->lines); document_links.push_back(link); } } @@ -137,6 +219,12 @@ void ExtendGDScriptParser::update_document_links(const String &p_code) { } } +lsp::Range ExtendGDScriptParser::range_of_node(const GDScriptParser::Node *p_node) const { + GodotPosition start(p_node->start_line, p_node->start_column); + GodotPosition end(p_node->end_line, p_node->end_column); + return GodotRange(start, end).to_lsp(this->lines); +} + void ExtendGDScriptParser::parse_class_symbol(const GDScriptParser::ClassNode *p_class, lsp::DocumentSymbol &r_symbol) { const String uri = get_uri(); @@ -149,13 +237,30 @@ void ExtendGDScriptParser::parse_class_symbol(const GDScriptParser::ClassNode *p } r_symbol.kind = lsp::SymbolKind::Class; r_symbol.deprecated = false; - r_symbol.range.start.line = p_class->start_line; - r_symbol.range.start.character = p_class->start_column; - r_symbol.range.end.line = lines.size(); - r_symbol.selectionRange.start.line = r_symbol.range.start.line; + r_symbol.range = range_of_node(p_class); + r_symbol.range.start.line = MAX(r_symbol.range.start.line, 0); + if (p_class->identifier) { + r_symbol.selectionRange = range_of_node(p_class->identifier); + } r_symbol.detail = "class " + r_symbol.name; - bool is_root_class = &r_symbol == &class_symbol; - r_symbol.documentation = parse_documentation(is_root_class ? 0 : LINE_NUMBER_TO_INDEX(p_class->start_line), is_root_class); + { + String doc = p_class->doc_data.description; + if (!p_class->doc_data.description.is_empty()) { + doc += "\n\n" + p_class->doc_data.description; + } + + if (!p_class->doc_data.tutorials.is_empty()) { + doc += "\n"; + for (const Pair<String, String> &tutorial : p_class->doc_data.tutorials) { + if (tutorial.first.is_empty()) { + doc += vformat("\n@tutorial: %s", tutorial.second); + } else { + doc += vformat("\n@tutorial(%s): %s", tutorial.first, tutorial.second); + } + } + } + r_symbol.documentation = doc; + } for (int i = 0; i < p_class->members.size(); i++) { const ClassNode::Member &m = p_class->members[i]; @@ -166,11 +271,8 @@ void ExtendGDScriptParser::parse_class_symbol(const GDScriptParser::ClassNode *p symbol.name = m.variable->identifier->name; symbol.kind = m.variable->property == VariableNode::PROP_NONE ? lsp::SymbolKind::Variable : lsp::SymbolKind::Property; symbol.deprecated = false; - symbol.range.start.line = LINE_NUMBER_TO_INDEX(m.variable->start_line); - symbol.range.start.character = LINE_NUMBER_TO_INDEX(m.variable->start_column); - symbol.range.end.line = LINE_NUMBER_TO_INDEX(m.variable->end_line); - symbol.range.end.character = LINE_NUMBER_TO_INDEX(m.variable->end_column); - symbol.selectionRange.start.line = symbol.range.start.line; + symbol.range = range_of_node(m.variable); + symbol.selectionRange = range_of_node(m.variable->identifier); if (m.variable->exported) { symbol.detail += "@export "; } @@ -182,10 +284,31 @@ void ExtendGDScriptParser::parse_class_symbol(const GDScriptParser::ClassNode *p symbol.detail += " = " + m.variable->initializer->reduced_value.to_json_string(); } - symbol.documentation = parse_documentation(LINE_NUMBER_TO_INDEX(m.variable->start_line)); + symbol.documentation = m.variable->doc_data.description; symbol.uri = uri; symbol.script_path = path; + if (m.variable->initializer && m.variable->initializer->type == GDScriptParser::Node::LAMBDA) { + GDScriptParser::LambdaNode *lambda_node = (GDScriptParser::LambdaNode *)m.variable->initializer; + lsp::DocumentSymbol lambda; + parse_function_symbol(lambda_node->function, lambda); + // Merge lambda into current variable. + symbol.children.append_array(lambda.children); + } + + if (m.variable->getter && m.variable->getter->type == GDScriptParser::Node::FUNCTION) { + lsp::DocumentSymbol get_symbol; + parse_function_symbol(m.variable->getter, get_symbol); + get_symbol.local = true; + symbol.children.push_back(get_symbol); + } + if (m.variable->setter && m.variable->setter->type == GDScriptParser::Node::FUNCTION) { + lsp::DocumentSymbol set_symbol; + parse_function_symbol(m.variable->setter, set_symbol); + set_symbol.local = true; + symbol.children.push_back(set_symbol); + } + r_symbol.children.push_back(symbol); } break; case ClassNode::Member::CONSTANT: { @@ -194,12 +317,9 @@ void ExtendGDScriptParser::parse_class_symbol(const GDScriptParser::ClassNode *p symbol.name = m.constant->identifier->name; symbol.kind = lsp::SymbolKind::Constant; symbol.deprecated = false; - symbol.range.start.line = LINE_NUMBER_TO_INDEX(m.constant->start_line); - symbol.range.start.character = LINE_NUMBER_TO_INDEX(m.constant->start_column); - symbol.range.end.line = LINE_NUMBER_TO_INDEX(m.constant->end_line); - symbol.range.end.character = LINE_NUMBER_TO_INDEX(m.constant->start_column); - symbol.selectionRange.start.line = LINE_NUMBER_TO_INDEX(m.constant->start_line); - symbol.documentation = parse_documentation(LINE_NUMBER_TO_INDEX(m.constant->start_line)); + symbol.range = range_of_node(m.constant); + symbol.selectionRange = range_of_node(m.constant->identifier); + symbol.documentation = m.constant->doc_data.description; symbol.uri = uri; symbol.script_path = path; @@ -231,36 +351,14 @@ void ExtendGDScriptParser::parse_class_symbol(const GDScriptParser::ClassNode *p r_symbol.children.push_back(symbol); } break; - case ClassNode::Member::ENUM_VALUE: { - lsp::DocumentSymbol symbol; - - symbol.name = m.enum_value.identifier->name; - symbol.kind = lsp::SymbolKind::EnumMember; - symbol.deprecated = false; - symbol.range.start.line = LINE_NUMBER_TO_INDEX(m.enum_value.line); - symbol.range.start.character = LINE_NUMBER_TO_INDEX(m.enum_value.leftmost_column); - symbol.range.end.line = LINE_NUMBER_TO_INDEX(m.enum_value.line); - symbol.range.end.character = LINE_NUMBER_TO_INDEX(m.enum_value.rightmost_column); - symbol.selectionRange.start.line = LINE_NUMBER_TO_INDEX(m.enum_value.line); - symbol.documentation = parse_documentation(LINE_NUMBER_TO_INDEX(m.enum_value.line)); - symbol.uri = uri; - symbol.script_path = path; - - symbol.detail = symbol.name + " = " + itos(m.enum_value.value); - - r_symbol.children.push_back(symbol); - } break; case ClassNode::Member::SIGNAL: { lsp::DocumentSymbol symbol; symbol.name = m.signal->identifier->name; symbol.kind = lsp::SymbolKind::Event; symbol.deprecated = false; - symbol.range.start.line = LINE_NUMBER_TO_INDEX(m.signal->start_line); - symbol.range.start.character = LINE_NUMBER_TO_INDEX(m.signal->start_column); - symbol.range.end.line = LINE_NUMBER_TO_INDEX(m.signal->end_line); - symbol.range.end.character = LINE_NUMBER_TO_INDEX(m.signal->end_column); - symbol.selectionRange.start.line = symbol.range.start.line; - symbol.documentation = parse_documentation(LINE_NUMBER_TO_INDEX(m.signal->start_line)); + symbol.range = range_of_node(m.signal); + symbol.selectionRange = range_of_node(m.signal->identifier); + symbol.documentation = m.signal->doc_data.description; symbol.uri = uri; symbol.script_path = path; symbol.detail = "signal " + String(m.signal->identifier->name) + "("; @@ -272,17 +370,48 @@ void ExtendGDScriptParser::parse_class_symbol(const GDScriptParser::ClassNode *p } symbol.detail += ")"; + for (GDScriptParser::ParameterNode *param : m.signal->parameters) { + lsp::DocumentSymbol param_symbol; + param_symbol.name = param->identifier->name; + param_symbol.kind = lsp::SymbolKind::Variable; + param_symbol.deprecated = false; + param_symbol.local = true; + param_symbol.range = range_of_node(param); + param_symbol.selectionRange = range_of_node(param->identifier); + param_symbol.uri = uri; + param_symbol.script_path = path; + param_symbol.detail = "var " + param_symbol.name; + if (param->get_datatype().is_hard_type()) { + param_symbol.detail += ": " + param->get_datatype().to_string(); + } + symbol.children.push_back(param_symbol); + } + r_symbol.children.push_back(symbol); + } break; + case ClassNode::Member::ENUM_VALUE: { + lsp::DocumentSymbol symbol; + + symbol.name = m.enum_value.identifier->name; + symbol.kind = lsp::SymbolKind::EnumMember; + symbol.deprecated = false; + symbol.range.start = GodotPosition(m.enum_value.line, m.enum_value.leftmost_column).to_lsp(this->lines); + symbol.range.end = GodotPosition(m.enum_value.line, m.enum_value.rightmost_column).to_lsp(this->lines); + symbol.selectionRange = range_of_node(m.enum_value.identifier); + symbol.documentation = m.enum_value.doc_data.description; + symbol.uri = uri; + symbol.script_path = path; + + symbol.detail = symbol.name + " = " + itos(m.enum_value.value); + r_symbol.children.push_back(symbol); } break; case ClassNode::Member::ENUM: { lsp::DocumentSymbol symbol; + symbol.name = m.m_enum->identifier->name; symbol.kind = lsp::SymbolKind::Enum; - symbol.range.start.line = LINE_NUMBER_TO_INDEX(m.m_enum->start_line); - symbol.range.start.character = LINE_NUMBER_TO_INDEX(m.m_enum->start_column); - symbol.range.end.line = LINE_NUMBER_TO_INDEX(m.m_enum->end_line); - symbol.range.end.character = LINE_NUMBER_TO_INDEX(m.m_enum->end_column); - symbol.selectionRange.start.line = symbol.range.start.line; - symbol.documentation = parse_documentation(LINE_NUMBER_TO_INDEX(m.m_enum->start_line)); + symbol.range = range_of_node(m.m_enum); + symbol.selectionRange = range_of_node(m.m_enum->identifier); + symbol.documentation = m.m_enum->doc_data.description; symbol.uri = uri; symbol.script_path = path; @@ -294,6 +423,25 @@ void ExtendGDScriptParser::parse_class_symbol(const GDScriptParser::ClassNode *p symbol.detail += String(m.m_enum->values[j].identifier->name) + " = " + itos(m.m_enum->values[j].value); } symbol.detail += "}"; + + for (GDScriptParser::EnumNode::Value value : m.m_enum->values) { + lsp::DocumentSymbol child; + + child.name = value.identifier->name; + child.kind = lsp::SymbolKind::EnumMember; + child.deprecated = false; + child.range.start = GodotPosition(value.line, value.leftmost_column).to_lsp(this->lines); + child.range.end = GodotPosition(value.line, value.rightmost_column).to_lsp(this->lines); + child.selectionRange = range_of_node(value.identifier); + child.documentation = value.doc_data.description; + child.uri = uri; + child.script_path = path; + + child.detail = child.name + " = " + itos(value.value); + + symbol.children.push_back(child); + } + r_symbol.children.push_back(symbol); } break; case ClassNode::Member::FUNCTION: { @@ -317,32 +465,29 @@ void ExtendGDScriptParser::parse_class_symbol(const GDScriptParser::ClassNode *p void ExtendGDScriptParser::parse_function_symbol(const GDScriptParser::FunctionNode *p_func, lsp::DocumentSymbol &r_symbol) { const String uri = get_uri(); - r_symbol.name = p_func->identifier->name; - r_symbol.kind = p_func->is_static ? lsp::SymbolKind::Function : lsp::SymbolKind::Method; - r_symbol.detail = "func " + String(p_func->identifier->name) + "("; + bool is_named = p_func->identifier != nullptr; + + r_symbol.name = is_named ? p_func->identifier->name : ""; + r_symbol.kind = (p_func->is_static || p_func->source_lambda != nullptr) ? lsp::SymbolKind::Function : lsp::SymbolKind::Method; + r_symbol.detail = "func"; + if (is_named) { + r_symbol.detail += " " + String(p_func->identifier->name); + } + r_symbol.detail += "("; r_symbol.deprecated = false; - r_symbol.range.start.line = LINE_NUMBER_TO_INDEX(p_func->start_line); - r_symbol.range.start.character = LINE_NUMBER_TO_INDEX(p_func->start_column); - r_symbol.range.end.line = LINE_NUMBER_TO_INDEX(p_func->start_line); - r_symbol.range.end.character = LINE_NUMBER_TO_INDEX(p_func->end_column); - r_symbol.selectionRange.start.line = r_symbol.range.start.line; - r_symbol.documentation = parse_documentation(LINE_NUMBER_TO_INDEX(p_func->start_line)); + r_symbol.range = range_of_node(p_func); + if (is_named) { + r_symbol.selectionRange = range_of_node(p_func->identifier); + } else { + r_symbol.selectionRange.start = r_symbol.selectionRange.end = r_symbol.range.start; + } + r_symbol.documentation = p_func->doc_data.description; r_symbol.uri = uri; r_symbol.script_path = path; String parameters; for (int i = 0; i < p_func->parameters.size(); i++) { const ParameterNode *parameter = p_func->parameters[i]; - lsp::DocumentSymbol symbol; - symbol.kind = lsp::SymbolKind::Variable; - symbol.name = parameter->identifier->name; - symbol.range.start.line = LINE_NUMBER_TO_INDEX(parameter->start_line); - symbol.range.start.character = LINE_NUMBER_TO_INDEX(parameter->start_column); - symbol.range.end.line = LINE_NUMBER_TO_INDEX(parameter->end_line); - symbol.range.end.character = LINE_NUMBER_TO_INDEX(parameter->end_column); - symbol.uri = uri; - symbol.script_path = path; - r_symbol.children.push_back(symbol); if (i > 0) { parameters += ", "; } @@ -387,6 +532,13 @@ void ExtendGDScriptParser::parse_function_symbol(const GDScriptParser::FunctionN node_stack.push_back(while_node->loop); } break; + case GDScriptParser::TypeNode::MATCH: { + GDScriptParser::MatchNode *match_node = (GDScriptParser::MatchNode *)node; + for (GDScriptParser::MatchBranchNode *branch_node : match_node->branches) { + node_stack.push_back(branch_node); + } + } break; + case GDScriptParser::TypeNode::MATCH_BRANCH: { GDScriptParser::MatchBranchNode *match_node = (GDScriptParser::MatchBranchNode *)node; node_stack.push_back(match_node->block); @@ -400,20 +552,6 @@ void ExtendGDScriptParser::parse_function_symbol(const GDScriptParser::FunctionN } } break; - case GDScriptParser::TypeNode::VARIABLE: { - GDScriptParser::VariableNode *variable_node = (GDScriptParser::VariableNode *)(node); - lsp::DocumentSymbol symbol; - symbol.kind = lsp::SymbolKind::Variable; - symbol.name = variable_node->identifier->name; - symbol.range.start.line = LINE_NUMBER_TO_INDEX(variable_node->start_line); - symbol.range.start.character = LINE_NUMBER_TO_INDEX(variable_node->start_column); - symbol.range.end.line = LINE_NUMBER_TO_INDEX(variable_node->end_line); - symbol.range.end.character = LINE_NUMBER_TO_INDEX(variable_node->end_column); - symbol.uri = uri; - symbol.script_path = path; - r_symbol.children.push_back(symbol); - } break; - default: continue; } @@ -426,10 +564,40 @@ void ExtendGDScriptParser::parse_function_symbol(const GDScriptParser::FunctionN lsp::DocumentSymbol symbol; symbol.name = local.name; symbol.kind = local.type == SuiteNode::Local::CONSTANT ? lsp::SymbolKind::Constant : lsp::SymbolKind::Variable; - symbol.range.start.line = LINE_NUMBER_TO_INDEX(local.start_line); - symbol.range.start.character = LINE_NUMBER_TO_INDEX(local.start_column); - symbol.range.end.line = LINE_NUMBER_TO_INDEX(local.end_line); - symbol.range.end.character = LINE_NUMBER_TO_INDEX(local.end_column); + switch (local.type) { + case SuiteNode::Local::CONSTANT: + symbol.range = range_of_node(local.constant); + symbol.selectionRange = range_of_node(local.constant->identifier); + break; + case SuiteNode::Local::VARIABLE: + symbol.range = range_of_node(local.variable); + symbol.selectionRange = range_of_node(local.variable->identifier); + if (local.variable->initializer && local.variable->initializer->type == GDScriptParser::Node::LAMBDA) { + GDScriptParser::LambdaNode *lambda_node = (GDScriptParser::LambdaNode *)local.variable->initializer; + lsp::DocumentSymbol lambda; + parse_function_symbol(lambda_node->function, lambda); + // Merge lambda into current variable. + // -> Only interested in new variables, not lambda itself. + symbol.children.append_array(lambda.children); + } + break; + case SuiteNode::Local::PARAMETER: + symbol.range = range_of_node(local.parameter); + symbol.selectionRange = range_of_node(local.parameter->identifier); + break; + case SuiteNode::Local::FOR_VARIABLE: + case SuiteNode::Local::PATTERN_BIND: + symbol.range = range_of_node(local.bind); + symbol.selectionRange = range_of_node(local.bind); + break; + default: + // Fallback. + symbol.range.start = GodotPosition(local.start_line, local.start_column).to_lsp(get_lines()); + symbol.range.end = GodotPosition(local.end_line, local.end_column).to_lsp(get_lines()); + symbol.selectionRange = symbol.range; + break; + } + symbol.local = true; symbol.uri = uri; symbol.script_path = path; symbol.detail = local.type == SuiteNode::Local::CONSTANT ? "const " : "var "; @@ -437,53 +605,19 @@ void ExtendGDScriptParser::parse_function_symbol(const GDScriptParser::FunctionN if (local.get_datatype().is_hard_type()) { symbol.detail += ": " + local.get_datatype().to_string(); } - symbol.documentation = parse_documentation(LINE_NUMBER_TO_INDEX(local.start_line)); - r_symbol.children.push_back(symbol); - } - } -} - -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(2, inline_comment.length())); + switch (local.type) { + case SuiteNode::Local::CONSTANT: + symbol.documentation = local.constant->doc_data.description; + break; + case SuiteNode::Local::VARIABLE: + symbol.documentation = local.variable->doc_data.description; + break; + default: + break; } + r_symbol.children.push_back(symbol); } } - - 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(2, 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 (const String &E : doc_lines) { - doc += E + "\n"; - } - return doc; } String ExtendGDScriptParser::get_text_for_completion(const lsp::Position &p_cursor) const { @@ -492,7 +626,7 @@ String ExtendGDScriptParser::get_text_for_completion(const lsp::Position &p_curs 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 += String::chr(0xFFFF); // Not unicode, represents the cursor. longthing += lines[i].substr(p_cursor.character, lines[i].size()); } else { longthing += lines[i]; @@ -513,7 +647,7 @@ String ExtendGDScriptParser::get_text_for_lookup_symbol(const lsp::Position &p_c 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()); + String last_part = line.substr(p_cursor.character, lines[i].length()); if (!p_symbol.is_empty()) { String left_cursor_text; for (int c = p_cursor.character - 1; c >= 0; c--) { @@ -527,9 +661,9 @@ String ExtendGDScriptParser::get_text_for_lookup_symbol(const lsp::Position &p_c } longthing += first_part; - longthing += String::chr(0xFFFF); //not unicode, represents the cursor + longthing += String::chr(0xFFFF); // Not unicode, represents the cursor. if (p_func_required) { - longthing += "("; // tell the parser this is a function call + longthing += "("; // Tell the parser this is a function call. } longthing += last_part; } else { @@ -544,7 +678,7 @@ String ExtendGDScriptParser::get_text_for_lookup_symbol(const lsp::Position &p_c return longthing; } -String ExtendGDScriptParser::get_identifier_under_position(const lsp::Position &p_position, Vector2i &p_offset) const { +String ExtendGDScriptParser::get_identifier_under_position(const lsp::Position &p_position, lsp::Range &r_range) const { ERR_FAIL_INDEX_V(p_position.line, lines.size(), ""); String line = lines[p_position.line]; if (line.is_empty()) { @@ -552,8 +686,32 @@ String ExtendGDScriptParser::get_identifier_under_position(const lsp::Position & } ERR_FAIL_INDEX_V(p_position.character, line.size(), ""); - int start_pos = p_position.character; - for (int c = p_position.character; c >= 0; c--) { + // `p_position` cursor is BETWEEN chars, not ON chars. + // -> + // ```gdscript + // var member| := some_func|(some_variable|) + // ^ ^ ^ + // | | | cursor on `some_variable, position on `)` + // | | + // | | cursor on `some_func`, pos on `(` + // | + // | cursor on `member`, pos on ` ` (space) + // ``` + // -> Move position to previous character if: + // * Position not on valid identifier char. + // * Prev position is valid identifier char. + lsp::Position pos = p_position; + if ( + pos.character >= line.length() // Cursor at end of line. + || (!is_ascii_identifier_char(line[pos.character]) // Not on valid identifier char. + && (pos.character > 0 // Not line start -> there is a prev char. + && is_ascii_identifier_char(line[pos.character - 1]) // Prev is valid identifier char. + ))) { + pos.character--; + } + + int start_pos = pos.character; + for (int c = pos.character; c >= 0; c--) { start_pos = c; char32_t ch = line[c]; bool valid_char = is_ascii_identifier_char(ch); @@ -562,8 +720,8 @@ String ExtendGDScriptParser::get_identifier_under_position(const lsp::Position & } } - int end_pos = p_position.character; - for (int c = p_position.character; c < line.length(); c++) { + int end_pos = pos.character; + for (int c = pos.character; c < line.length(); c++) { char32_t ch = line[c]; bool valid_char = is_ascii_identifier_char(ch); if (!valid_char) { @@ -571,9 +729,11 @@ String ExtendGDScriptParser::get_identifier_under_position(const lsp::Position & } end_pos = c; } + if (start_pos < end_pos) { - p_offset.x = start_pos - p_position.character; - p_offset.y = end_pos - p_position.character; + r_range.start.line = r_range.end.line = pos.line; + r_range.start.character = start_pos + 1; + r_range.end.character = end_pos + 1; return line.substr(start_pos + 1, end_pos - start_pos); } @@ -584,15 +744,15 @@ 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 *ExtendGDScriptParser::search_symbol_defined_at_line(int p_line, const lsp::DocumentSymbol &p_parent, const String &p_symbol_name) const { const lsp::DocumentSymbol *ret = nullptr; if (p_line < p_parent.range.start.line) { return ret; - } else if (p_parent.range.start.line == p_line) { + } else if (p_parent.range.start.line == p_line && (p_symbol_name.is_empty() || p_parent.name == p_symbol_name)) { 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]); + ret = search_symbol_defined_at_line(p_line, p_parent.children[i], p_symbol_name); if (ret) { break; } @@ -645,11 +805,11 @@ Error ExtendGDScriptParser::get_left_function_call(const lsp::Position &p_positi return ERR_METHOD_NOT_FOUND; } -const lsp::DocumentSymbol *ExtendGDScriptParser::get_symbol_defined_at_line(int p_line) const { +const lsp::DocumentSymbol *ExtendGDScriptParser::get_symbol_defined_at_line(int p_line, const String &p_symbol_name) const { if (p_line <= 0) { return &class_symbol; } - return search_symbol_defined_at_line(p_line, class_symbol); + return search_symbol_defined_at_line(p_line, class_symbol, p_symbol_name); } const lsp::DocumentSymbol *ExtendGDScriptParser::get_member_symbol(const String &p_name, const String &p_subclass) const { diff --git a/modules/gdscript/language_server/gdscript_extend_parser.h b/modules/gdscript/language_server/gdscript_extend_parser.h index 4fd27de081..a808f19e5b 100644 --- a/modules/gdscript/language_server/gdscript_extend_parser.h +++ b/modules/gdscript/language_server/gdscript_extend_parser.h @@ -39,6 +39,9 @@ #ifndef LINE_NUMBER_TO_INDEX #define LINE_NUMBER_TO_INDEX(p_line) ((p_line)-1) #endif +#ifndef COLUMN_NUMBER_TO_INDEX +#define COLUMN_NUMBER_TO_INDEX(p_column) ((p_column)-1) +#endif #ifndef SYMBOL_SEPERATOR #define SYMBOL_SEPERATOR "::" @@ -50,6 +53,64 @@ typedef HashMap<String, const lsp::DocumentSymbol *> ClassMembers; +/** + * Represents a Position as used by GDScript Parser. Used for conversion to and from `lsp::Position`. + * + * Difference to `lsp::Position`: + * * Line & Char/column: 1-based + * * LSP: both 0-based + * * Tabs are expanded to columns using tab size (`text_editor/behavior/indent/size`). + * * LSP: tab is single char + * + * Example: + * ```gdscript + * →→var my_value = 42 + * ``` + * `_` is at: + * * Godot: `column=12` + * * using `indent/size=4` + * * Note: counting starts at `1` + * * LSP: `character=8` + * * Note: counting starts at `0` + */ +struct GodotPosition { + int line; + int column; + + GodotPosition(int p_line, int p_column) : + line(p_line), column(p_column) {} + + lsp::Position to_lsp(const Vector<String> &p_lines) const; + static GodotPosition from_lsp(const lsp::Position p_pos, const Vector<String> &p_lines); + + bool operator==(const GodotPosition &p_other) const { + return line == p_other.line && column == p_other.column; + } + + String to_string() const { + return vformat("(%d,%d)", line, column); + } +}; + +struct GodotRange { + GodotPosition start; + GodotPosition end; + + GodotRange(GodotPosition p_start, GodotPosition p_end) : + start(p_start), end(p_end) {} + + lsp::Range to_lsp(const Vector<String> &p_lines) const; + static GodotRange from_lsp(const lsp::Range &p_range, const Vector<String> &p_lines); + + bool operator==(const GodotRange &p_other) const { + return start == p_other.start && end == p_other.end; + } + + String to_string() const { + return vformat("[%s:%s]", start.to_string(), end.to_string()); + } +}; + class ExtendGDScriptParser : public GDScriptParser { String path; Vector<String> lines; @@ -60,6 +121,8 @@ class ExtendGDScriptParser : public GDScriptParser { ClassMembers members; HashMap<String, ClassMembers> inner_classes; + lsp::Range range_of_node(const GDScriptParser::Node *p_node) const; + void update_diagnostics(); void update_symbols(); @@ -70,8 +133,7 @@ class ExtendGDScriptParser : public GDScriptParser { 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; + const lsp::DocumentSymbol *search_symbol_defined_at_line(int p_line, const lsp::DocumentSymbol &p_parent, const String &p_symbol_name = "") const; Array member_completions; @@ -87,10 +149,18 @@ public: 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_required = false) const; - String get_identifier_under_position(const lsp::Position &p_position, Vector2i &p_offset) const; + String get_identifier_under_position(const lsp::Position &p_position, lsp::Range &r_range) const; String get_uri() const; - const lsp::DocumentSymbol *get_symbol_defined_at_line(int p_line) const; + /** + * `p_symbol_name` gets ignored if empty. Otherwise symbol must match passed in named. + * + * Necessary when multiple symbols at same line for example with `func`: + * `func handle_arg(arg: int):` + * -> Without `p_symbol_name`: returns `handle_arg`. Even if parameter (`arg`) is wanted. + * With `p_symbol_name`: symbol name MUST match `p_symbol_name`: returns `arg`. + */ + const lsp::DocumentSymbol *get_symbol_defined_at_line(int p_line, const String &p_symbol_name = "") const; const lsp::DocumentSymbol *get_member_symbol(const String &p_name, const String &p_subclass = "") const; const List<lsp::DocumentLink> &get_document_links() const; diff --git a/modules/gdscript/language_server/gdscript_language_protocol.cpp b/modules/gdscript/language_server/gdscript_language_protocol.cpp index 112db4df3a..14fc21d7dc 100644 --- a/modules/gdscript/language_server/gdscript_language_protocol.cpp +++ b/modules/gdscript/language_server/gdscript_language_protocol.cpp @@ -278,6 +278,11 @@ void GDScriptLanguageProtocol::stop() { } void GDScriptLanguageProtocol::notify_client(const String &p_method, const Variant &p_params, int p_client_id) { +#ifdef TESTS_ENABLED + if (clients.is_empty()) { + return; + } +#endif if (p_client_id == -1) { ERR_FAIL_COND_MSG(latest_client_id == -1, "GDScript LSP: Can't notify client as none was connected."); @@ -294,6 +299,11 @@ void GDScriptLanguageProtocol::notify_client(const String &p_method, const Varia } void GDScriptLanguageProtocol::request_client(const String &p_method, const Variant &p_params, int p_client_id) { +#ifdef TESTS_ENABLED + if (clients.is_empty()) { + return; + } +#endif if (p_client_id == -1) { ERR_FAIL_COND_MSG(latest_client_id == -1, "GDScript LSP: Can't notify client as none was connected."); diff --git a/modules/gdscript/language_server/gdscript_text_document.cpp b/modules/gdscript/language_server/gdscript_text_document.cpp index 92a5f55978..1e927f9f6e 100644 --- a/modules/gdscript/language_server/gdscript_text_document.cpp +++ b/modules/gdscript/language_server/gdscript_text_document.cpp @@ -50,6 +50,8 @@ void GDScriptTextDocument::_bind_methods() { ClassDB::bind_method(D_METHOD("completion"), &GDScriptTextDocument::completion); ClassDB::bind_method(D_METHOD("resolve"), &GDScriptTextDocument::resolve); ClassDB::bind_method(D_METHOD("rename"), &GDScriptTextDocument::rename); + ClassDB::bind_method(D_METHOD("prepareRename"), &GDScriptTextDocument::prepareRename); + ClassDB::bind_method(D_METHOD("references"), &GDScriptTextDocument::references); ClassDB::bind_method(D_METHOD("foldingRange"), &GDScriptTextDocument::foldingRange); ClassDB::bind_method(D_METHOD("codeLens"), &GDScriptTextDocument::codeLens); ClassDB::bind_method(D_METHOD("documentLink"), &GDScriptTextDocument::documentLink); @@ -161,11 +163,8 @@ Array GDScriptTextDocument::documentSymbol(const Dictionary &p_params) { String path = GDScriptLanguageProtocol::get_singleton()->get_workspace()->get_file_path(uri); Array arr; if (HashMap<String, ExtendGDScriptParser *>::ConstIterator parser = GDScriptLanguageProtocol::get_singleton()->get_workspace()->scripts.find(path)) { - Vector<lsp::DocumentedSymbolInformation> list; - parser->value->get_symbols().symbol_tree_as_list(uri, list); - for (int i = 0; i < list.size(); i++) { - arr.push_back(list[i].to_json()); - } + lsp::DocumentSymbol symbol = parser->value->get_symbols(); + arr.push_back(symbol.to_json(true)); } return arr; } @@ -253,6 +252,48 @@ Dictionary GDScriptTextDocument::rename(const Dictionary &p_params) { return GDScriptLanguageProtocol::get_singleton()->get_workspace()->rename(params, new_name); } +Variant GDScriptTextDocument::prepareRename(const Dictionary &p_params) { + lsp::TextDocumentPositionParams params; + params.load(p_params); + + lsp::DocumentSymbol symbol; + lsp::Range range; + if (GDScriptLanguageProtocol::get_singleton()->get_workspace()->can_rename(params, symbol, range)) { + return Variant(range.to_json()); + } + + // `null` -> rename not valid at current location. + return Variant(); +} + +Array GDScriptTextDocument::references(const Dictionary &p_params) { + Array res; + + lsp::ReferenceParams params; + params.load(p_params); + + const lsp::DocumentSymbol *symbol = GDScriptLanguageProtocol::get_singleton()->get_workspace()->resolve_symbol(params); + if (symbol) { + Vector<lsp::Location> usages = GDScriptLanguageProtocol::get_singleton()->get_workspace()->find_all_usages(*symbol); + res.resize(usages.size()); + int declaration_adjustment = 0; + for (int i = 0; i < usages.size(); i++) { + lsp::Location usage = usages[i]; + if (!params.context.includeDeclaration && usage.range == symbol->range) { + declaration_adjustment++; + continue; + } + res[i - declaration_adjustment] = usages[i].to_json(); + } + + if (declaration_adjustment > 0) { + res.resize(res.size() - declaration_adjustment); + } + } + + return res; +} + Dictionary GDScriptTextDocument::resolve(const Dictionary &p_params) { lsp::CompletionItem item; item.load(p_params); @@ -450,7 +491,7 @@ Array GDScriptTextDocument::find_symbols(const lsp::TextDocumentPositionParams & if (symbol) { lsp::Location location; location.uri = symbol->uri; - location.range = symbol->range; + location.range = symbol->selectionRange; 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()); @@ -464,7 +505,7 @@ Array GDScriptTextDocument::find_symbols(const lsp::TextDocumentPositionParams & if (!s->uri.is_empty()) { lsp::Location location; location.uri = s->uri; - location.range = s->range; + location.range = s->selectionRange; arr.push_back(location.to_json()); r_list.push_back(s); } diff --git a/modules/gdscript/language_server/gdscript_text_document.h b/modules/gdscript/language_server/gdscript_text_document.h index 0121101db2..cfd0490f0a 100644 --- a/modules/gdscript/language_server/gdscript_text_document.h +++ b/modules/gdscript/language_server/gdscript_text_document.h @@ -65,6 +65,8 @@ public: Array completion(const Dictionary &p_params); Dictionary resolve(const Dictionary &p_params); Dictionary rename(const Dictionary &p_params); + Variant prepareRename(const Dictionary &p_params); + Array references(const Dictionary &p_params); Array foldingRange(const Dictionary &p_params); Array codeLens(const Dictionary &p_params); Array documentLink(const Dictionary &p_params); diff --git a/modules/gdscript/language_server/gdscript_workspace.cpp b/modules/gdscript/language_server/gdscript_workspace.cpp index 9f848b02f5..81933c8c87 100644 --- a/modules/gdscript/language_server/gdscript_workspace.cpp +++ b/modules/gdscript/language_server/gdscript_workspace.cpp @@ -46,7 +46,6 @@ void GDScriptWorkspace::_bind_methods() { ClassDB::bind_method(D_METHOD("apply_new_signal"), &GDScriptWorkspace::apply_new_signal); ClassDB::bind_method(D_METHOD("didDeleteFiles"), &GDScriptWorkspace::did_delete_files); - ClassDB::bind_method(D_METHOD("symbol"), &GDScriptWorkspace::symbol); ClassDB::bind_method(D_METHOD("parse_script", "path", "content"), &GDScriptWorkspace::parse_script); ClassDB::bind_method(D_METHOD("parse_local_script", "path"), &GDScriptWorkspace::parse_local_script); ClassDB::bind_method(D_METHOD("get_file_path", "uri"), &GDScriptWorkspace::get_file_path); @@ -182,35 +181,33 @@ const lsp::DocumentSymbol *GDScriptWorkspace::get_parameter_symbol(const lsp::Do return nullptr; } -const lsp::DocumentSymbol *GDScriptWorkspace::get_local_symbol(const ExtendGDScriptParser *p_parser, const String &p_symbol_identifier) { - const lsp::DocumentSymbol *class_symbol = &p_parser->get_symbols(); +const lsp::DocumentSymbol *GDScriptWorkspace::get_local_symbol_at(const ExtendGDScriptParser *p_parser, const String &p_symbol_identifier, const lsp::Position p_position) { + // Go down and pick closest `DocumentSymbol` with `p_symbol_identifier`. - for (int i = 0; i < class_symbol->children.size(); ++i) { - int kind = class_symbol->children[i].kind; - switch (kind) { - case lsp::SymbolKind::Function: - case lsp::SymbolKind::Method: - case lsp::SymbolKind::Class: { - const lsp::DocumentSymbol *function_symbol = &class_symbol->children[i]; + const lsp::DocumentSymbol *current = &p_parser->get_symbols(); + const lsp::DocumentSymbol *best_match = nullptr; - for (int l = 0; l < function_symbol->children.size(); ++l) { - const lsp::DocumentSymbol *local = &function_symbol->children[l]; - if (!local->detail.is_empty() && local->name == p_symbol_identifier) { - return local; - } - } - } break; + while (current) { + if (current->name == p_symbol_identifier) { + if (current->selectionRange.contains(p_position)) { + // Exact match: pos is ON symbol decl identifier. + return current; + } - case lsp::SymbolKind::Variable: { - const lsp::DocumentSymbol *variable_symbol = &class_symbol->children[i]; - if (variable_symbol->name == p_symbol_identifier) { - return variable_symbol; - } - } break; + best_match = current; + } + + const lsp::DocumentSymbol *parent = current; + current = nullptr; + for (const lsp::DocumentSymbol &child : parent->children) { + if (child.range.contains(p_position)) { + current = &child; + break; + } } } - return nullptr; + return best_match; } void GDScriptWorkspace::reload_all_workspace_scripts() { @@ -275,25 +272,6 @@ ExtendGDScriptParser *GDScriptWorkspace::get_parse_result(const String &p_path) return nullptr; } -Array GDScriptWorkspace::symbol(const Dictionary &p_params) { - String query = p_params["query"]; - Array arr; - if (!query.is_empty()) { - for (const KeyValue<String, ExtendGDScriptParser *> &E : scripts) { - Vector<lsp::DocumentedSymbolInformation> script_symbols; - E.value->get_symbols().symbol_tree_as_list(E.key, script_symbols); - for (int i = 0; i < script_symbols.size(); ++i) { - if (query.is_subsequence_ofn(script_symbols[i].name)) { - lsp::DocumentedSymbolInformation symbol = script_symbols[i]; - symbol.location.uri = get_file_uri(symbol.location.uri); - arr.push_back(symbol.to_json()); - } - } - } - } - return arr; -} - Error GDScriptWorkspace::initialize() { if (initialized) { return OK; @@ -423,7 +401,7 @@ Error GDScriptWorkspace::initialize() { native_members.insert(E.key, members); } - // cache member completions + // Cache member completions. for (const KeyValue<String, ExtendGDScriptParser *> &S : scripts) { S.value->get_member_completions(); } @@ -458,48 +436,110 @@ Error GDScriptWorkspace::parse_script(const String &p_path, const String &p_cont return err; } -Dictionary GDScriptWorkspace::rename(const lsp::TextDocumentPositionParams &p_doc_pos, const String &new_name) { - Error err; - String path = get_file_path(p_doc_pos.textDocument.uri); +static bool is_valid_rename_target(const lsp::DocumentSymbol *p_symbol) { + // Must be valid symbol. + if (!p_symbol) { + return false; + } + + // Cannot rename builtin. + if (!p_symbol->native_class.is_empty()) { + return false; + } + + // Source must be available. + if (p_symbol->script_path.is_empty()) { + return false; + } + return true; +} + +Dictionary GDScriptWorkspace::rename(const lsp::TextDocumentPositionParams &p_doc_pos, const String &new_name) { lsp::WorkspaceEdit edit; - List<String> paths; - list_script_files("res://", paths); + const lsp::DocumentSymbol *reference_symbol = resolve_symbol(p_doc_pos); + if (is_valid_rename_target(reference_symbol)) { + Vector<lsp::Location> usages = find_all_usages(*reference_symbol); + for (int i = 0; i < usages.size(); ++i) { + lsp::Location loc = usages[i]; + + edit.add_change(loc.uri, loc.range.start.line, loc.range.start.character, loc.range.end.character, new_name); + } + } + + return edit.to_json(); +} +bool GDScriptWorkspace::can_rename(const lsp::TextDocumentPositionParams &p_doc_pos, lsp::DocumentSymbol &r_symbol, lsp::Range &r_range) { const lsp::DocumentSymbol *reference_symbol = resolve_symbol(p_doc_pos); - if (reference_symbol) { - String identifier = reference_symbol->name; + if (!is_valid_rename_target(reference_symbol)) { + return false; + } - for (List<String>::Element *PE = paths.front(); PE; PE = PE->next()) { - PackedStringArray content = FileAccess::get_file_as_string(PE->get(), &err).split("\n"); - for (int i = 0; i < content.size(); ++i) { - String line = content[i]; + String path = get_file_path(p_doc_pos.textDocument.uri); + if (const ExtendGDScriptParser *parser = get_parse_result(path)) { + parser->get_identifier_under_position(p_doc_pos.position, r_range); + r_symbol = *reference_symbol; + return true; + } - int character = line.find(identifier); - while (character > -1) { - lsp::TextDocumentPositionParams params; + return false; +} - lsp::TextDocumentIdentifier text_doc; - text_doc.uri = get_file_uri(PE->get()); +Vector<lsp::Location> GDScriptWorkspace::find_usages_in_file(const lsp::DocumentSymbol &p_symbol, const String &p_file_path) { + Vector<lsp::Location> usages; - params.textDocument = text_doc; - params.position.line = i; - params.position.character = character; + String identifier = p_symbol.name; + if (const ExtendGDScriptParser *parser = get_parse_result(p_file_path)) { + const PackedStringArray &content = parser->get_lines(); + for (int i = 0; i < content.size(); ++i) { + String line = content[i]; - const lsp::DocumentSymbol *other_symbol = resolve_symbol(params); + int character = line.find(identifier); + while (character > -1) { + lsp::TextDocumentPositionParams params; - if (other_symbol == reference_symbol) { - edit.add_change(text_doc.uri, i, character, character + identifier.length(), new_name); - } + lsp::TextDocumentIdentifier text_doc; + text_doc.uri = get_file_uri(p_file_path); - character = line.find(identifier, character + 1); + params.textDocument = text_doc; + params.position.line = i; + params.position.character = character; + + const lsp::DocumentSymbol *other_symbol = resolve_symbol(params); + + if (other_symbol == &p_symbol) { + lsp::Location loc; + loc.uri = text_doc.uri; + loc.range.start = params.position; + loc.range.end.line = params.position.line; + loc.range.end.character = params.position.character + identifier.length(); + usages.append(loc); } + + character = line.find(identifier, character + 1); } } } - return edit.to_json(); + return usages; +} + +Vector<lsp::Location> GDScriptWorkspace::find_all_usages(const lsp::DocumentSymbol &p_symbol) { + if (p_symbol.local) { + // Only search in current document. + return find_usages_in_file(p_symbol, p_symbol.script_path); + } + // Search in all documents. + List<String> paths; + list_script_files("res://", paths); + + Vector<lsp::Location> usages; + for (List<String>::Element *PE = paths.front(); PE; PE = PE->next()) { + usages.append_array(find_usages_in_file(p_symbol, PE->get())); + } + return usages; } Error GDScriptWorkspace::parse_local_script(const String &p_path) { @@ -636,9 +676,9 @@ const lsp::DocumentSymbol *GDScriptWorkspace::resolve_symbol(const lsp::TextDocu lsp::Position pos = p_doc_pos.position; if (symbol_identifier.is_empty()) { - Vector2i offset; - symbol_identifier = parser->get_identifier_under_position(p_doc_pos.position, offset); - pos.character += offset.y; + lsp::Range range; + symbol_identifier = parser->get_identifier_under_position(p_doc_pos.position, range); + pos.character = range.end.character; } if (!symbol_identifier.is_empty()) { @@ -661,7 +701,7 @@ const lsp::DocumentSymbol *GDScriptWorkspace::resolve_symbol(const lsp::TextDocu } 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)); + symbol = target_parser->get_symbol_defined_at_line(LINE_NUMBER_TO_INDEX(ret.location), symbol_identifier); if (symbol) { switch (symbol->kind) { @@ -670,10 +710,6 @@ const lsp::DocumentSymbol *GDScriptWorkspace::resolve_symbol(const lsp::TextDocu symbol = get_parameter_symbol(symbol, symbol_identifier); } } break; - - case lsp::SymbolKind::Variable: { - symbol = get_local_symbol(parser, symbol_identifier); - } break; } } } @@ -686,10 +722,9 @@ const lsp::DocumentSymbol *GDScriptWorkspace::resolve_symbol(const lsp::TextDocu symbol = get_native_symbol(ret.class_name, member); } } else { - symbol = parser->get_member_symbol(symbol_identifier); - + symbol = get_local_symbol_at(parser, symbol_identifier, p_doc_pos.position); if (!symbol) { - symbol = get_local_symbol(parser, symbol_identifier); + symbol = parser->get_member_symbol(symbol_identifier); } } } @@ -703,8 +738,8 @@ void GDScriptWorkspace::resolve_related_symbols(const lsp::TextDocumentPositionP 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); + lsp::Range range; + symbol_identifier = parser->get_identifier_under_position(p_doc_pos.position, range); for (const KeyValue<StringName, ClassMembers> &E : native_members) { const ClassMembers &members = native_members.get(E.key); diff --git a/modules/gdscript/language_server/gdscript_workspace.h b/modules/gdscript/language_server/gdscript_workspace.h index 80653778fb..0b2d43b817 100644 --- a/modules/gdscript/language_server/gdscript_workspace.h +++ b/modules/gdscript/language_server/gdscript_workspace.h @@ -54,7 +54,7 @@ protected: 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; const lsp::DocumentSymbol *get_parameter_symbol(const lsp::DocumentSymbol *p_parent, const String &symbol_identifier); - const lsp::DocumentSymbol *get_local_symbol(const ExtendGDScriptParser *p_parser, const String &p_symbol_identifier); + const lsp::DocumentSymbol *get_local_symbol_at(const ExtendGDScriptParser *p_parser, const String &p_symbol_identifier, const lsp::Position p_position); void reload_all_workspace_scripts(); @@ -74,9 +74,6 @@ public: 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); @@ -96,6 +93,9 @@ public: Error resolve_signature(const lsp::TextDocumentPositionParams &p_doc_pos, lsp::SignatureHelp &r_signature); void did_delete_files(const Dictionary &p_params); Dictionary rename(const lsp::TextDocumentPositionParams &p_doc_pos, const String &new_name); + bool can_rename(const lsp::TextDocumentPositionParams &p_doc_pos, lsp::DocumentSymbol &r_symbol, lsp::Range &r_range); + Vector<lsp::Location> find_usages_in_file(const lsp::DocumentSymbol &p_symbol, const String &p_file_path); + Vector<lsp::Location> find_all_usages(const lsp::DocumentSymbol &p_symbol); GDScriptWorkspace(); ~GDScriptWorkspace(); diff --git a/modules/gdscript/language_server/godot_lsp.h b/modules/gdscript/language_server/godot_lsp.h index 3782945e07..1ac4267c7b 100644 --- a/modules/gdscript/language_server/godot_lsp.h +++ b/modules/gdscript/language_server/godot_lsp.h @@ -83,6 +83,14 @@ struct Position { */ int character = 0; + _FORCE_INLINE_ bool operator==(const Position &p_other) const { + return line == p_other.line && character == p_other.character; + } + + String to_string() const { + return vformat("(%d,%d)", line, character); + } + _FORCE_INLINE_ void load(const Dictionary &p_params) { line = p_params["line"]; character = p_params["character"]; @@ -112,6 +120,27 @@ struct Range { */ Position end; + _FORCE_INLINE_ bool operator==(const Range &p_other) const { + return start == p_other.start && end == p_other.end; + } + + bool contains(const Position &p_pos) const { + // Inside line range. + if (start.line <= p_pos.line && p_pos.line <= end.line) { + // If on start line: must come after start char. + bool start_ok = p_pos.line == start.line ? start.character <= p_pos.character : true; + // If on end line: must come before end char. + bool end_ok = p_pos.line == end.line ? p_pos.character <= end.character : true; + return start_ok && end_ok; + } else { + return false; + } + } + + String to_string() const { + return vformat("[%s:%s]", start.to_string(), end.to_string()); + } + _FORCE_INLINE_ void load(const Dictionary &p_params) { start.load(p_params["start"]); end.load(p_params["end"]); @@ -203,6 +232,17 @@ struct TextDocumentPositionParams { } }; +struct ReferenceContext { + /** + * Include the declaration of the current symbol. + */ + bool includeDeclaration; +}; + +struct ReferenceParams : TextDocumentPositionParams { + ReferenceContext context; +}; + struct DocumentLinkParams { /** * The document to provide document links for. @@ -343,8 +383,8 @@ struct Command { } }; -// Use namespace instead of enumeration to follow the LSP specifications -// lsp::EnumName::EnumValue is OK but lsp::EnumValue is not +// Use namespace instead of enumeration to follow the LSP specifications. +// `lsp::EnumName::EnumValue` is OK but `lsp::EnumValue` is not. namespace TextDocumentSyncKind { /** @@ -436,7 +476,7 @@ struct RenameOptions { /** * Renames should be checked and tested before being executed. */ - bool prepareProvider = false; + bool prepareProvider = true; Dictionary to_json() { Dictionary dict; @@ -794,12 +834,12 @@ static const String Markdown = "markdown"; */ struct MarkupContent { /** - * The type of the Markup + * The type of the Markup. */ String kind; /** - * The content itself + * The content itself. */ String value; @@ -821,8 +861,8 @@ struct MarkupContent { }; // Use namespace instead of enumeration to follow the LSP specifications -// lsp::EnumName::EnumValue is OK but lsp::EnumValue is not -// And here C++ compilers are unhappy with our enumeration name like Color, File, RefCounted etc. +// `lsp::EnumName::EnumValue` is OK but `lsp::EnumValue` is not. +// And here C++ compilers are unhappy with our enumeration name like `Color`, `File`, `RefCounted` etc. /** * The kind of a completion entry. */ @@ -854,7 +894,7 @@ static const int Operator = 24; static const int TypeParameter = 25; }; // namespace CompletionItemKind -// Use namespace instead of enumeration to follow the LSP specifications +// Use namespace instead of enumeration to follow the LSP specifications. /** * Defines whether the insert text in a completion item should be interpreted as * plain text or a snippet. @@ -1070,8 +1110,8 @@ struct CompletionList { }; // Use namespace instead of enumeration to follow the LSP specifications -// lsp::EnumName::EnumValue is OK but lsp::EnumValue is not -// And here C++ compilers are unhappy with our enumeration name like String, Array, Object etc +// `lsp::EnumName::EnumValue` is OK but `lsp::EnumValue` is not +// And here C++ compilers are unhappy with our enumeration name like `String`, `Array`, `Object` etc /** * A symbol kind. */ @@ -1105,70 +1145,6 @@ static const int TypeParameter = 26; }; // namespace SymbolKind /** - * Represents information about programming constructs like variables, classes, - * interfaces etc. - */ -struct SymbolInformation { - /** - * The name of this symbol. - */ - String name; - - /** - * The kind of this symbol. - */ - int kind = SymbolKind::File; - - /** - * Indicates if this symbol is deprecated. - */ - bool deprecated = false; - - /** - * The location of this symbol. The location's range is used by a tool - * to reveal the location in the editor. If the symbol is selected in the - * tool the range's start information is used to position the cursor. So - * the range usually spans more then the actual symbol's name and does - * normally include things like visibility modifiers. - * - * The range doesn't have to denote a node range in the sense of a abstract - * syntax tree. It can therefore not be used to re-construct a hierarchy of - * the symbols. - */ - Location location; - - /** - * The name of the symbol containing this symbol. This information is for - * user interface purposes (e.g. to render a qualifier in the user interface - * if necessary). It can't be used to re-infer a hierarchy for the document - * symbols. - */ - String containerName; - - _FORCE_INLINE_ Dictionary to_json() const { - Dictionary dict; - dict["name"] = name; - dict["kind"] = kind; - dict["deprecated"] = deprecated; - dict["location"] = location.to_json(); - dict["containerName"] = containerName; - return dict; - } -}; - -struct DocumentedSymbolInformation : public SymbolInformation { - /** - * A human-readable string with additional information - */ - String detail; - - /** - * A human-readable string that represents a doc-comment. - */ - String documentation; -}; - -/** * Represents programming constructs like variables, classes, interfaces etc. that appear in a document. Document symbols can be * hierarchical and they have two ranges: one that encloses its definition and one that points to its most interesting range, * e.g. the range of an identifier. @@ -1186,12 +1162,12 @@ struct DocumentSymbol { String detail; /** - * Documentation for this symbol + * Documentation for this symbol. */ String documentation; /** - * Class name for the native symbols + * Class name for the native symbols. */ String native_class; @@ -1206,6 +1182,13 @@ struct DocumentSymbol { bool deprecated = false; /** + * If `true`: Symbol is local to script and cannot be accessed somewhere else. + * + * For example: local variable inside a `func`. + */ + bool local = false; + + /** * The range enclosing this symbol not including leading/trailing whitespace but everything else * like comments. This information is typically used to determine if the clients cursor is * inside the symbol to reveal in the symbol in the UI. @@ -1238,35 +1221,21 @@ struct DocumentSymbol { dict["documentation"] = documentation; dict["native_class"] = native_class; } - Array arr; - arr.resize(children.size()); - for (int i = 0; i < children.size(); i++) { - arr[i] = children[i].to_json(with_doc); + if (!children.is_empty()) { + Array arr; + for (int i = 0; i < children.size(); i++) { + if (children[i].local) { + continue; + } + arr.push_back(children[i].to_json(with_doc)); + } + if (!children.is_empty()) { + dict["children"] = arr; + } } - dict["children"] = arr; return dict; } - void symbol_tree_as_list(const String &p_uri, Vector<DocumentedSymbolInformation> &r_list, const String &p_container = "", bool p_join_name = false) const { - DocumentedSymbolInformation si; - if (p_join_name && !p_container.is_empty()) { - si.name = p_container + ">" + name; - } else { - si.name = name; - } - si.kind = kind; - si.containerName = p_container; - si.deprecated = deprecated; - si.location.uri = p_uri; - si.location.range = range; - si.detail = detail; - si.documentation = documentation; - r_list.push_back(si); - for (int i = 0; i < children.size(); i++) { - children[i].symbol_tree_as_list(p_uri, r_list, si.name, p_join_name); - } - } - _FORCE_INLINE_ MarkupContent render() const { MarkupContent markdown; if (detail.length()) { @@ -1750,7 +1719,7 @@ struct ServerCapabilities { /** * The server provides find references support. */ - bool referencesProvider = false; + bool referencesProvider = true; /** * The server provides document highlight support. diff --git a/modules/gdscript/tests/gdscript_test_runner.cpp b/modules/gdscript/tests/gdscript_test_runner.cpp index 874cbc6ee8..01772a2e38 100644 --- a/modules/gdscript/tests/gdscript_test_runner.cpp +++ b/modules/gdscript/tests/gdscript_test_runner.cpp @@ -149,6 +149,10 @@ GDScriptTestRunner::GDScriptTestRunner(const String &p_source_dir, bool p_init_l // Set all warning levels to "Warn" in order to test them properly, even the ones that default to error. ProjectSettings::get_singleton()->set_setting("debug/gdscript/warnings/enable", true); for (int i = 0; i < (int)GDScriptWarning::WARNING_MAX; i++) { + if (i == GDScriptWarning::UNTYPED_DECLARATION) { + // TODO: Add ability for test scripts to specify which warnings to enable/disable for testing. + continue; + } String warning_setting = GDScriptWarning::get_settings_path_from_code((GDScriptWarning::Code)i); ProjectSettings::get_singleton()->set_setting(warning_setting, (int)GDScriptWarning::WARN); } diff --git a/modules/gdscript/tests/scripts/analyzer/errors/typed_array_init_with_unconvertable_in_literal.gd b/modules/gdscript/tests/scripts/analyzer/errors/typed_array_init_with_unconvertable_in_literal.gd index 25cde1d40b..7cc5aaf44f 100644 --- a/modules/gdscript/tests/scripts/analyzer/errors/typed_array_init_with_unconvertable_in_literal.gd +++ b/modules/gdscript/tests/scripts/analyzer/errors/typed_array_init_with_unconvertable_in_literal.gd @@ -1,4 +1,4 @@ func test(): - var unconvertable := 1 - var typed: Array[Object] = [unconvertable] + var unconvertible := 1 + var typed: Array[Object] = [unconvertible] print('not ok') diff --git a/modules/gdscript/tests/scripts/lsp/class.notest.gd b/modules/gdscript/tests/scripts/lsp/class.notest.gd new file mode 100644 index 0000000000..53d0b14d72 --- /dev/null +++ b/modules/gdscript/tests/scripts/lsp/class.notest.gd @@ -0,0 +1,132 @@ +extends Node + +class Inner1 extends Node: +# ^^^^^^ class1 -> class1 + var member1 := 42 + # ^^^^^^^ class1:member1 -> class1:member1 + var member2 : int = 13 + # ^^^^^^^ class1:member2 -> class1:member2 + var member3 = 1337 + # ^^^^^^^ class1:member3 -> class1:member3 + + signal changed(old, new) + # ^^^^^^^ class1:signal -> class1:signal + func my_func(arg1: int, arg2: String, arg3): + # | | | | | | ^^^^ class1:func:arg3 -> class1:func:arg3 + # | | | | ^^^^ class1:func:arg2 -> class1:func:arg2 + # | | ^^^^ class1:func:arg1 -> class1:func:arg1 + # ^^^^^^^ class1:func -> class1:func + print(arg1, arg2, arg3) + # | | | | ^^^^ -> class1:func:arg3 + # | | ^^^^ -> class1:func:arg2 + # ^^^^ -> class1:func:arg1 + changed.emit(arg1, arg3) + # | | | ^^^^ -> class1:func:arg3 + # | ^^^^ -> class1:func:arg1 + #<^^^^^ -> class1:signal + return arg1 + arg2.length() + arg3 + # | | | | ^^^^ -> class1:func:arg3 + # | | ^^^^ -> class1:func:arg2 + # ^^^^ -> class1:func:arg1 + +class Inner2: +# ^^^^^^ class2 -> class2 + var member1 := 42 + # ^^^^^^^ class2:member1 -> class2:member1 + var member2 : int = 13 + # ^^^^^^^ class2:member2 -> class2:member2 + var member3 = 1337 + # ^^^^^^^ class2:member3 -> class2:member3 + + signal changed(old, new) + # ^^^^^^^ class2:signal -> class2:signal + func my_func(arg1: int, arg2: String, arg3): + # | | | | | | ^^^^ class2:func:arg3 -> class2:func:arg3 + # | | | | ^^^^ class2:func:arg2 -> class2:func:arg2 + # | | ^^^^ class2:func:arg1 -> class2:func:arg1 + # ^^^^^^^ class2:func -> class2:func + print(arg1, arg2, arg3) + # | | | | ^^^^ -> class2:func:arg3 + # | | ^^^^ -> class2:func:arg2 + # ^^^^ -> class2:func:arg1 + changed.emit(arg1, arg3) + # | | | ^^^^ -> class2:func:arg3 + # | ^^^^ -> class2:func:arg1 + #<^^^^^ -> class2:signal + return arg1 + arg2.length() + arg3 + # | | | | ^^^^ -> class2:func:arg3 + # | | ^^^^ -> class2:func:arg2 + # ^^^^ -> class2:func:arg1 + +class Inner3 extends Inner2: +# | | ^^^^^^ -> class2 +# ^^^^^^ class3 -> class3 + var whatever = "foo" + # ^^^^^^^^ class3:whatever -> class3:whatever + + func _init(): + # ^^^^^ class3:init + # Note: no self-ref check here: resolves to `Object._init`. + # usages of `Inner3.new()` DO resolve to this `_init` + pass + + class NestedInInner3: + # ^^^^^^^^^^^^^^ class3:nested1 -> class3:nested1 + var some_value := 42 + # ^^^^^^^^^^ class3:nested1:some_value -> class3:nested1:some_value + + class AnotherNestedInInner3 extends NestedInInner3: + #! | | ^^^^^^^^^^^^^^ -> class3:nested1 + # ^^^^^^^^^^^^^^^^^^^^^ class3:nested2 -> class3:nested2 + var another_value := 13 + # ^^^^^^^^^^^^^ class3:nested2:another_value -> class3:nested2:another_value + +func _ready(): + var inner1 = Inner1.new() + # | | ^^^^^^ -> class1 + # ^^^^^^ func:class1 -> func:class1 + var value1 = inner1.my_func(1,"",3) + # | | | | ^^^^^^^ -> class1:func + # | | ^^^^^^ -> func:class1 + # ^^^^^^ func:class1:value1 -> func:class1:value1 + var value2 = inner1.member3 + # | | | | ^^^^^^^ -> class1:member3 + # | | ^^^^^^ -> func:class1 + # ^^^^^^ func:class1:value2 -> func:class1:value2 + print(value1, value2) + # | | ^^^^^^ -> func:class1:value2 + # ^^^^^^ -> func:class1:value1 + + var inner3 = Inner3.new() + # | | | | ^^^ -> class3:init + # | | ^^^^^^ -> class3 + # ^^^^^^ func:class3 -> func:class3 + print(inner3) + # ^^^^^^ -> func:class3 + + var nested1 = Inner3.NestedInInner3.new() + # | | | | ^^^^^^^^^^^^^^ -> class3:nested1 + # | | ^^^^^^ -> class3 + # ^^^^^^^ func:class3:nested1 -> func:class3:nested1 + var value_nested1 = nested1.some_value + # | | | | ^^^^^^^^^^ -> class3:nested1:some_value + # | | ^^^^^^^ -> func:class3:nested1 + # ^^^^^^^^^^^^^ func:class3:nested1:value + print(value_nested1) + # ^^^^^^^^^^^^^ -> func:class3:nested1:value + + var nested2 = Inner3.AnotherNestedInInner3.new() + # | | | | ^^^^^^^^^^^^^^^^^^^^^ -> class3:nested2 + # | | ^^^^^^ -> class3 + # ^^^^^^^ func:class3:nested2 -> func:class3:nested2 + var value_nested2 = nested2.some_value + # | | | | ^^^^^^^^^^ -> class3:nested1:some_value + # | | ^^^^^^^ -> func:class3:nested2 + # ^^^^^^^^^^^^^ func:class3:nested2:value + var another_value_nested2 = nested2.another_value + # | | | | ^^^^^^^^^^^^^ -> class3:nested2:another_value + # | | ^^^^^^^ -> func:class3:nested2 + # ^^^^^^^^^^^^^^^^^^^^^ func:class3:nested2:another_value_nested + print(value_nested2, another_value_nested2) + # | | ^^^^^^^^^^^^^^^^^^^^^ -> func:class3:nested2:another_value_nested + # ^^^^^^^^^^^^^ -> func:class3:nested2:value diff --git a/modules/gdscript/tests/scripts/lsp/enums.notest.gd b/modules/gdscript/tests/scripts/lsp/enums.notest.gd new file mode 100644 index 0000000000..38b9ec110a --- /dev/null +++ b/modules/gdscript/tests/scripts/lsp/enums.notest.gd @@ -0,0 +1,26 @@ +extends Node + +enum {UNIT_NEUTRAL, UNIT_ENEMY, UNIT_ALLY} +# | | | | ^^^^^^^^^ enum:unnamed:ally -> enum:unnamed:ally +# | | ^^^^^^^^^^ enum:unnamed:enemy -> enum:unnamed:enemy +# ^^^^^^^^^^^^ enum:unnamed:neutral -> enum:unnamed:neutral +enum Named {THING_1, THING_2, ANOTHER_THING = -1} +# | | | | | | ^^^^^^^^^^^^^ enum:named:thing3 -> enum:named:thing3 +# | | | | ^^^^^^^ enum:named:thing2 -> enum:named:thing2 +# | | ^^^^^^^ enum:named:thing1 -> enum:named:thing1 +# ^^^^^ enum:named -> enum:named + +func f(arg): + match arg: + UNIT_ENEMY: print(UNIT_ENEMY) + # | ^^^^^^^^^^ -> enum:unnamed:enemy + #<^^^^^^^^ -> enum:unnamed:enemy + Named.THING_2: print(Named.THING_2) + #! | | | | | ^^^^^^^ -> enum:named:thing2 + # | | | ^^^^^ -> enum:named + #! | ^^^^^^^ -> enum:named:thing2 + #<^^^ -> enum:named + _: print(UNIT_ENEMY, Named.ANOTHER_THING) + #! | | | | ^^^^^^^^^^^^^ -> enum:named:thing3 + # | | ^^^^^ -> enum:named + # ^^^^^^^^^^ -> enum:unnamed:enemy diff --git a/modules/gdscript/tests/scripts/lsp/indentation.notest.gd b/modules/gdscript/tests/scripts/lsp/indentation.notest.gd new file mode 100644 index 0000000000..c25d73a719 --- /dev/null +++ b/modules/gdscript/tests/scripts/lsp/indentation.notest.gd @@ -0,0 +1,28 @@ +extends Node + +var root = 0 +# ^^^^ 0_indent -> 0_indent + +func a(): + var alpha: int = root + 42 + # | | ^^^^ -> 0_indent + # ^^^^^ 1_indent -> 1_indent + if alpha > 42: + # ^^^^^ -> 1_indent + var beta := alpha + 13 + # | | ^^^^ -> 1_indent + # ^^^^ 2_indent -> 2_indent + if beta > alpha: + # | | ^^^^^ -> 1_indent + # ^^^^ -> 2_indent + var gamma = beta + 1 + # | | ^^^^ -> 2_indent + # ^^^^^ 3_indent -> 3_indent + print(gamma) + # ^^^^^ -> 3_indent + print(beta) + # ^^^^ -> 2_indent + print(alpha) + # ^^^^^ -> 1_indent + print(root) + # ^^^^ -> 0_indent diff --git a/modules/gdscript/tests/scripts/lsp/lambdas.notest.gd b/modules/gdscript/tests/scripts/lsp/lambdas.notest.gd new file mode 100644 index 0000000000..6f5d468eea --- /dev/null +++ b/modules/gdscript/tests/scripts/lsp/lambdas.notest.gd @@ -0,0 +1,91 @@ +extends Node + +var lambda_member1 := func(alpha: int, beta): return alpha + beta +# | | | | | | | | ^^^^ -> \1:beta +# | | | | | | ^^^^^ -> \1:alpha +# | | | | ^^^^ \1:beta -> \1:beta +# | | ^^^^^ \1:alpha -> \1:alpha +# ^^^^^^^^^^^^^^ \1 -> \1 + +var lambda_member2 := func(alpha, beta: int) -> int: +# | | | | | | +# | | | | | | +# | | | | ^^^^ \2:beta -> \2:beta +# | | ^^^^^ \2:alpha -> \2:alpha +# ^^^^^^^^^^^^^^ \2 -> \2 + return alpha + beta + # | | ^^^^ -> \2:beta + # ^^^^^ -> \2:alpha + +var lambda_member3 := func add_values(alpha, beta): return alpha + beta +# | | | | | | | | ^^^^ -> \3:beta +# | | | | | | ^^^^^ -> \3:alpha +# | | | | ^^^^ \3:beta -> \3:beta +# | | ^^^^^ \3:alpha -> \3:alpha +# ^^^^^^^^^^^^^^ \3 -> \3 + +var lambda_multiline = func(alpha: int, beta: int) -> int: +# | | | | | | +# | | | | | | +# | | | | ^^^^ \multi:beta -> \multi:beta +# | | ^^^^^ \multi:alpha -> \multi:alpha +# ^^^^^^^^^^^^^^^^ \multi -> \multi + print(alpha + beta) + # | | ^^^^ -> \multi:beta + # ^^^^^ -> \multi:alpha + var tmp = alpha + beta + 42 + # | | | | ^^^^ -> \multi:beta + # | | ^^^^^ -> \multi:alpha + # ^^^ \multi:tmp -> \multi:tmp + print(tmp) + # ^^^ -> \multi:tmp + if tmp > 50: + # ^^^ -> \multi:tmp + tmp += alpha + # | ^^^^^ -> \multi:alpha + #<^ -> \multi:tmp + else: + tmp -= beta + # | ^^^^ -> \multi:beta + #<^ -> \multi:tmp + print(tmp) + # ^^^ -> \multi:tmp + return beta + tmp + alpha + # | | | | ^^^^^ -> \multi:alpha + # | | ^^^ -> \multi:tmp + # ^^^^ -> \multi:beta + + +var some_name := "foo bar" +# ^^^^^^^^^ member:some_name -> member:some_name + +func _ready() -> void: + var a = lambda_member1.call(1,2) + # ^^^^^^^^^^^^^^ -> \1 + var b = lambda_member2.call(1,2) + # ^^^^^^^^^^^^^^ -> \2 + var c = lambda_member3.call(1,2) + # ^^^^^^^^^^^^^^ -> \3 + var d = lambda_multiline.call(1,2) + # ^^^^^^^^^^^^^^^^ -> \multi + print(a,b,c,d) + + var lambda_local = func(alpha, beta): return alpha + beta + # | | | | | | | | ^^^^ -> \local:beta + # | | | | | | ^^^^^ -> \local:alpha + # | | | | ^^^^ \local:beta -> \local:beta + # | | ^^^^^ \local:alpha -> \local:alpha + # ^^^^^^^^^^^^ \local -> \local + + var value := 42 + # ^^^^^ local:value -> local:value + var lambda_capture = func(): return value + some_name.length() + # | | | | ^^^^^^^^^ -> member:some_name + # | | ^^^^^ -> local:value + # ^^^^^^^^^^^^^^ \capture -> \capture + + var z = lambda_local.call(1,2) + # ^^^^^^^^^^^^ -> \local + var x = lambda_capture.call() + # ^^^^^^^^^^^^^^ -> \capture + print(z,x) diff --git a/modules/gdscript/tests/scripts/lsp/local_variables.notest.gd b/modules/gdscript/tests/scripts/lsp/local_variables.notest.gd new file mode 100644 index 0000000000..b6cc46f7da --- /dev/null +++ b/modules/gdscript/tests/scripts/lsp/local_variables.notest.gd @@ -0,0 +1,25 @@ +extends Node + +var member := 2 +# ^^^^^^ member -> member + +func test_member() -> void: + var test := member + 42 + # | | ^^^^^^ -> member + # ^^^^ test -> test + test += 3 + #<^^ -> test + member += 5 + #<^^^^ -> member + test = return_arg(test) + # | ^^^^ -> test + #<^^ -> test + print(test) + # ^^^^ -> test + +func return_arg(arg: int) -> int: +# ^^^ arg -> arg + arg += 2 + #<^ -> arg + return arg + # ^^^ -> arg
\ No newline at end of file diff --git a/modules/gdscript/tests/scripts/lsp/properties.notest.gd b/modules/gdscript/tests/scripts/lsp/properties.notest.gd new file mode 100644 index 0000000000..8dfaee2e5b --- /dev/null +++ b/modules/gdscript/tests/scripts/lsp/properties.notest.gd @@ -0,0 +1,65 @@ +extends Node + +var prop1 := 42 +# ^^^^^ prop1 -> prop1 +var prop2 : int = 42 +# ^^^^^ prop2 -> prop2 +var prop3 := 42: +# ^^^^^ prop3 -> prop3 + get: + return prop3 + 13 + # ^^^^^ -> prop3 + set(value): + # ^^^^^ prop3:value -> prop3:value + prop3 = value - 13 + # | ^^^^^ -> prop3:value + #<^^^ -> prop3 +var prop4: int: +# ^^^^^ prop4 -> prop4 + get: + return 42 +var prop5 := 42: +# ^^^^^ prop5 -> prop5 + set(value): + # ^^^^^ prop5:value -> prop5:value + prop5 = value - 13 + # | ^^^^^ -> prop5:value + #<^^^ -> prop5 + +var prop6: +# ^^^^^ prop6 -> prop6 + get = get_prop6, + # ^^^^^^^^^ -> get_prop6 + set = set_prop6 + # ^^^^^^^^^ -> set_prop6 +func get_prop6(): +# ^^^^^^^^^ get_prop6 -> get_prop6 + return 42 +func set_prop6(value): +# | | ^^^^^ set_prop6:value -> set_prop6:value +# ^^^^^^^^^ set_prop6 -> set_prop6 + print(value) + # ^^^^^ -> set_prop6:value + +var prop7: +# ^^^^^ prop7 -> prop7 + get = get_prop7 + # ^^^^^^^^^ -> get_prop7 +func get_prop7(): +# ^^^^^^^^^ get_prop7 -> get_prop7 + return 42 + +var prop8: +# ^^^^^ prop8 -> prop8 + set = set_prop8 + # ^^^^^^^^^ -> set_prop8 +func set_prop8(value): +# | | ^^^^^ set_prop8:value -> set_prop8:value +# ^^^^^^^^^ set_prop8 -> set_prop8 + print(value) + # ^^^^^ -> set_prop8:value + +const const_var := 42 +# ^^^^^^^^^ const_var -> const_var +static var static_var := 42 +# ^^^^^^^^^^ static_var -> static_var diff --git a/modules/gdscript/tests/scripts/lsp/scopes.notest.gd b/modules/gdscript/tests/scripts/lsp/scopes.notest.gd new file mode 100644 index 0000000000..20b8fb9bd7 --- /dev/null +++ b/modules/gdscript/tests/scripts/lsp/scopes.notest.gd @@ -0,0 +1,106 @@ +extends Node + +var member := 2 +# ^^^^^^ public -> public + +signal some_changed(new_value) +# | | ^^^^^^^^^ signal:parameter -> signal:parameter +# ^^^^^^^^^^^^ signal -> signal +var some_value := 42: +# ^^^^^^^^^^ property -> property + get: + return some_value + # ^^^^^^^^^^ -> property + set(value): + # ^^^^^ property:set:value -> property:set:value + some_changed.emit(value) + # | ^^^^^ -> property:set:value + #<^^^^^^^^^^ -> signal + some_value = value + # | ^^^^^ -> property:set:value + #<^^^^^^^^ -> property + +func v(): + var value := member + 2 + # | | ^^^^^^ -> public + # ^^^^^ v:value -> v:value + print(value) + # ^^^^^ -> v:value + if value > 0: + # ^^^^^ -> v:value + var beta := value + 2 + # | | ^^^^^ -> v:value + # ^^^^ v:if:beta -> v:if:beta + print(beta) + # ^^^^ -> v:if:beta + + for counter in beta: + # | | ^^^^ -> v:if:beta + # ^^^^^^^ v:if:counter -> v:if:counter + print (counter) + # ^^^^^^^ -> v:if:counter + + else: + for counter in value: + # | | ^^^^^ -> v:value + # ^^^^^^^ v:else:counter -> v:else:counter + print(counter) + # ^^^^^^^ -> v:else:counter + +func f(): + var func1 = func(value): print(value + 13) + # | | | | ^^^^^ -> f:func1:value + # | | ^^^^^ f:func1:value -> f:func1:value + # ^^^^^ f:func1 -> f:func1 + var func2 = func(value): print(value + 42) + # | | | | ^^^^^ -> f:func2:value + # | | ^^^^^ f:func2:value -> f:func2:value + # ^^^^^ f:func2 -> f:func2 + + func1.call(1) + #<^^^ -> f:func1 + func2.call(2) + #<^^^ -> f:func2 + +func m(): + var value = 42 + # ^^^^^ m:value -> m:value + + match value: + # ^^^^^ -> m:value + 13: + print(value) + # ^^^^^ -> m:value + [var start, _, var end]: + # | | ^^^ m:match:array:end -> m:match:array:end + # ^^^^^ m:match:array:start -> m:match:array:start + print(start + end) + # | | ^^^ -> m:match:array:end + # ^^^^^ -> m:match:array:start + { "name": var name }: + # ^^^^ m:match:dict:var -> m:match:dict:var + print(name) + # ^^^^ -> m:match:dict:var + var whatever: + # ^^^^^^^^ m:match:var -> m:match:var + print(whatever) + # ^^^^^^^^ -> m:match:var + +func m2(): + var value = 42 + # ^^^^^ m2:value -> m2:value + + match value: + # ^^^^^ -> m2:value + { "name": var name }: + # ^^^^ m2:match:dict:var -> m2:match:dict:var + print(name) + # ^^^^ -> m2:match:dict:var + [var name, ..]: + # ^^^^ m2:match:array:var -> m2:match:array:var + print(name) + # ^^^^ -> m2:match:array:var + var name: + # ^^^^ m2:match:var -> m2:match:var + print(name) + # ^^^^ -> m2:match:var diff --git a/modules/gdscript/tests/scripts/lsp/shadowing_initializer.notest.gd b/modules/gdscript/tests/scripts/lsp/shadowing_initializer.notest.gd new file mode 100644 index 0000000000..338000fa0e --- /dev/null +++ b/modules/gdscript/tests/scripts/lsp/shadowing_initializer.notest.gd @@ -0,0 +1,56 @@ +extends Node + +var value := 42 +# ^^^^^ member:value -> member:value + +func variable(): + var value = value + 42 + #! | | ^^^^^ -> member:value + # ^^^^^ variable:value -> variable:value + print(value) + # ^^^^^ -> variable:value + +func array(): + var value = [1,value,3,value+4] + #! | | | | ^^^^^ -> member:value + #! | | ^^^^^ -> member:value + # ^^^^^ array:value -> array:value + print(value) + # ^^^^^ -> array:value + +func dictionary(): + var value = { + # ^^^^^ dictionary:value -> dictionary:value + "key1": value, + #! ^^^^^ -> member:value + "key2": 1 + value + 3, + #! ^^^^^ -> member:value + } + print(value) + # ^^^^^ -> dictionary:value + +func for_loop(): + for value in value: + # | | ^^^^^ -> member:value + # ^^^^^ for:value -> for:value + print(value) + # ^^^^^ -> for:value + +func for_range(): + for value in range(5, value): + # | | ^^^^^ -> member:value + # ^^^^^ for:range:value -> for:range:value + print(value) + # ^^^^^ -> for:range:value + +func matching(): + match value: + # ^^^^^ -> member:value + 42: print(value) + # ^^^^^ -> member:value + [var value, ..]: print(value) + # | | ^^^^^ -> match:array:value + # ^^^^^ match:array:value -> match:array:value + var value: print(value) + # | | ^^^^^ -> match:var:value + # ^^^^^ match:var:value -> match:var:value diff --git a/modules/gdscript/tests/scripts/runtime/features/member_info.gd b/modules/gdscript/tests/scripts/runtime/features/member_info.gd new file mode 100644 index 0000000000..50f840cef3 --- /dev/null +++ b/modules/gdscript/tests/scripts/runtime/features/member_info.gd @@ -0,0 +1,125 @@ +class_name TestMemberInfo + +class MyClass: + pass + +enum MyEnum {} + +static var test_static_var_untyped +static var test_static_var_weak_null = null +static var test_static_var_weak_int = 1 +static var test_static_var_hard_int: int + +var test_var_untyped +var test_var_weak_null = null +var test_var_weak_int = 1 +@export var test_var_weak_int_exported = 1 +var test_var_weak_variant_type = TYPE_NIL +@export var test_var_weak_variant_type_exported = TYPE_NIL +var test_var_hard_variant: Variant +var test_var_hard_int: int +var test_var_hard_variant_type: Variant.Type +@export var test_var_hard_variant_type_exported: Variant.Type +var test_var_hard_node_process_mode: Node.ProcessMode +var test_var_hard_my_enum: MyEnum +var test_var_hard_array: Array +var test_var_hard_array_int: Array[int] +var test_var_hard_array_variant_type: Array[Variant.Type] +var test_var_hard_array_node_process_mode: Array[Node.ProcessMode] +var test_var_hard_array_my_enum: Array[MyEnum] +var test_var_hard_array_resource: Array[Resource] +var test_var_hard_array_this: Array[TestMemberInfo] +var test_var_hard_array_my_class: Array[MyClass] +var test_var_hard_resource: Resource +var test_var_hard_this: TestMemberInfo +var test_var_hard_my_class: MyClass + +static func test_static_func(): pass + +func test_func_implicit_void(): pass +func test_func_explicit_void() -> void: pass +func test_func_weak_null(): return null +func test_func_weak_int(): return 1 +func test_func_hard_variant() -> Variant: return null +func test_func_hard_int() -> int: return 1 +func test_func_args_1(_a: int, _b: Array[int], _c: int = 1, _d = 2): pass +func test_func_args_2(_a = 1, _b = _a, _c = [2], _d = 3): pass + +signal test_signal_1() +signal test_signal_2(a: Variant, b) +signal test_signal_3(a: int, b: Array[int]) +signal test_signal_4(a: Variant.Type, b: Array[Variant.Type]) +signal test_signal_5(a: MyEnum, b: Array[MyEnum]) +signal test_signal_6(a: Resource, b: Array[Resource]) +signal test_signal_7(a: TestMemberInfo, b: Array[TestMemberInfo]) +signal test_signal_8(a: MyClass, b: Array[MyClass]) + +func test(): + var script: Script = get_script() + for property in script.get_property_list(): + if str(property.name).begins_with("test_"): + if not (property.usage & PROPERTY_USAGE_SCRIPT_VARIABLE): + print("Error: Missing `PROPERTY_USAGE_SCRIPT_VARIABLE` flag.") + print("static var ", property.name, ": ", get_type(property)) + for property in get_property_list(): + if str(property.name).begins_with("test_"): + if not (property.usage & PROPERTY_USAGE_SCRIPT_VARIABLE): + print("Error: Missing `PROPERTY_USAGE_SCRIPT_VARIABLE` flag.") + print("var ", property.name, ": ", get_type(property)) + for method in get_method_list(): + if str(method.name).begins_with("test_"): + print(get_signature(method)) + for method in get_signal_list(): + if str(method.name).begins_with("test_"): + print(get_signature(method, true)) + +func get_type(property: Dictionary, is_return: bool = false) -> String: + match property.type: + TYPE_NIL: + if property.usage & PROPERTY_USAGE_NIL_IS_VARIANT: + return "Variant" + return "void" if is_return else "null" + TYPE_BOOL: + return "bool" + TYPE_INT: + if property.usage & PROPERTY_USAGE_CLASS_IS_ENUM: + return property.class_name + return "int" + TYPE_STRING: + return "String" + TYPE_DICTIONARY: + return "Dictionary" + TYPE_ARRAY: + if property.hint == PROPERTY_HINT_ARRAY_TYPE: + return "Array[%s]" % property.hint_string + return "Array" + TYPE_OBJECT: + if not str(property.class_name).is_empty(): + return property.class_name + return "Object" + return "<error>" + +func get_signature(method: Dictionary, is_signal: bool = false) -> String: + var result: String = "" + if method.flags & METHOD_FLAG_STATIC: + result += "static " + result += ("signal " if is_signal else "func ") + method.name + "(" + + var args: Array[Dictionary] = method.args + var default_args: Array = method.default_args + var mandatory_argc: int = args.size() - default_args.size() + for i in args.size(): + if i > 0: + result += ", " + var arg: Dictionary = args[i] + result += arg.name + ": " + get_type(arg) + if i >= mandatory_argc: + result += " = " + var_to_str(default_args[i - mandatory_argc]) + + result += ")" + if is_signal: + if get_type(method.return, true) != "void": + print("Error: Signal return type must be `void`.") + else: + result += " -> " + get_type(method.return, true) + return result diff --git a/modules/gdscript/tests/scripts/runtime/features/member_info.out b/modules/gdscript/tests/scripts/runtime/features/member_info.out new file mode 100644 index 0000000000..7c826ac05a --- /dev/null +++ b/modules/gdscript/tests/scripts/runtime/features/member_info.out @@ -0,0 +1,45 @@ +GDTEST_OK +static var test_static_var_untyped: Variant +static var test_static_var_weak_null: Variant +static var test_static_var_weak_int: Variant +static var test_static_var_hard_int: int +var test_var_untyped: Variant +var test_var_weak_null: Variant +var test_var_weak_int: Variant +var test_var_weak_int_exported: int +var test_var_weak_variant_type: Variant +var test_var_weak_variant_type_exported: Variant.Type +var test_var_hard_variant: Variant +var test_var_hard_int: int +var test_var_hard_variant_type: Variant.Type +var test_var_hard_variant_type_exported: Variant.Type +var test_var_hard_node_process_mode: Node.ProcessMode +var test_var_hard_my_enum: TestMemberInfo.MyEnum +var test_var_hard_array: Array +var test_var_hard_array_int: Array[int] +var test_var_hard_array_variant_type: Array[Variant.Type] +var test_var_hard_array_node_process_mode: Array[Node.ProcessMode] +var test_var_hard_array_my_enum: Array[TestMemberInfo.MyEnum] +var test_var_hard_array_resource: Array[Resource] +var test_var_hard_array_this: Array[TestMemberInfo] +var test_var_hard_array_my_class: Array[RefCounted] +var test_var_hard_resource: Resource +var test_var_hard_this: TestMemberInfo +var test_var_hard_my_class: RefCounted +static func test_static_func() -> void +func test_func_implicit_void() -> void +func test_func_explicit_void() -> void +func test_func_weak_null() -> Variant +func test_func_weak_int() -> Variant +func test_func_hard_variant() -> Variant +func test_func_hard_int() -> int +func test_func_args_1(_a: int, _b: Array[int], _c: int = 1, _d: Variant = 2) -> void +func test_func_args_2(_a: Variant = 1, _b: Variant = null, _c: Variant = null, _d: Variant = 3) -> void +signal test_signal_1() +signal test_signal_2(a: Variant, b: Variant) +signal test_signal_3(a: int, b: Array[int]) +signal test_signal_4(a: Variant.Type, b: Array[Variant.Type]) +signal test_signal_5(a: TestMemberInfo.MyEnum, b: Array[TestMemberInfo.MyEnum]) +signal test_signal_6(a: Resource, b: Array[Resource]) +signal test_signal_7(a: TestMemberInfo, b: Array[TestMemberInfo]) +signal test_signal_8(a: RefCounted, b: Array[RefCounted]) diff --git a/modules/gdscript/tests/test_gdscript.cpp b/modules/gdscript/tests/test_gdscript.cpp index 0446a7aad6..b86a8b3cb1 100644 --- a/modules/gdscript/tests/test_gdscript.cpp +++ b/modules/gdscript/tests/test_gdscript.cpp @@ -138,12 +138,13 @@ static void recursively_disassemble_functions(const Ref<GDScript> script, const for (const KeyValue<StringName, GDScriptFunction *> &E : script->get_member_functions()) { const GDScriptFunction *func = E.value; - String signature = "Disassembling " + func->get_name().operator String() + "("; - for (int i = 0; i < func->get_argument_count(); i++) { + const MethodInfo &mi = func->get_method_info(); + String signature = "Disassembling " + mi.name + "("; + for (int i = 0; i < mi.arguments.size(); i++) { if (i > 0) { signature += ", "; } - signature += func->get_argument_name(i); + signature += mi.arguments[i].name; } print_line(signature + ")"); #ifdef TOOLS_ENABLED @@ -156,7 +157,7 @@ static void recursively_disassemble_functions(const Ref<GDScript> script, const for (const KeyValue<StringName, Ref<GDScript>> &F : script->get_subclasses()) { const Ref<GDScript> inner_script = F.value; print_line(""); - print_line(vformat("Inner Class: %s", inner_script->get_script_class_name())); + print_line(vformat("Inner Class: %s", inner_script->get_local_name())); print_line(""); recursively_disassemble_functions(inner_script, p_lines); } diff --git a/modules/gdscript/tests/test_lsp.h b/modules/gdscript/tests/test_lsp.h new file mode 100644 index 0000000000..e57df00e2d --- /dev/null +++ b/modules/gdscript/tests/test_lsp.h @@ -0,0 +1,480 @@ +/**************************************************************************/ +/* test_lsp.h */ +/**************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* https://godotengine.org */ +/**************************************************************************/ +/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* 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 TEST_LSP_H +#define TEST_LSP_H + +#ifdef TOOLS_ENABLED + +#include "tests/test_macros.h" + +#include "../language_server/gdscript_extend_parser.h" +#include "../language_server/gdscript_language_protocol.h" +#include "../language_server/gdscript_workspace.h" +#include "../language_server/godot_lsp.h" + +#include "core/io/dir_access.h" +#include "core/io/file_access_pack.h" +#include "core/os/os.h" +#include "editor/editor_help.h" +#include "editor/editor_node.h" +#include "modules/gdscript/gdscript_analyzer.h" +#include "modules/regex/regex.h" + +#include "thirdparty/doctest/doctest.h" + +template <> +struct doctest::StringMaker<lsp::Position> { + static doctest::String convert(const lsp::Position &p_val) { + return p_val.to_string().utf8().get_data(); + } +}; + +template <> +struct doctest::StringMaker<lsp::Range> { + static doctest::String convert(const lsp::Range &p_val) { + return p_val.to_string().utf8().get_data(); + } +}; + +template <> +struct doctest::StringMaker<GodotPosition> { + static doctest::String convert(const GodotPosition &p_val) { + return p_val.to_string().utf8().get_data(); + } +}; + +namespace GDScriptTests { + +// LSP GDScript test scripts are located inside project of other GDScript tests: +// Cannot reset `ProjectSettings` (singleton) -> Cannot load another workspace and resources in there. +// -> Reuse GDScript test project. LSP specific scripts are then placed inside `lsp` folder. +// Access via `res://lsp/my_script.notest.gd`. +const String root = "modules/gdscript/tests/scripts/"; + +/* + * After use: + * * `memdelete` returned `GDScriptLanguageProtocol`. + * * Call `GDScriptTests::::finish_language`. + */ +GDScriptLanguageProtocol *initialize(const String &p_root) { + Error err = OK; + Ref<DirAccess> dir(DirAccess::open(p_root, &err)); + REQUIRE_MESSAGE(err == OK, "Could not open specified root directory"); + String absolute_root = dir->get_current_dir(); + init_language(absolute_root); + + GDScriptLanguageProtocol *proto = memnew(GDScriptLanguageProtocol); + + Ref<GDScriptWorkspace> workspace = GDScriptLanguageProtocol::get_singleton()->get_workspace(); + workspace->root = absolute_root; + // On windows: `C:/...` -> `C%3A/...`. + workspace->root_uri = "file:///" + absolute_root.lstrip("/").replace_first(":", "%3A"); + + return proto; +} + +lsp::Position pos(const int p_line, const int p_character) { + lsp::Position p; + p.line = p_line; + p.character = p_character; + return p; +} + +lsp::Range range(const lsp::Position p_start, const lsp::Position p_end) { + lsp::Range r; + r.start = p_start; + r.end = p_end; + return r; +} + +lsp::TextDocumentPositionParams pos_in(const lsp::DocumentUri &p_uri, const lsp::Position p_pos) { + lsp::TextDocumentPositionParams params; + params.textDocument.uri = p_uri; + params.position = p_pos; + return params; +} + +const lsp::DocumentSymbol *test_resolve_symbol_at(const String &p_uri, const lsp::Position p_pos, const String &p_expected_uri, const String &p_expected_name, const lsp::Range &p_expected_range) { + Ref<GDScriptWorkspace> workspace = GDScriptLanguageProtocol::get_singleton()->get_workspace(); + + lsp::TextDocumentPositionParams params = pos_in(p_uri, p_pos); + const lsp::DocumentSymbol *symbol = workspace->resolve_symbol(params); + CHECK(symbol); + + if (symbol) { + CHECK_EQ(symbol->uri, p_expected_uri); + CHECK_EQ(symbol->name, p_expected_name); + CHECK_EQ(symbol->selectionRange, p_expected_range); + } + + return symbol; +} + +struct InlineTestData { + lsp::Range range; + String text; + String name; + String ref; + + static bool try_parse(const Vector<String> &p_lines, const int p_line_number, InlineTestData &r_data) { + String line = p_lines[p_line_number]; + + RegEx regex = RegEx("^\\t*#[ |]*(?<range>(?<left><)?\\^+)(\\s+(?<name>(?!->)\\S+))?(\\s+->\\s+(?<ref>\\S+))?"); + Ref<RegExMatch> match = regex.search(line); + if (match.is_null()) { + return false; + } + + // Find first line without leading comment above current line. + int target_line = p_line_number; + while (target_line >= 0) { + String dedented = p_lines[target_line].lstrip("\t"); + if (!dedented.begins_with("#")) { + break; + } + target_line--; + } + if (target_line < 0) { + return false; + } + r_data.range.start.line = r_data.range.end.line = target_line; + + String marker = match->get_string("range"); + int i = line.find(marker); + REQUIRE(i >= 0); + r_data.range.start.character = i; + if (!match->get_string("left").is_empty()) { + // Include `#` (comment char) in range. + r_data.range.start.character--; + } + r_data.range.end.character = i + marker.length(); + + String target = p_lines[target_line]; + r_data.text = target.substr(r_data.range.start.character, r_data.range.end.character - r_data.range.start.character); + + r_data.name = match->get_string("name"); + r_data.ref = match->get_string("ref"); + + return true; + } +}; + +Vector<InlineTestData> read_tests(const String &p_path) { + Error err; + String source = FileAccess::get_file_as_string(p_path, &err); + REQUIRE_MESSAGE(err == OK, vformat("Cannot read '%s'", p_path)); + + // Format: + // ```gdscript + // var foo = bar + baz + // # | | | | ^^^ name -> ref + // # | | ^^^ -> ref + // # ^^^ name + // + // func my_func(): + // # ^^^^^^^ name + // var value = foo + 42 + // # ^^^^^ name + // print(value) + // # ^^^^^ -> ref + // ``` + // + // * `^`: Range marker. + // * `name`: Unique name. Can contain any characters except whitespace chars. + // * `ref`: Reference to unique name. + // + // Notes: + // * If range should include first content-char (which is occupied by `#`): use `<` for next marker. + // -> Range expands 1 to left (-> includes `#`). + // * Note: Means: Range cannot be single char directly marked by `#`, but must be at least two chars (marked with `#<`). + // * Comment must start at same ident as line its marked (-> because of tab alignment...). + // * Use spaces to align after `#`! -> for correct alignment + // * Between `#` and `^` can be spaces or `|` (to better visualize what's marked below). + PackedStringArray lines = source.split("\n"); + + PackedStringArray names; + Vector<InlineTestData> data; + for (int i = 0; i < lines.size(); i++) { + InlineTestData d; + if (InlineTestData::try_parse(lines, i, d)) { + if (!d.name.is_empty()) { + // Safety check: names must be unique. + if (names.find(d.name) != -1) { + FAIL(vformat("Duplicated name '%s' in '%s'. Names must be unique!", d.name, p_path)); + } + names.append(d.name); + } + + data.append(d); + } + } + + return data; +} + +void test_resolve_symbol(const String &p_uri, const InlineTestData &p_test_data, const Vector<InlineTestData> &p_all_data) { + if (p_test_data.ref.is_empty()) { + return; + } + + SUBCASE(vformat("Can resolve symbol '%s' at %s to '%s'", p_test_data.text, p_test_data.range.to_string(), p_test_data.ref).utf8().get_data()) { + const InlineTestData *target = nullptr; + for (int i = 0; i < p_all_data.size(); i++) { + if (p_all_data[i].name == p_test_data.ref) { + target = &p_all_data[i]; + break; + } + } + REQUIRE_MESSAGE(target, vformat("No target for ref '%s'", p_test_data.ref)); + + Ref<GDScriptWorkspace> workspace = GDScriptLanguageProtocol::get_singleton()->get_workspace(); + lsp::Position pos = p_test_data.range.start; + + SUBCASE("start of identifier") { + pos.character = p_test_data.range.start.character; + test_resolve_symbol_at(p_uri, pos, p_uri, target->text, target->range); + } + + SUBCASE("inside identifier") { + pos.character = (p_test_data.range.end.character + p_test_data.range.start.character) / 2; + test_resolve_symbol_at(p_uri, pos, p_uri, target->text, target->range); + } + + SUBCASE("end of identifier") { + pos.character = p_test_data.range.end.character; + test_resolve_symbol_at(p_uri, pos, p_uri, target->text, target->range); + } + } +} + +Vector<InlineTestData> filter_ref_towards(const Vector<InlineTestData> &p_data, const String &p_name) { + Vector<InlineTestData> res; + + for (const InlineTestData &d : p_data) { + if (d.ref == p_name) { + res.append(d); + } + } + + return res; +} + +void test_resolve_symbols(const String &p_uri, const Vector<InlineTestData> &p_test_data, const Vector<InlineTestData> &p_all_data) { + for (const InlineTestData &d : p_test_data) { + test_resolve_symbol(p_uri, d, p_all_data); + } +} + +void assert_no_errors_in(const String &p_path) { + Error err; + String source = FileAccess::get_file_as_string(p_path, &err); + REQUIRE_MESSAGE(err == OK, vformat("Cannot read '%s'", p_path)); + + GDScriptParser parser; + err = parser.parse(source, p_path, true); + REQUIRE_MESSAGE(err == OK, vformat("Errors while parsing '%s'", p_path)); + + GDScriptAnalyzer analyzer(&parser); + err = analyzer.analyze(); + REQUIRE_MESSAGE(err == OK, vformat("Errors while analyzing '%s'", p_path)); +} + +inline lsp::Position lsp_pos(int line, int character) { + lsp::Position p; + p.line = line; + p.character = character; + return p; +} + +void test_position_roundtrip(lsp::Position p_lsp, GodotPosition p_gd, const PackedStringArray &p_lines) { + GodotPosition actual_gd = GodotPosition::from_lsp(p_lsp, p_lines); + CHECK_EQ(p_gd, actual_gd); + lsp::Position actual_lsp = p_gd.to_lsp(p_lines); + CHECK_EQ(p_lsp, actual_lsp); +} + +// Note: +// * Cursor is BETWEEN chars +// * `va|r` -> cursor between `a`&`r` +// * `var` +// ^ +// -> Character on `r` -> cursor between `a`&`r`s for tests: +// * Line & Char: +// * LSP: both 0-based +// * Godot: both 1-based +TEST_SUITE("[Modules][GDScript][LSP]") { + TEST_CASE("Can convert positions to and from Godot") { + String code = R"(extends Node + +var member := 42 + +func f(): + var value := 42 + return value + member)"; + PackedStringArray lines = code.split("\n"); + + SUBCASE("line after end") { + lsp::Position lsp = lsp_pos(7, 0); + GodotPosition gd(8, 1); + test_position_roundtrip(lsp, gd, lines); + } + SUBCASE("first char in first line") { + lsp::Position lsp = lsp_pos(0, 0); + GodotPosition gd(1, 1); + test_position_roundtrip(lsp, gd, lines); + } + + SUBCASE("with tabs") { + // On `v` in `value` in `var value := ...`. + lsp::Position lsp = lsp_pos(5, 6); + GodotPosition gd(6, 13); + test_position_roundtrip(lsp, gd, lines); + } + + SUBCASE("doesn't fail with column outside of character length") { + lsp::Position lsp = lsp_pos(2, 100); + GodotPosition::from_lsp(lsp, lines); + + GodotPosition gd(3, 100); + gd.to_lsp(lines); + } + + SUBCASE("doesn't fail with line outside of line length") { + lsp::Position lsp = lsp_pos(200, 100); + GodotPosition::from_lsp(lsp, lines); + + GodotPosition gd(300, 100); + gd.to_lsp(lines); + } + + SUBCASE("special case: negative line for root class") { + GodotPosition gd(-1, 0); + lsp::Position expected = lsp_pos(0, 0); + lsp::Position actual = gd.to_lsp(lines); + CHECK_EQ(actual, expected); + } + SUBCASE("special case: lines.length() + 1 for root class") { + GodotPosition gd(lines.size() + 1, 0); + lsp::Position expected = lsp_pos(lines.size(), 0); + lsp::Position actual = gd.to_lsp(lines); + CHECK_EQ(actual, expected); + } + } + TEST_CASE("[workspace][resolve_symbol]") { + GDScriptLanguageProtocol *proto = initialize(root); + REQUIRE(proto); + Ref<GDScriptWorkspace> workspace = GDScriptLanguageProtocol::get_singleton()->get_workspace(); + + { + String path = "res://lsp/local_variables.notest.gd"; + assert_no_errors_in(path); + String uri = workspace->get_file_uri(path); + Vector<InlineTestData> all_test_data = read_tests(path); + SUBCASE("Can get correct ranges for public variables") { + Vector<InlineTestData> test_data = filter_ref_towards(all_test_data, "member"); + test_resolve_symbols(uri, test_data, all_test_data); + } + SUBCASE("Can get correct ranges for local variables") { + Vector<InlineTestData> test_data = filter_ref_towards(all_test_data, "test"); + test_resolve_symbols(uri, test_data, all_test_data); + } + SUBCASE("Can get correct ranges for local parameters") { + Vector<InlineTestData> test_data = filter_ref_towards(all_test_data, "arg"); + test_resolve_symbols(uri, test_data, all_test_data); + } + } + + SUBCASE("Can get correct ranges for indented variables") { + String path = "res://lsp/indentation.notest.gd"; + assert_no_errors_in(path); + String uri = workspace->get_file_uri(path); + Vector<InlineTestData> all_test_data = read_tests(path); + test_resolve_symbols(uri, all_test_data, all_test_data); + } + + SUBCASE("Can get correct ranges for scopes") { + String path = "res://lsp/scopes.notest.gd"; + assert_no_errors_in(path); + String uri = workspace->get_file_uri(path); + Vector<InlineTestData> all_test_data = read_tests(path); + test_resolve_symbols(uri, all_test_data, all_test_data); + } + + SUBCASE("Can get correct ranges for lambda") { + String path = "res://lsp/lambdas.notest.gd"; + assert_no_errors_in(path); + String uri = workspace->get_file_uri(path); + Vector<InlineTestData> all_test_data = read_tests(path); + test_resolve_symbols(uri, all_test_data, all_test_data); + } + + SUBCASE("Can get correct ranges for inner class") { + String path = "res://lsp/class.notest.gd"; + assert_no_errors_in(path); + String uri = workspace->get_file_uri(path); + Vector<InlineTestData> all_test_data = read_tests(path); + test_resolve_symbols(uri, all_test_data, all_test_data); + } + + SUBCASE("Can get correct ranges for inner class") { + String path = "res://lsp/enums.notest.gd"; + assert_no_errors_in(path); + String uri = workspace->get_file_uri(path); + Vector<InlineTestData> all_test_data = read_tests(path); + test_resolve_symbols(uri, all_test_data, all_test_data); + } + + SUBCASE("Can get correct ranges for shadowing & shadowed variables") { + String path = "res://lsp/shadowing_initializer.notest.gd"; + assert_no_errors_in(path); + String uri = workspace->get_file_uri(path); + Vector<InlineTestData> all_test_data = read_tests(path); + test_resolve_symbols(uri, all_test_data, all_test_data); + } + + SUBCASE("Can get correct ranges for properties and getter/setter") { + String path = "res://lsp/properties.notest.gd"; + assert_no_errors_in(path); + String uri = workspace->get_file_uri(path); + Vector<InlineTestData> all_test_data = read_tests(path); + test_resolve_symbols(uri, all_test_data, all_test_data); + } + + memdelete(proto); + finish_language(); + } +} + +} // namespace GDScriptTests + +#endif // TOOLS_ENABLED + +#endif // TEST_LSP_H diff --git a/modules/openxr/action_map/openxr_action_map.cpp b/modules/openxr/action_map/openxr_action_map.cpp index 652e5fc407..6d79e33de8 100644 --- a/modules/openxr/action_map/openxr_action_map.cpp +++ b/modules/openxr/action_map/openxr_action_map.cpp @@ -470,6 +470,7 @@ void OpenXRActionMap::create_default_action_sets() { profile->add_new_binding(primary_click, "/user/hand/left/input/trackpad/click,/user/hand/right/input/trackpad/click"); profile->add_new_binding(primary_touch, "/user/hand/left/input/trackpad/touch,/user/hand/right/input/trackpad/touch"); profile->add_new_binding(haptic, "/user/hand/left/output/haptic,/user/hand/right/output/haptic"); + add_interaction_profile(profile); // Create our HTC Vive tracker profile profile = OpenXRInteractionProfile::new_profile("/interaction_profiles/htc/vive_tracker_htcx"); diff --git a/modules/openxr/openxr_api.h b/modules/openxr/openxr_api.h index 2498cd1eb4..6d1c731e7a 100644 --- a/modules/openxr/openxr_api.h +++ b/modules/openxr/openxr_api.h @@ -289,7 +289,7 @@ private: bool on_state_loss_pending(); bool on_state_exiting(); - // convencience + // convenience void copy_string_to_char_buffer(const String p_string, char *p_buffer, int p_buffer_len); public: diff --git a/modules/zip/zip_packer.cpp b/modules/zip/zip_packer.cpp index c8b4fb4e77..5f623476fc 100644 --- a/modules/zip/zip_packer.cpp +++ b/modules/zip/zip_packer.cpp @@ -33,7 +33,7 @@ #include "core/io/zip_io.h" #include "core/os/os.h" -Error ZIPPacker::open(String p_path, ZipAppend p_append) { +Error ZIPPacker::open(const String &p_path, ZipAppend p_append) { if (fa.is_valid()) { close(); } @@ -55,7 +55,7 @@ Error ZIPPacker::close() { return err; } -Error ZIPPacker::start_file(String p_path) { +Error ZIPPacker::start_file(const String &p_path) { ERR_FAIL_COND_V_MSG(fa.is_null(), FAILED, "ZIPPacker must be opened before use."); zip_fileinfo zipfi; @@ -76,7 +76,7 @@ Error ZIPPacker::start_file(String p_path) { return err == ZIP_OK ? OK : FAILED; } -Error ZIPPacker::write_file(Vector<uint8_t> p_data) { +Error ZIPPacker::write_file(const Vector<uint8_t> &p_data) { ERR_FAIL_COND_V_MSG(fa.is_null(), FAILED, "ZIPPacker must be opened before use."); return zipWriteInFileInZip(zf, p_data.ptr(), p_data.size()) == ZIP_OK ? OK : FAILED; diff --git a/modules/zip/zip_packer.h b/modules/zip/zip_packer.h index 142d0fddbf..e194f5ebbe 100644 --- a/modules/zip/zip_packer.h +++ b/modules/zip/zip_packer.h @@ -52,11 +52,11 @@ public: APPEND_ADDINZIP = 2, }; - Error open(String p_path, ZipAppend p_append); + Error open(const String &p_path, ZipAppend p_append); Error close(); - Error start_file(String p_path); - Error write_file(Vector<uint8_t> p_data); + Error start_file(const String &p_path); + Error write_file(const Vector<uint8_t> &p_data); Error close_file(); ZIPPacker(); diff --git a/modules/zip/zip_reader.cpp b/modules/zip/zip_reader.cpp index 5752b829ef..f4a92dce5b 100644 --- a/modules/zip/zip_reader.cpp +++ b/modules/zip/zip_reader.cpp @@ -33,7 +33,7 @@ #include "core/error/error_macros.h" #include "core/io/zip_io.h" -Error ZIPReader::open(String p_path) { +Error ZIPReader::open(const String &p_path) { if (fa.is_valid()) { close(); } @@ -81,7 +81,7 @@ PackedStringArray ZIPReader::get_files() { return arr; } -PackedByteArray ZIPReader::read_file(String p_path, bool p_case_sensitive) { +PackedByteArray ZIPReader::read_file(const String &p_path, bool p_case_sensitive) { ERR_FAIL_COND_V_MSG(fa.is_null(), PackedByteArray(), "ZIPReader must be opened before use."); int err = UNZ_OK; @@ -118,7 +118,7 @@ PackedByteArray ZIPReader::read_file(String p_path, bool p_case_sensitive) { return data; } -bool ZIPReader::file_exists(String p_path, bool p_case_sensitive) { +bool ZIPReader::file_exists(const String &p_path, bool p_case_sensitive) { ERR_FAIL_COND_V_MSG(fa.is_null(), false, "ZIPReader must be opened before use."); int cs = p_case_sensitive ? 1 : 2; diff --git a/modules/zip/zip_reader.h b/modules/zip/zip_reader.h index 0f78352e3f..874bd81ed3 100644 --- a/modules/zip/zip_reader.h +++ b/modules/zip/zip_reader.h @@ -46,12 +46,12 @@ protected: static void _bind_methods(); public: - Error open(String p_path); + Error open(const String &p_path); Error close(); PackedStringArray get_files(); - PackedByteArray read_file(String p_path, bool p_case_sensitive); - bool file_exists(String p_path, bool p_case_sensitive); + PackedByteArray read_file(const String &p_path, bool p_case_sensitive); + bool file_exists(const String &p_path, bool p_case_sensitive); ZIPReader(); ~ZIPReader(); |