asgardius/virtualx-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
virtualx-engine/modules/gdscript/gdscript_analyzer.cpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

5439 lines
213 KiB
C++
Raw Normal View History

One Copyright Update to rule them all As many open source projects have started doing it, we're removing the current year from the copyright notice, so that we don't need to bump it every year. It seems like only the first year of publication is technically relevant for copyright notices, and even that seems to be something that many companies stopped listing altogether (in a version controlled codebase, the commits are a much better source of date of publication than a hardcoded copyright statement). We also now list Godot Engine contributors first as we're collectively the current maintainers of the project, and we clarify that the "exclusive" copyright of the co-founders covers the timespan before opensourcing (their further contributions are included as part of Godot Engine contributors). Also fixed "cf." Frenchism - it's meant as "refer to / see".
2023-01-05 13:25:55 +01:00
/**************************************************************************/
/* gdscript_analyzer.cpp */
/**************************************************************************/
/* 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. */
/**************************************************************************/
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 00:14:56 +02:00
#include "gdscript_analyzer.h"
Style: Harmonize header includes in modules This applies our existing style guide, and adds a new rule to that style guide for modular components such as platform ports and modules: Includes from the platform port or module ("local" includes) should be listed first in their own block using relative paths, before Godot's "core" includes which use "absolute" (project folder relative) paths, and finally thirdparty includes. Includes in `#ifdef`s come after their relevant section, i.e. the overall structure is: - Local includes * Conditional local includes - Core includes * Conditional core includes - Thirdparty includes * Conditional thirdparty includes
2023-06-13 16:56:21 +02:00
#include "gdscript.h"
#include "gdscript_utility_functions.h"
GDScript: Make singleton functions be seen as static Since those can be called without an instance.
2021-08-20 15:52:58 +02:00
#include "core/config/engine.h"
Reorganized core/ directory, it was too fatty already -Removed FuncRef, since Callable makes it obsolete -Removed int_types.h as its obsolete in c++11+ -Changed color names code
2020-11-07 23:33:38 +01:00
#include "core/config/project_settings.h"
Make global scope enums accessible as types in GDScript Add functions to CoreConstant so enums can be properly deduced. Also add the enums in release builds to make consistent with ClassDB enums and avoid differences in script compilation between debug and release.
2023-02-19 16:57:09 +01:00
#include "core/core_constants.h"
Fix ability to overload "script" variable
2022-11-08 23:41:50 +01:00
#include "core/core_string_names.h"
Core: Move DirAccess and FileAccess to `core/io` File handling APIs are typically considered part of I/O, and we did have most `FileAccess` implementations in `core/io` already.
2021-06-11 14:51:48 +02:00
#include "core/io/file_access.h"
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 00:14:56 +02:00
#include "core/io/resource_loader.h"
Reorganized core/ directory, it was too fatty already -Removed FuncRef, since Callable makes it obsolete -Removed int_types.h as its obsolete in c++11+ -Changed color names code
2020-11-07 23:33:38 +01:00
#include "core/object/class_db.h"
#include "core/object/script_language.h"
#include "core/templates/hash_map.h"
Fix cyclic references in GDScript 2.0
2022-10-09 18:41:28 +02:00
#include "scene/resources/packed_scene.h"
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 00:14:56 +02:00
Clean up ProjectConverter3To4 architecture, move renames map to separate file This allows properly limiting what features depend on the RegEx module (doing the actual conversion) and what features only require the renames data (GDScript suggestions). Also better excludes the conversion command line options when actually disabling deprecated code. Fixes #73029.
2023-02-10 09:07:01 +01:00
#if defined(TOOLS_ENABLED) && !defined(DISABLE_DEPRECATED)
#define SUGGEST_GODOT4_RENAMES
#include "editor/renames_map_3_to_4.h"
#endif
Assorted enum and native type fixes
2022-12-04 04:02:03 +01:00
#define UNNAMED_ENUM "<anonymous enum>"
Make global scope enums accessible as types in GDScript Add functions to CoreConstant so enums can be properly deduced. Also add the enums in release builds to make consistent with ClassDB enums and avoid differences in script compilation between debug and release.
2023-02-19 16:57:09 +01:00
#define ENUM_SEPARATOR "."
Assorted enum and native type fixes
2022-12-04 04:02:03 +01:00
GDScript: Refactor builtin functions They are now called "utility functions" to avoid confusion with methods of builtin types, and be consistent with the naming in Variant. Core utility functions are now available in GDScript. The ones missing in core are added specifically to GDScript as helpers for convenience. Some functions were remove when there are better ways to do, reducing redundancy and cleaning up the global scope.
2020-11-26 15:56:32 +01:00
static MethodInfo info_from_utility_func(const StringName &p_function) {
ERR_FAIL_COND_V(!Variant::has_utility_function(p_function), MethodInfo());
MethodInfo info(p_function);
if (Variant::has_utility_function_return_value(p_function)) {
info.return_val.type = Variant::get_utility_function_return_type(p_function);
if (info.return_val.type == Variant::NIL) {
info.return_val.usage |= PROPERTY_USAGE_NIL_IS_VARIANT;
}
}
if (Variant::is_utility_function_vararg(p_function)) {
info.flags |= METHOD_FLAG_VARARG;
} else {
for (int i = 0; i < Variant::get_utility_function_argument_count(p_function); i++) {
PropertyInfo pi;
#ifdef DEBUG_METHODS_ENABLED
pi.name = Variant::get_utility_function_argument_name(p_function, i);
#else
pi.name = "arg" + itos(i + 1);
#endif
pi.type = Variant::get_utility_function_argument_type(p_function, i);
info.arguments.push_back(pi);
}
}
return info;
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
static GDScriptParser::DataType make_callable_type(const MethodInfo &p_info) {
GDScriptParser::DataType type;
type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
type.kind = GDScriptParser::DataType::BUILTIN;
type.builtin_type = Variant::CALLABLE;
type.is_constant = true;
type.method_info = p_info;
return type;
}
static GDScriptParser::DataType make_signal_type(const MethodInfo &p_info) {
GDScriptParser::DataType type;
type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
type.kind = GDScriptParser::DataType::BUILTIN;
type.builtin_type = Variant::SIGNAL;
type.is_constant = true;
type.method_info = p_info;
return type;
}
static GDScriptParser::DataType make_native_meta_type(const StringName &p_class_name) {
GDScriptParser::DataType type;
type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
type.kind = GDScriptParser::DataType::NATIVE;
type.builtin_type = Variant::OBJECT;
type.native_type = p_class_name;
GDScript: Fix small inconsistencies with resolve_datatype
2023-01-12 00:03:53 +01:00
type.is_constant = true;
type.is_meta_type = true;
return type;
}
static GDScriptParser::DataType make_script_meta_type(const Ref<Script> &p_script) {
GDScriptParser::DataType type;
type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
type.kind = GDScriptParser::DataType::SCRIPT;
type.builtin_type = Variant::OBJECT;
type.native_type = p_script->get_instance_base_type();
type.script_type = p_script;
type.script_path = p_script->get_path();
type.is_constant = true;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
type.is_meta_type = true;
return type;
}
Assorted enum and native type fixes
2022-12-04 04:02:03 +01:00
// In enum types, native_type is used to store the class (native or otherwise) that the enum belongs to.
// This disambiguates between similarly named enums in base classes or outer classes
static GDScriptParser::DataType make_enum_type(const StringName &p_enum_name, const String &p_base_name, const bool p_meta = false) {
Added support for enums to be used as types in GDScript
2020-06-12 02:49:58 +02:00
GDScriptParser::DataType type;
type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
type.kind = GDScriptParser::DataType::ENUM;
Assorted enum and native type fixes
2022-12-04 04:02:03 +01:00
type.builtin_type = p_meta ? Variant::DICTIONARY : Variant::INT;
type.enum_type = p_enum_name;
Added support for enums to be used as types in GDScript
2020-06-12 02:49:58 +02:00
type.is_constant = true;
Assorted enum and native type fixes
2022-12-04 04:02:03 +01:00
type.is_meta_type = p_meta;
// For enums, native_type is only used to check compatibility in is_type_compatible()
// We can set anything readable here for error messages, as long as it uniquely identifies the type of the enum
Make global scope enums accessible as types in GDScript Add functions to CoreConstant so enums can be properly deduced. Also add the enums in release builds to make consistent with ClassDB enums and avoid differences in script compilation between debug and release.
2023-02-19 16:57:09 +01:00
if (p_base_name.is_empty()) {
type.native_type = p_enum_name;
} else {
type.native_type = p_base_name + ENUM_SEPARATOR + p_enum_name;
}
Assorted enum and native type fixes
2022-12-04 04:02:03 +01:00
return type;
}
Make global scope enums accessible as types in GDScript Add functions to CoreConstant so enums can be properly deduced. Also add the enums in release builds to make consistent with ClassDB enums and avoid differences in script compilation between debug and release.
2023-02-19 16:57:09 +01:00
static GDScriptParser::DataType make_native_enum_type(const StringName &p_enum_name, const StringName &p_native_class, bool p_meta = true) {
GDScript: Add warnings that are set to error by default - Adds a list of default levels for all warning so they can be set individually. - Add warnings set by default to error for: - Using `get_node()` without `@onready`. - Using `@onready` together with `@export`. - Inferring a static type with a Variant value. - Overriding a native engine method. - Adjust how annotations to ignore warnings are treated so they also apply to method parameters. - Clean up a bit how ignored warnings are set. There were two sets but only one was actually being used. - Set all warnings to the `WARN` level for tests, so they they can be properly tested. - Fix enum types in native methods signatures being set to `int`. - Fix native enums being treated as Dictionary by mistake. - Make name of native enum types use the class they are defined in, not the direct super class of the script. This ensures they are always equal even when coming from different sources. - Fix error for signature mismatch that was only showing the first default argument as having a default. Now it shows for all.
2023-02-02 15:57:22 +01:00
// Find out which base class declared the enum, so the name is always the same even when coming from other contexts.
StringName native_base = p_native_class;
while (true && native_base != StringName()) {
if (ClassDB::has_enum(native_base, p_enum_name, true)) {
break;
}
native_base = ClassDB::get_parent_class_nocheck(native_base);
}
GDScriptParser::DataType type = make_enum_type(p_enum_name, native_base, p_meta);
if (p_meta) {
Make global scope enums accessible as types in GDScript Add functions to CoreConstant so enums can be properly deduced. Also add the enums in release builds to make consistent with ClassDB enums and avoid differences in script compilation between debug and release.
2023-02-19 16:57:09 +01:00
type.builtin_type = Variant::NIL; // Native enum types are not Dictionaries.
GDScript: Add warnings that are set to error by default - Adds a list of default levels for all warning so they can be set individually. - Add warnings set by default to error for: - Using `get_node()` without `@onready`. - Using `@onready` together with `@export`. - Inferring a static type with a Variant value. - Overriding a native engine method. - Adjust how annotations to ignore warnings are treated so they also apply to method parameters. - Clean up a bit how ignored warnings are set. There were two sets but only one was actually being used. - Set all warnings to the `WARN` level for tests, so they they can be properly tested. - Fix enum types in native methods signatures being set to `int`. - Fix native enums being treated as Dictionary by mistake. - Make name of native enum types use the class they are defined in, not the direct super class of the script. This ensures they are always equal even when coming from different sources. - Fix error for signature mismatch that was only showing the first default argument as having a default. Now it shows for all.
2023-02-02 15:57:22 +01:00
}
Added support for enums to be used as types in GDScript
2020-06-12 02:49:58 +02:00
List<StringName> enum_values;
GDScript: Add warnings that are set to error by default - Adds a list of default levels for all warning so they can be set individually. - Add warnings set by default to error for: - Using `get_node()` without `@onready`. - Using `@onready` together with `@export`. - Inferring a static type with a Variant value. - Overriding a native engine method. - Adjust how annotations to ignore warnings are treated so they also apply to method parameters. - Clean up a bit how ignored warnings are set. There were two sets but only one was actually being used. - Set all warnings to the `WARN` level for tests, so they they can be properly tested. - Fix enum types in native methods signatures being set to `int`. - Fix native enums being treated as Dictionary by mistake. - Make name of native enum types use the class they are defined in, not the direct super class of the script. This ensures they are always equal even when coming from different sources. - Fix error for signature mismatch that was only showing the first default argument as having a default. Now it shows for all.
2023-02-02 15:57:22 +01:00
ClassDB::get_enum_constants(native_base, p_enum_name, &enum_values, true);
Added support for enums to be used as types in GDScript
2020-06-12 02:49:58 +02:00
Use C++ iterators for Lists in many situations
2021-07-16 05:45:57 +02:00
for (const StringName &E : enum_values) {
GDScript: Add warnings that are set to error by default - Adds a list of default levels for all warning so they can be set individually. - Add warnings set by default to error for: - Using `get_node()` without `@onready`. - Using `@onready` together with `@export`. - Inferring a static type with a Variant value. - Overriding a native engine method. - Adjust how annotations to ignore warnings are treated so they also apply to method parameters. - Clean up a bit how ignored warnings are set. There were two sets but only one was actually being used. - Set all warnings to the `WARN` level for tests, so they they can be properly tested. - Fix enum types in native methods signatures being set to `int`. - Fix native enums being treated as Dictionary by mistake. - Make name of native enum types use the class they are defined in, not the direct super class of the script. This ensures they are always equal even when coming from different sources. - Fix error for signature mismatch that was only showing the first default argument as having a default. Now it shows for all.
2023-02-02 15:57:22 +01:00
type.enum_values[E] = ClassDB::get_integer_constant(native_base, E);
Added support for enums to be used as types in GDScript
2020-06-12 02:49:58 +02:00
}
return type;
}
Make global scope enums accessible as types in GDScript Add functions to CoreConstant so enums can be properly deduced. Also add the enums in release builds to make consistent with ClassDB enums and avoid differences in script compilation between debug and release.
2023-02-19 16:57:09 +01:00
static GDScriptParser::DataType make_global_enum_type(const StringName &p_enum_name, const StringName &p_base, bool p_meta = true) {
GDScriptParser::DataType type = make_enum_type(p_enum_name, p_base, p_meta);
if (p_meta) {
type.builtin_type = Variant::NIL; // Native enum types are not Dictionaries.
type.is_pseudo_type = true;
}
HashMap<StringName, int64_t> enum_values;
CoreConstants::get_enum_values(type.native_type, &enum_values);
for (const KeyValue<StringName, int64_t> &element : enum_values) {
type.enum_values[element.key] = element.value;
}
return type;
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
static GDScriptParser::DataType make_builtin_meta_type(Variant::Type p_type) {
GDScriptParser::DataType type;
type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
type.kind = GDScriptParser::DataType::BUILTIN;
type.builtin_type = p_type;
type.is_constant = true;
type.is_meta_type = true;
return type;
}
Fix ability to overload "script" variable
2022-11-08 23:41:50 +01:00
bool GDScriptAnalyzer::has_member_name_conflict_in_script_class(const StringName &p_member_name, const GDScriptParser::ClassNode *p_class, const GDScriptParser::Node *p_member) {
Check for GDScript member and class naming conflicts in a variety of conditions.
2021-08-24 18:49:03 +02:00
if (p_class->members_indices.has(p_member_name)) {
int index = p_class->members_indices[p_member_name];
const GDScriptParser::ClassNode::Member *member = &p_class->members[index];
if (member->type == GDScriptParser::ClassNode::Member::VARIABLE ||
member->type == GDScriptParser::ClassNode::Member::CONSTANT ||
member->type == GDScriptParser::ClassNode::Member::ENUM ||
member->type == GDScriptParser::ClassNode::Member::ENUM_VALUE ||
member->type == GDScriptParser::ClassNode::Member::CLASS ||
member->type == GDScriptParser::ClassNode::Member::SIGNAL) {
return true;
}
Fix ability to overload "script" variable
2022-11-08 23:41:50 +01:00
if (p_member->type != GDScriptParser::Node::FUNCTION && member->type == GDScriptParser::ClassNode::Member::FUNCTION) {
return true;
}
Check for GDScript member and class naming conflicts in a variety of conditions.
2021-08-24 18:49:03 +02:00
}
return false;
}
bool GDScriptAnalyzer::has_member_name_conflict_in_native_type(const StringName &p_member_name, const StringName &p_native_type_string) {
if (ClassDB::has_signal(p_native_type_string, p_member_name)) {
return true;
}
if (ClassDB::has_property(p_native_type_string, p_member_name)) {
return true;
}
if (ClassDB::has_integer_constant(p_native_type_string, p_member_name)) {
return true;
}
Fix ability to overload "script" variable
2022-11-08 23:41:50 +01:00
if (p_member_name == CoreStringNames::get_singleton()->_script) {
return true;
}
Check for GDScript member and class naming conflicts in a variety of conditions.
2021-08-24 18:49:03 +02:00
return false;
}
Error GDScriptAnalyzer::check_native_member_name_conflict(const StringName &p_member_name, const GDScriptParser::Node *p_member_node, const StringName &p_native_type_string) {
if (has_member_name_conflict_in_native_type(p_member_name, p_native_type_string)) {
push_error(vformat(R"(Member "%s" redefined (original in native class '%s'))", p_member_name, p_native_type_string), p_member_node);
return ERR_PARSE_ERROR;
}
if (class_exists(p_member_name)) {
Disallow class names to be the same as global names Also forbid autoloads to have the same name as global script class.
2021-09-13 15:51:29 +02:00
push_error(vformat(R"(The member "%s" shadows a native class.)", p_member_name), p_member_node);
Check for GDScript member and class naming conflicts in a variety of conditions.
2021-08-24 18:49:03 +02:00
return ERR_PARSE_ERROR;
}
GDScript: Don't allow builtin type names as identifiers
2021-09-29 16:23:16 +02:00
if (GDScriptParser::get_builtin_type(p_member_name) != Variant::VARIANT_MAX) {
push_error(vformat(R"(The member "%s" cannot have the same name as a builtin type.)", p_member_name), p_member_node);
return ERR_PARSE_ERROR;
}
Check for GDScript member and class naming conflicts in a variety of conditions.
2021-08-24 18:49:03 +02:00
return OK;
}
Error GDScriptAnalyzer::check_class_member_name_conflict(const GDScriptParser::ClassNode *p_class_node, const StringName &p_member_name, const GDScriptParser::Node *p_member_node) {
Assorted enum and native type fixes
2022-12-04 04:02:03 +01:00
// TODO check outer classes for static members only
Check for GDScript member and class naming conflicts in a variety of conditions.
2021-08-24 18:49:03 +02:00
const GDScriptParser::DataType *current_data_type = &p_class_node->base_type;
while (current_data_type && current_data_type->kind == GDScriptParser::DataType::Kind::CLASS) {
GDScriptParser::ClassNode *current_class_node = current_data_type->class_type;
Fix ability to overload "script" variable
2022-11-08 23:41:50 +01:00
if (has_member_name_conflict_in_script_class(p_member_name, current_class_node, p_member_node)) {
Fix missing parent class name identifier crash
2022-12-03 03:30:19 +01:00
String parent_class_name = current_class_node->fqcn;
if (current_class_node->identifier != nullptr) {
parent_class_name = current_class_node->identifier->name;
}
push_error(vformat(R"(The member "%s" already exists in parent class %s.)", p_member_name, parent_class_name), p_member_node);
Check for GDScript member and class naming conflicts in a variety of conditions.
2021-08-24 18:49:03 +02:00
return ERR_PARSE_ERROR;
}
current_data_type = &current_class_node->base_type;
}
Fix ability to overload "script" variable
2022-11-08 23:41:50 +01:00
// No need for native class recursion because Node exposes all Object's properties.
Check for GDScript member and class naming conflicts in a variety of conditions.
2021-08-24 18:49:03 +02:00
if (current_data_type && current_data_type->kind == GDScriptParser::DataType::Kind::NATIVE) {
Refactor some object type checking code with `cast_to` Less stringly typed logic, and less String allocations and comparisons.
2022-02-06 14:12:19 +01:00
if (current_data_type->native_type != StringName()) {
Check for GDScript member and class naming conflicts in a variety of conditions.
2021-08-24 18:49:03 +02:00
return check_native_member_name_conflict(
p_member_name,
p_member_node,
current_data_type->native_type);
}
}
return OK;
}
Fix constant base typing in extended GDScript class
2022-12-04 22:55:40 +01:00
void GDScriptAnalyzer::get_class_node_current_scope_classes(GDScriptParser::ClassNode *p_node, List<GDScriptParser::ClassNode *> *p_list) {
Fix GDScript base and outer classes, signals and functions lookup order - Add outer class lookup test - Add signal lookup test Co-authored-by: Dmitrii Maganov <vonagam@gmail.com>
2022-12-18 06:38:53 +01:00
ERR_FAIL_NULL(p_node);
ERR_FAIL_NULL(p_list);
Fix constant base typing in extended GDScript class
2022-12-04 22:55:40 +01:00
if (p_list->find(p_node) != nullptr) {
return;
}
Fix GDScript base and outer classes, signals and functions lookup order - Add outer class lookup test - Add signal lookup test Co-authored-by: Dmitrii Maganov <vonagam@gmail.com>
2022-12-18 06:38:53 +01:00
Fix constant base typing in extended GDScript class
2022-12-04 22:55:40 +01:00
p_list->push_back(p_node);
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
// TODO: Try to solve class inheritance if not yet resolving.
Fix constant base typing in extended GDScript class
2022-12-04 22:55:40 +01:00
// Prioritize node base type over its outer class
if (p_node->base_type.class_type != nullptr) {
get_class_node_current_scope_classes(p_node->base_type.class_type, p_list);
}
if (p_node->outer != nullptr) {
get_class_node_current_scope_classes(p_node->outer, p_list);
}
}
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
Error GDScriptAnalyzer::resolve_class_inheritance(GDScriptParser::ClassNode *p_class, const GDScriptParser::Node *p_source) {
if (p_source == nullptr && parser->has_class(p_class)) {
p_source = p_class;
}
if (p_class->base_type.is_resolving()) {
push_error(vformat(R"(Could not resolve class "%s": Cyclic reference.)", type_from_metatype(p_class->get_datatype()).to_string()), p_source);
return ERR_PARSE_ERROR;
}
if (!p_class->base_type.has_no_type()) {
// Already resolved.
return OK;
}
if (!parser->has_class(p_class)) {
String script_path = p_class->get_datatype().script_path;
Ref<GDScriptParserRef> parser_ref = get_parser_for(script_path);
if (parser_ref.is_null()) {
push_error(vformat(R"(Could not find script "%s".)", script_path), p_source);
return ERR_PARSE_ERROR;
}
Error err = parser_ref->raise_status(GDScriptParserRef::PARSED);
if (err) {
push_error(vformat(R"(Could not parse script "%s": %s.)", script_path, error_names[err]), p_source);
return ERR_PARSE_ERROR;
}
ERR_FAIL_COND_V_MSG(!parser_ref->get_parser()->has_class(p_class), ERR_PARSE_ERROR, R"(Parser bug: Mismatched external parser.)");
GDScriptAnalyzer *other_analyzer = parser_ref->get_analyzer();
GDScriptParser *other_parser = parser_ref->get_parser();
int error_count = other_parser->errors.size();
other_analyzer->resolve_class_inheritance(p_class);
if (other_parser->errors.size() > error_count) {
push_error(vformat(R"(Could not resolve inheritance for class "%s".)", p_class->fqcn), p_source);
return ERR_PARSE_ERROR;
}
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 00:14:56 +02:00
return OK;
}
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
GDScriptParser::ClassNode *previous_class = parser->current_class;
parser->current_class = p_class;
Disallow class names to be the same as global names Also forbid autoloads to have the same name as global script class.
2021-09-13 15:51:29 +02:00
if (p_class->identifier) {
StringName class_name = p_class->identifier->name;
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
if (GDScriptParser::get_builtin_type(class_name) < Variant::VARIANT_MAX) {
push_error(vformat(R"(Class "%s" hides a built-in type.)", class_name), p_class->identifier);
} else if (class_exists(class_name)) {
Disallow class names to be the same as global names Also forbid autoloads to have the same name as global script class.
2021-09-13 15:51:29 +02:00
push_error(vformat(R"(Class "%s" hides a native class.)", class_name), p_class->identifier);
} else if (ScriptServer::is_global_class(class_name) && (ScriptServer::get_global_class_path(class_name) != parser->script_path || p_class != parser->head)) {
push_error(vformat(R"(Class "%s" hides a global script class.)", class_name), p_class->identifier);
} else if (ProjectSettings::get_singleton()->has_autoload(class_name) && ProjectSettings::get_singleton()->get_autoload(class_name).is_singleton) {
push_error(vformat(R"(Class "%s" hides an autoload singleton.)", class_name), p_class->identifier);
}
}
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
GDScriptParser::DataType resolving_datatype;
resolving_datatype.kind = GDScriptParser::DataType::RESOLVING;
p_class->base_type = resolving_datatype;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
// Set datatype for class.
GDScriptParser::DataType class_type;
class_type.is_constant = true;
class_type.is_meta_type = true;
class_type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
class_type.kind = GDScriptParser::DataType::CLASS;
class_type.class_type = p_class;
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
class_type.script_path = parser->script_path;
GDScript: Allow subscript on self and object types
2021-10-06 17:01:34 +02:00
class_type.builtin_type = Variant::OBJECT;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
p_class->set_datatype(class_type);
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
GDScriptParser::DataType result;
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 00:14:56 +02:00
if (!p_class->extends_used) {
result.type_source = GDScriptParser::DataType::ANNOTATED_INFERRED;
result.kind = GDScriptParser::DataType::NATIVE;
Refactor some object type checking code with `cast_to` Less stringly typed logic, and less String allocations and comparisons.
2022-02-06 14:12:19 +01:00
result.native_type = SNAME("RefCounted");
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 00:14:56 +02:00
} else {
result.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
GDScriptParser::DataType base;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
int extends_index = 0;
Rename empty() to is_empty()
2020-12-15 13:04:21 +01:00
if (!p_class->extends_path.is_empty()) {
Fix extends with relative path to parent script
2021-07-14 17:23:54 +02:00
if (p_class->extends_path.is_relative_path()) {
Rename String `plus_file` to `path_join`
2022-08-30 02:34:01 +02:00
p_class->extends_path = class_type.script_path.get_base_dir().path_join(p_class->extends_path).simplify_path();
Fix extends with relative path to parent script
2021-07-14 17:23:54 +02:00
}
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 11:53:28 +02:00
Ref<GDScriptParserRef> ext_parser = get_parser_for(p_class->extends_path);
if (ext_parser.is_null()) {
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
push_error(vformat(R"(Could not resolve super class path "%s".)", p_class->extends_path), p_class);
return ERR_PARSE_ERROR;
}
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
Error err = ext_parser->raise_status(GDScriptParserRef::INHERITANCE_SOLVED);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
if (err != OK) {
push_error(vformat(R"(Could not resolve super class inheritance from "%s".)", p_class->extends_path), p_class);
return err;
}
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 11:53:28 +02:00
base = ext_parser->get_parser()->head->get_datatype();
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 00:14:56 +02:00
} else {
Rename empty() to is_empty()
2020-12-15 13:04:21 +01:00
if (p_class->extends.is_empty()) {
Prevent crash due to empty error message on empty extends in GDScript
2022-03-12 07:33:11 +01:00
push_error("Could not resolve an empty super class path.", p_class);
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
return ERR_PARSE_ERROR;
}
GDScript: Change parser representation of class extends
2023-03-08 21:06:29 +01:00
GDScriptParser::IdentifierNode *id = p_class->extends[extends_index++];
const StringName &name = id->name;
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 00:14:56 +02:00
base.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
if (ScriptServer::is_global_class(name)) {
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
String base_path = ScriptServer::get_global_class_path(name);
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
if (base_path == parser->script_path) {
base = parser->head->get_datatype();
} else {
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 11:53:28 +02:00
Ref<GDScriptParserRef> base_parser = get_parser_for(base_path);
if (base_parser.is_null()) {
GDScript: Change parser representation of class extends
2023-03-08 21:06:29 +01:00
push_error(vformat(R"(Could not resolve super class "%s".)", name), id);
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
return ERR_PARSE_ERROR;
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
Error err = base_parser->raise_status(GDScriptParserRef::INHERITANCE_SOLVED);
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
if (err != OK) {
GDScript: Change parser representation of class extends
2023-03-08 21:06:29 +01:00
push_error(vformat(R"(Could not resolve super class inheritance from "%s".)", name), id);
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
return err;
}
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 11:53:28 +02:00
base = base_parser->get_parser()->head->get_datatype();
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 00:14:56 +02:00
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
} else if (ProjectSettings::get_singleton()->has_autoload(name) && ProjectSettings::get_singleton()->get_autoload(name).is_singleton) {
const ProjectSettings::AutoloadInfo &info = ProjectSettings::get_singleton()->get_autoload(name);
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
if (info.path.get_extension().to_lower() != GDScriptLanguage::get_singleton()->get_extension()) {
GDScript: Change parser representation of class extends
2023-03-08 21:06:29 +01:00
push_error(vformat(R"(Singleton %s is not a GDScript.)", info.name), id);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
return ERR_PARSE_ERROR;
}
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 11:53:28 +02:00
Ref<GDScriptParserRef> info_parser = get_parser_for(info.path);
if (info_parser.is_null()) {
GDScript: Change parser representation of class extends
2023-03-08 21:06:29 +01:00
push_error(vformat(R"(Could not parse singleton from "%s".)", info.path), id);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
return ERR_PARSE_ERROR;
}
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
Error err = info_parser->raise_status(GDScriptParserRef::INHERITANCE_SOLVED);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
if (err != OK) {
GDScript: Change parser representation of class extends
2023-03-08 21:06:29 +01:00
push_error(vformat(R"(Could not resolve super class inheritance from "%s".)", name), id);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
return err;
}
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
base = info_parser->get_parser()->head->get_datatype();
GDScript: Fix extending abstract classes, forbid their construction
2022-12-29 08:34:13 +01:00
} else if (class_exists(name)) {
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
base.kind = GDScriptParser::DataType::NATIVE;
base.native_type = name;
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 00:14:56 +02:00
} else {
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
// Look for other classes in script.
bool found = false;
Fix constant base typing in extended GDScript class
2022-12-04 22:55:40 +01:00
List<GDScriptParser::ClassNode *> script_classes;
get_class_node_current_scope_classes(p_class, &script_classes);
for (GDScriptParser::ClassNode *look_class : script_classes) {
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
if (look_class->identifier && look_class->identifier->name == name) {
if (!look_class->get_datatype().is_set()) {
GDScript: Change parser representation of class extends
2023-03-08 21:06:29 +01:00
Error err = resolve_class_inheritance(look_class, id);
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
if (err) {
return err;
}
}
base = look_class->get_datatype();
found = true;
break;
}
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
if (look_class->has_member(name)) {
GDScript: Change parser representation of class extends
2023-03-08 21:06:29 +01:00
resolve_class_member(look_class, name, id);
GDScript: Add missing member type check when resolving `extends`
2023-04-10 08:54:53 +02:00
GDScriptParser::ClassNode::Member member = look_class->get_member(name);
GDScriptParser::DataType member_datatype = member.get_datatype();
switch (member.type) {
case GDScriptParser::ClassNode::Member::CLASS:
break; // OK.
case GDScriptParser::ClassNode::Member::CONSTANT:
if (member_datatype.kind != GDScriptParser::DataType::SCRIPT && member_datatype.kind != GDScriptParser::DataType::CLASS) {
push_error(vformat(R"(Constant "%s" is not a preloaded script or class.)", name), id);
return ERR_PARSE_ERROR;
}
break;
default:
push_error(vformat(R"(Cannot use %s "%s" in extends chain.)", member.get_type_name(), name), id);
return ERR_PARSE_ERROR;
}
base = member_datatype;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
found = true;
break;
}
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 00:14:56 +02:00
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
if (!found) {
GDScript: Change parser representation of class extends
2023-03-08 21:06:29 +01:00
push_error(vformat(R"(Could not find base class "%s".)", name), id);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
return ERR_PARSE_ERROR;
}
}
}
for (int index = extends_index; index < p_class->extends.size(); index++) {
GDScript: Change parser representation of class extends
2023-03-08 21:06:29 +01:00
GDScriptParser::IdentifierNode *id = p_class->extends[index];
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
if (base.kind != GDScriptParser::DataType::CLASS) {
GDScript: Change parser representation of class extends
2023-03-08 21:06:29 +01:00
push_error(vformat(R"(Cannot get nested types for extension from non-GDScript type "%s".)", base.to_string()), id);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
return ERR_PARSE_ERROR;
}
reduce_identifier_from_base(id, &base);
GDScriptParser::DataType id_type = id->get_datatype();
GDScript: Change parser representation of class extends
2023-03-08 21:06:29 +01:00
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
if (!id_type.is_set()) {
GDScript: Change parser representation of class extends
2023-03-08 21:06:29 +01:00
push_error(vformat(R"(Could not find nested type "%s".)", id->name), id);
return ERR_PARSE_ERROR;
GDScript: Add missing member type check when resolving `extends`
2023-04-10 08:54:53 +02:00
} else if (id_type.kind != GDScriptParser::DataType::SCRIPT && id_type.kind != GDScriptParser::DataType::CLASS) {
push_error(vformat(R"(Identifier "%s" is not a preloaded script or class.)", id->name), id);
return ERR_PARSE_ERROR;
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 00:14:56 +02:00
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
base = id_type;
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 00:14:56 +02:00
}
result = base;
}
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
if (!result.is_set() || result.has_no_type()) {
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 00:14:56 +02:00
// TODO: More specific error messages.
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
push_error(vformat(R"(Could not resolve inheritance for class "%s".)", p_class->identifier == nullptr ? "<main>" : p_class->identifier->name), p_class);
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 00:14:56 +02:00
return ERR_PARSE_ERROR;
}
GDScript: Show error when there's an inheritance cycle
2020-08-26 21:01:08 +02:00
// Check for cyclic inheritance.
const GDScriptParser::ClassNode *base_class = result.class_type;
while (base_class) {
if (base_class->fqcn == p_class->fqcn) {
push_error("Cyclic inheritance.", p_class);
return ERR_PARSE_ERROR;
}
base_class = base_class->base_type.class_type;
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
p_class->base_type = result;
class_type.native_type = result.native_type;
p_class->set_datatype(class_type);
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 00:14:56 +02:00
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
parser->current_class = previous_class;
return OK;
}
Error GDScriptAnalyzer::resolve_class_inheritance(GDScriptParser::ClassNode *p_class, bool p_recursive) {
Error err = resolve_class_inheritance(p_class);
if (err) {
return err;
}
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 00:14:56 +02:00
if (p_recursive) {
for (int i = 0; i < p_class->members.size(); i++) {
if (p_class->members[i].type == GDScriptParser::ClassNode::Member::CLASS) {
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
err = resolve_class_inheritance(p_class->members[i].m_class, true);
GDScript: Show error when there's an inheritance cycle
2020-08-26 21:01:08 +02:00
if (err) {
return err;
}
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 00:14:56 +02:00
}
}
}
return OK;
}
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
GDScriptParser::DataType GDScriptAnalyzer::resolve_datatype(GDScriptParser::TypeNode *p_type) {
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
GDScriptParser::DataType bad_type;
bad_type.kind = GDScriptParser::DataType::VARIANT;
bad_type.type_source = GDScriptParser::DataType::INFERRED;
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 00:14:56 +02:00
if (p_type == nullptr) {
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
return bad_type;
}
if (p_type->get_datatype().is_resolving()) {
push_error(R"(Could not resolve datatype: Cyclic reference.)", p_type);
return bad_type;
}
if (!p_type->get_datatype().has_no_type()) {
return p_type->get_datatype();
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 00:14:56 +02:00
}
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
GDScriptParser::DataType resolving_datatype;
resolving_datatype.kind = GDScriptParser::DataType::RESOLVING;
p_type->set_datatype(resolving_datatype);
GDScriptParser::DataType result;
result.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
Rename empty() to is_empty()
2020-12-15 13:04:21 +01:00
if (p_type->type_chain.is_empty()) {
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 00:14:56 +02:00
// void.
result.kind = GDScriptParser::DataType::BUILTIN;
result.builtin_type = Variant::NIL;
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
p_type->set_datatype(result);
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 00:14:56 +02:00
return result;
}
GDScript: Allow use local constants as types
2023-08-24 18:01:31 +02:00
const GDScriptParser::IdentifierNode *first_id = p_type->type_chain[0];
StringName first = first_id->name;
bool type_found = false;
if (first_id->suite && first_id->suite->has_local(first)) {
const GDScriptParser::SuiteNode::Local &local = first_id->suite->get_local(first);
if (local.type == GDScriptParser::SuiteNode::Local::CONSTANT) {
result = local.get_datatype();
if (!result.is_set()) {
// Don't try to resolve it as the constant can be declared below.
push_error(vformat(R"(Local constant "%s" is not resolved at this point.)", first), first_id);
return bad_type;
}
if (result.is_meta_type) {
type_found = true;
} else if (Ref<Script>(local.constant->initializer->reduced_value).is_valid()) {
Ref<GDScript> gdscript = local.constant->initializer->reduced_value;
if (gdscript.is_valid()) {
Ref<GDScriptParserRef> ref = get_parser_for(gdscript->get_script_path());
if (ref->raise_status(GDScriptParserRef::INHERITANCE_SOLVED) != OK) {
push_error(vformat(R"(Could not parse script from "%s".)", gdscript->get_script_path()), first_id);
return bad_type;
}
result = ref->get_parser()->head->get_datatype();
} else {
result = make_script_meta_type(local.constant->initializer->reduced_value);
}
type_found = true;
Make global scope enums accessible as types in GDScript Add functions to CoreConstant so enums can be properly deduced. Also add the enums in release builds to make consistent with ClassDB enums and avoid differences in script compilation between debug and release.
2023-02-19 16:57:09 +01:00
} else {
GDScript: Allow use local constants as types
2023-08-24 18:01:31 +02:00
push_error(vformat(R"(Local constant "%s" is not a valid type.)", first), first_id);
Make global scope enums accessible as types in GDScript Add functions to CoreConstant so enums can be properly deduced. Also add the enums in release builds to make consistent with ClassDB enums and avoid differences in script compilation between debug and release.
2023-02-19 16:57:09 +01:00
return bad_type;
}
GDScript: Allow use local constants as types
2023-08-24 18:01:31 +02:00
} else {
push_error(vformat(R"(Local %s "%s" cannot be used as a type.)", local.get_name(), first), first_id);
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
return bad_type;
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 00:14:56 +02:00
}
GDScript: Allow use local constants as types
2023-08-24 18:01:31 +02:00
}
Add typed arrays to GDScript - Use `Array[type]` for type-hints. e.g.: `var array: Array[int] = [1, 2, 3]` - Array literals are typed if their storage is typed (variable asssignment of as argument in function all). Otherwise they are untyped.
2021-03-09 16:32:35 +01:00
GDScript: Allow use local constants as types
2023-08-24 18:01:31 +02:00
if (!type_found) {
if (first == SNAME("Variant")) {
if (p_type->type_chain.size() == 2) {
// May be nested enum.
StringName enum_name = p_type->type_chain[1]->name;
StringName qualified_name = String(first) + ENUM_SEPARATOR + String(p_type->type_chain[1]->name);
if (CoreConstants::is_global_enum(qualified_name)) {
result = make_global_enum_type(enum_name, first, true);
return result;
} else {
push_error(vformat(R"(Name "%s" is not a nested type of "Variant".)", enum_name), p_type->type_chain[1]);
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
return bad_type;
Add GDScript resource export.
2022-04-25 06:33:18 +02:00
}
GDScript: Allow use local constants as types
2023-08-24 18:01:31 +02:00
} else if (p_type->type_chain.size() > 2) {
push_error(R"(Variant only contains enum types, which do not have nested types.)", p_type->type_chain[2]);
return bad_type;
}
result.kind = GDScriptParser::DataType::VARIANT;
} else if (first == SNAME("Object")) {
// Object is treated like a native type, not a built-in.
result.kind = GDScriptParser::DataType::NATIVE;
result.builtin_type = Variant::OBJECT;
result.native_type = SNAME("Object");
} else if (GDScriptParser::get_builtin_type(first) < Variant::VARIANT_MAX) {
// Built-in types.
if (p_type->type_chain.size() > 1) {
push_error(R"(Built-in types don't contain nested types.)", p_type->type_chain[1]);
return bad_type;
}
result.kind = GDScriptParser::DataType::BUILTIN;
result.builtin_type = GDScriptParser::get_builtin_type(first);
if (result.builtin_type == Variant::ARRAY) {
GDScriptParser::DataType container_type = type_from_metatype(resolve_datatype(p_type->container_type));
if (container_type.kind != GDScriptParser::DataType::VARIANT) {
container_type.is_constant = false;
result.set_container_element_type(container_type);
}
}
} else if (class_exists(first)) {
// Native engine classes.
result.kind = GDScriptParser::DataType::NATIVE;
result.builtin_type = Variant::OBJECT;
result.native_type = first;
} else if (ScriptServer::is_global_class(first)) {
if (parser->script_path == ScriptServer::get_global_class_path(first)) {
result = parser->head->get_datatype();
Add GDScript resource export.
2022-04-25 06:33:18 +02:00
} else {
GDScript: Allow use local constants as types
2023-08-24 18:01:31 +02:00
String path = ScriptServer::get_global_class_path(first);
String ext = path.get_extension();
if (ext == GDScriptLanguage::get_singleton()->get_extension()) {
Ref<GDScriptParserRef> ref = get_parser_for(path);
if (!ref.is_valid() || ref->raise_status(GDScriptParserRef::INHERITANCE_SOLVED) != OK) {
push_error(vformat(R"(Could not parse global class "%s" from "%s".)", first, ScriptServer::get_global_class_path(first)), p_type);
return bad_type;
}
result = ref->get_parser()->head->get_datatype();
} else {
result = make_script_meta_type(ResourceLoader::load(path, "Script"));
}
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
}
GDScript: Allow use local constants as types
2023-08-24 18:01:31 +02:00
} else if (ProjectSettings::get_singleton()->has_autoload(first) && ProjectSettings::get_singleton()->get_autoload(first).is_singleton) {
const ProjectSettings::AutoloadInfo &autoload = ProjectSettings::get_singleton()->get_autoload(first);
Ref<GDScriptParserRef> ref = get_parser_for(autoload.path);
if (ref.is_null()) {
push_error(vformat(R"(The referenced autoload "%s" (from "%s") could not be loaded.)", first, autoload.path), p_type);
return bad_type;
Assorted enum and native type fixes
2022-12-04 04:02:03 +01:00
}
GDScript: Allow use local constants as types
2023-08-24 18:01:31 +02:00
if (ref->raise_status(GDScriptParserRef::INHERITANCE_SOLVED) != OK) {
push_error(vformat(R"(Could not parse singleton "%s" from "%s".)", first, autoload.path), p_type);
return bad_type;
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
}
GDScript: Allow use local constants as types
2023-08-24 18:01:31 +02:00
result = ref->get_parser()->head->get_datatype();
} else if (ClassDB::has_enum(parser->current_class->base_type.native_type, first)) {
// Native enum in current class.
result = make_native_enum_type(first, parser->current_class->base_type.native_type);
} else if (CoreConstants::is_global_enum(first)) {
if (p_type->type_chain.size() > 1) {
push_error(R"(Enums cannot contain nested types.)", p_type->type_chain[1]);
return bad_type;
}
result = make_global_enum_type(first, StringName());
} else {
// Classes in current scope.
List<GDScriptParser::ClassNode *> script_classes;
bool found = false;
get_class_node_current_scope_classes(parser->current_class, &script_classes);
for (GDScriptParser::ClassNode *script_class : script_classes) {
if (found) {
break;
}
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
GDScript: Allow use local constants as types
2023-08-24 18:01:31 +02:00
if (script_class->identifier && script_class->identifier->name == first) {
result = script_class->get_datatype();
break;
}
if (script_class->members_indices.has(first)) {
resolve_class_member(script_class, first, p_type);
GDScriptParser::ClassNode::Member member = script_class->get_member(first);
switch (member.type) {
case GDScriptParser::ClassNode::Member::CLASS:
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
result = member.get_datatype();
Assorted enum and native type fixes
2022-12-04 04:02:03 +01:00
found = true;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
break;
GDScript: Allow use local constants as types
2023-08-24 18:01:31 +02:00
case GDScriptParser::ClassNode::Member::ENUM:
result = member.get_datatype();
Assorted enum and native type fixes
2022-12-04 04:02:03 +01:00
found = true;
GDScript: Fix inner classes and preloaded scripts as types
2021-05-26 14:23:17 +02:00
break;
GDScript: Allow use local constants as types
2023-08-24 18:01:31 +02:00
case GDScriptParser::ClassNode::Member::CONSTANT:
if (member.get_datatype().is_meta_type) {
result = member.get_datatype();
found = true;
break;
} else if (Ref<Script>(member.constant->initializer->reduced_value).is_valid()) {
Ref<GDScript> gdscript = member.constant->initializer->reduced_value;
if (gdscript.is_valid()) {
Ref<GDScriptParserRef> ref = get_parser_for(gdscript->get_script_path());
if (ref->raise_status(GDScriptParserRef::INHERITANCE_SOLVED) != OK) {
push_error(vformat(R"(Could not parse script from "%s".)", gdscript->get_script_path()), p_type);
return bad_type;
}
result = ref->get_parser()->head->get_datatype();
} else {
result = make_script_meta_type(member.constant->initializer->reduced_value);
}
found = true;
break;
}
[[fallthrough]];
default:
push_error(vformat(R"("%s" is a %s but does not contain a type.)", first, member.get_type_name()), p_type);
return bad_type;
}
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 00:14:56 +02:00
}
}
}
Added support for enums to be used as types in GDScript
2020-06-12 02:49:58 +02:00
}
GDScript: Allow use local constants as types
2023-08-24 18:01:31 +02:00
Added support for enums to be used as types in GDScript
2020-06-12 02:49:58 +02:00
if (!result.is_set()) {
GDScript: Fix error message for unfound type
2023-02-21 22:00:29 +01:00
push_error(vformat(R"(Could not find type "%s" in the current scope.)", first), p_type);
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
return bad_type;
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 00:14:56 +02:00
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
if (p_type->type_chain.size() > 1) {
Added support for enums to be used as types in GDScript
2020-06-12 02:49:58 +02:00
if (result.kind == GDScriptParser::DataType::CLASS) {
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
for (int i = 1; i < p_type->type_chain.size(); i++) {
GDScriptParser::DataType base = result;
reduce_identifier_from_base(p_type->type_chain[i], &base);
result = p_type->type_chain[i]->get_datatype();
if (!result.is_set()) {
push_error(vformat(R"(Could not find type "%s" under base "%s".)", p_type->type_chain[i]->name, base.to_string()), p_type->type_chain[1]);
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
return bad_type;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
} else if (!result.is_meta_type) {
push_error(vformat(R"(Member "%s" under base "%s" is not a valid type.)", p_type->type_chain[i]->name, base.to_string()), p_type->type_chain[1]);
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
return bad_type;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
}
Added support for enums to be used as types in GDScript
2020-06-12 02:49:58 +02:00
} else if (result.kind == GDScriptParser::DataType::NATIVE) {
// Only enums allowed for native.
Assorted enum and native type fixes
2022-12-04 04:02:03 +01:00
if (ClassDB::has_enum(result.native_type, p_type->type_chain[1]->name)) {
if (p_type->type_chain.size() > 2) {
push_error(R"(Enums cannot contain nested types.)", p_type->type_chain[2]);
return bad_type;
} else {
result = make_native_enum_type(p_type->type_chain[1]->name, result.native_type);
}
} else {
push_error(vformat(R"(Could not find type "%s" in "%s".)", p_type->type_chain[1]->name, first), p_type->type_chain[1]);
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
return bad_type;
Added support for enums to be used as types in GDScript
2020-06-12 02:49:58 +02:00
}
} else {
push_error(vformat(R"(Could not find nested type "%s" under base "%s".)", p_type->type_chain[1]->name, result.to_string()), p_type->type_chain[1]);
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
return bad_type;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 00:14:56 +02:00
}
Add typed arrays to GDScript - Use `Array[type]` for type-hints. e.g.: `var array: Array[int] = [1, 2, 3]` - Array literals are typed if their storage is typed (variable asssignment of as argument in function all). Otherwise they are untyped.
2021-03-09 16:32:35 +01:00
if (result.builtin_type != Variant::ARRAY && p_type->container_type != nullptr) {
push_error("Only arrays can specify the collection element type.", p_type);
}
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
p_type->set_datatype(result);
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 00:14:56 +02:00
return result;
}
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
void GDScriptAnalyzer::resolve_class_member(GDScriptParser::ClassNode *p_class, StringName p_name, const GDScriptParser::Node *p_source) {
ERR_FAIL_COND(!p_class->has_member(p_name));
resolve_class_member(p_class, p_class->members_indices[p_name], p_source);
}
void GDScriptAnalyzer::resolve_class_member(GDScriptParser::ClassNode *p_class, int p_index, const GDScriptParser::Node *p_source) {
ERR_FAIL_INDEX(p_index, p_class->members.size());
GDScriptParser::ClassNode::Member &member = p_class->members.write[p_index];
if (p_source == nullptr && parser->has_class(p_class)) {
p_source = member.get_source_node();
}
if (member.get_datatype().is_resolving()) {
push_error(vformat(R"(Could not resolve member "%s": Cyclic reference.)", member.get_name()), p_source);
return;
}
if (member.get_datatype().is_set()) {
return;
}
if (!parser->has_class(p_class)) {
String script_path = p_class->get_datatype().script_path;
Ref<GDScriptParserRef> parser_ref = get_parser_for(script_path);
if (parser_ref.is_null()) {
push_error(vformat(R"(Could not find script "%s" (While resolving "%s").)", script_path, member.get_name()), p_source);
return;
}
Error err = parser_ref->raise_status(GDScriptParserRef::PARSED);
if (err) {
push_error(vformat(R"(Could not resolve script "%s": %s (While resolving "%s").)", script_path, error_names[err], member.get_name()), p_source);
return;
}
ERR_FAIL_COND_MSG(!parser_ref->get_parser()->has_class(p_class), R"(Parser bug: Mismatched external parser.)");
GDScriptAnalyzer *other_analyzer = parser_ref->get_analyzer();
GDScriptParser *other_parser = parser_ref->get_parser();
int error_count = other_parser->errors.size();
other_analyzer->resolve_class_member(p_class, p_index);
if (other_parser->errors.size() > error_count) {
push_error(vformat(R"(Could not resolve member "%s".)", member.get_name()), p_source);
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
return;
}
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
// If it's already resolving, that's ok.
if (!p_class->base_type.is_resolving()) {
Error err = resolve_class_inheritance(p_class);
if (err) {
return;
}
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 00:14:56 +02:00
GDScriptParser::ClassNode *previous_class = parser->current_class;
parser->current_class = p_class;
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
GDScriptParser::DataType resolving_datatype;
resolving_datatype.kind = GDScriptParser::DataType::RESOLVING;
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 00:14:56 +02:00
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
{
GDScript: Add warnings that are set to error by default - Adds a list of default levels for all warning so they can be set individually. - Add warnings set by default to error for: - Using `get_node()` without `@onready`. - Using `@onready` together with `@export`. - Inferring a static type with a Variant value. - Overriding a native engine method. - Adjust how annotations to ignore warnings are treated so they also apply to method parameters. - Clean up a bit how ignored warnings are set. There were two sets but only one was actually being used. - Set all warnings to the `WARN` level for tests, so they they can be properly tested. - Fix enum types in native methods signatures being set to `int`. - Fix native enums being treated as Dictionary by mistake. - Make name of native enum types use the class they are defined in, not the direct super class of the script. This ensures they are always equal even when coming from different sources. - Fix error for signature mismatch that was only showing the first default argument as having a default. Now it shows for all.
2023-02-02 15:57:22 +01:00
#ifdef DEBUG_ENABLED
HashSet<GDScriptWarning::Code> previously_ignored_warnings = parser->ignored_warnings;
GDScriptParser::Node *member_node = member.get_source_node();
if (member_node && member_node->type != GDScriptParser::Node::ANNOTATION) {
// Apply @warning_ignore annotations before resolving member.
for (GDScriptParser::AnnotationNode *&E : member_node->annotations) {
if (E->name == SNAME("@warning_ignore")) {
resolve_annotation(E);
E->apply(parser, member.variable);
}
}
for (GDScriptWarning::Code ignored_warning : member_node->ignored_warnings) {
parser->ignored_warnings.insert(ignored_warning);
}
}
#endif
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 00:14:56 +02:00
switch (member.type) {
case GDScriptParser::ClassNode::Member::VARIABLE: {
Add support for static variables in GDScript Which allows editable data associated with a particular class instead of the instance. Scripts with static variables are kept in memory indefinitely unless the `@static_unload` annotation is used or the `static_unload()` method is called on the GDScript. If the custom function `_static_init()` exists it will be called when the class is loaded, after the static variables are set.
2023-04-19 16:10:35 +02:00
bool previous_static_context = static_context;
static_context = member.variable->is_static;
GDScript: Fix lambda resolution with cyclic references
2023-08-23 11:37:18 +02:00
Check for GDScript member and class naming conflicts in a variety of conditions.
2021-08-24 18:49:03 +02:00
check_class_member_name_conflict(p_class, member.variable->identifier->name, member.variable);
GDScript: Fix lambda resolution with cyclic references
2023-08-23 11:37:18 +02:00
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
member.variable->set_datatype(resolving_datatype);
Unify typing of variables, constants and parameters in GDScript
2022-12-22 21:43:36 +01:00
resolve_variable(member.variable, false);
GDScript: Fix lambda resolution with cyclic references
2023-08-23 11:37:18 +02:00
resolve_pending_lambda_bodies();
Move GDSript annotation application after type-checking This ensures that annotations that rely on the datatype (such as @export) can validated it timely, allowing compound expressions instead of only literal values.
2021-03-17 14:57:30 +01:00
// Apply annotations.
Use C++ iterators for Lists in many situations
2021-07-16 05:45:57 +02:00
for (GDScriptParser::AnnotationNode *&E : member.variable->annotations) {
GDScript: Add warnings that are set to error by default - Adds a list of default levels for all warning so they can be set individually. - Add warnings set by default to error for: - Using `get_node()` without `@onready`. - Using `@onready` together with `@export`. - Inferring a static type with a Variant value. - Overriding a native engine method. - Adjust how annotations to ignore warnings are treated so they also apply to method parameters. - Clean up a bit how ignored warnings are set. There were two sets but only one was actually being used. - Set all warnings to the `WARN` level for tests, so they they can be properly tested. - Fix enum types in native methods signatures being set to `int`. - Fix native enums being treated as Dictionary by mistake. - Make name of native enum types use the class they are defined in, not the direct super class of the script. This ensures they are always equal even when coming from different sources. - Fix error for signature mismatch that was only showing the first default argument as having a default. Now it shows for all.
2023-02-02 15:57:22 +01:00
if (E->name != SNAME("@warning_ignore")) {
resolve_annotation(E);
E->apply(parser, member.variable);
}
}
GDScript: Fix lambda resolution with cyclic references
2023-08-23 11:37:18 +02:00
Add support for static variables in GDScript Which allows editable data associated with a particular class instead of the instance. Scripts with static variables are kept in memory indefinitely unless the `@static_unload` annotation is used or the `static_unload()` method is called on the GDScript. If the custom function `_static_init()` exists it will be called when the class is loaded, after the static variables are set.
2023-04-19 16:10:35 +02:00
static_context = previous_static_context;
GDScript: Fix lambda resolution with cyclic references
2023-08-23 11:37:18 +02:00
GDScript: Add warnings that are set to error by default - Adds a list of default levels for all warning so they can be set individually. - Add warnings set by default to error for: - Using `get_node()` without `@onready`. - Using `@onready` together with `@export`. - Inferring a static type with a Variant value. - Overriding a native engine method. - Adjust how annotations to ignore warnings are treated so they also apply to method parameters. - Clean up a bit how ignored warnings are set. There were two sets but only one was actually being used. - Set all warnings to the `WARN` level for tests, so they they can be properly tested. - Fix enum types in native methods signatures being set to `int`. - Fix native enums being treated as Dictionary by mistake. - Make name of native enum types use the class they are defined in, not the direct super class of the script. This ensures they are always equal even when coming from different sources. - Fix error for signature mismatch that was only showing the first default argument as having a default. Now it shows for all.
2023-02-02 15:57:22 +01:00
#ifdef DEBUG_ENABLED
if (member.variable->exported && member.variable->onready) {
parser->push_warning(member.variable, GDScriptWarning::ONREADY_WITH_EXPORT);
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 00:14:56 +02:00
}
GDScript: Add warnings that are set to error by default - Adds a list of default levels for all warning so they can be set individually. - Add warnings set by default to error for: - Using `get_node()` without `@onready`. - Using `@onready` together with `@export`. - Inferring a static type with a Variant value. - Overriding a native engine method. - Adjust how annotations to ignore warnings are treated so they also apply to method parameters. - Clean up a bit how ignored warnings are set. There were two sets but only one was actually being used. - Set all warnings to the `WARN` level for tests, so they they can be properly tested. - Fix enum types in native methods signatures being set to `int`. - Fix native enums being treated as Dictionary by mistake. - Make name of native enum types use the class they are defined in, not the direct super class of the script. This ensures they are always equal even when coming from different sources. - Fix error for signature mismatch that was only showing the first default argument as having a default. Now it shows for all.
2023-02-02 15:57:22 +01:00
if (member.variable->initializer) {
// Check if it is call to get_node() on self (using shorthand $ or not), so we can check if @onready is needed.
// This could be improved by traversing the expression fully and checking the presence of get_node at any level.
Add support for static variables in GDScript Which allows editable data associated with a particular class instead of the instance. Scripts with static variables are kept in memory indefinitely unless the `@static_unload` annotation is used or the `static_unload()` method is called on the GDScript. If the custom function `_static_init()` exists it will be called when the class is loaded, after the static variables are set.
2023-04-19 16:10:35 +02:00
if (!member.variable->is_static && !member.variable->onready && member.variable->initializer && (member.variable->initializer->type == GDScriptParser::Node::GET_NODE || member.variable->initializer->type == GDScriptParser::Node::CALL || member.variable->initializer->type == GDScriptParser::Node::CAST)) {
GDScript: Add warnings that are set to error by default - Adds a list of default levels for all warning so they can be set individually. - Add warnings set by default to error for: - Using `get_node()` without `@onready`. - Using `@onready` together with `@export`. - Inferring a static type with a Variant value. - Overriding a native engine method. - Adjust how annotations to ignore warnings are treated so they also apply to method parameters. - Clean up a bit how ignored warnings are set. There were two sets but only one was actually being used. - Set all warnings to the `WARN` level for tests, so they they can be properly tested. - Fix enum types in native methods signatures being set to `int`. - Fix native enums being treated as Dictionary by mistake. - Make name of native enum types use the class they are defined in, not the direct super class of the script. This ensures they are always equal even when coming from different sources. - Fix error for signature mismatch that was only showing the first default argument as having a default. Now it shows for all.
2023-02-02 15:57:22 +01:00
GDScriptParser::Node *expr = member.variable->initializer;
if (expr->type == GDScriptParser::Node::CAST) {
expr = static_cast<GDScriptParser::CastNode *>(expr)->operand;
}
bool is_get_node = expr->type == GDScriptParser::Node::GET_NODE;
bool is_using_shorthand = is_get_node;
if (!is_get_node && expr->type == GDScriptParser::Node::CALL) {
is_using_shorthand = false;
GDScriptParser::CallNode *call = static_cast<GDScriptParser::CallNode *>(expr);
if (call->function_name == SNAME("get_node")) {
switch (call->get_callee_type()) {
case GDScriptParser::Node::IDENTIFIER: {
is_get_node = true;
} break;
case GDScriptParser::Node::SUBSCRIPT: {
GDScriptParser::SubscriptNode *subscript = static_cast<GDScriptParser::SubscriptNode *>(call->callee);
is_get_node = subscript->is_attribute && subscript->base->type == GDScriptParser::Node::SELF;
} break;
default:
break;
}
}
}
if (is_get_node) {
parser->push_warning(member.variable, GDScriptWarning::GET_NODE_DEFAULT_WITHOUT_ONREADY, is_using_shorthand ? "$" : "get_node()");
}
}
}
#endif
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
} break;
case GDScriptParser::ClassNode::Member::CONSTANT: {
Check for GDScript member and class naming conflicts in a variety of conditions.
2021-08-24 18:49:03 +02:00
check_class_member_name_conflict(p_class, member.constant->identifier->name, member.constant);
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
member.constant->set_datatype(resolving_datatype);
Unify typing of variables, constants and parameters in GDScript
2022-12-22 21:43:36 +01:00
resolve_constant(member.constant, false);
Move GDSript annotation application after type-checking This ensures that annotations that rely on the datatype (such as @export) can validated it timely, allowing compound expressions instead of only literal values.
2021-03-17 14:57:30 +01:00
// Apply annotations.
Use C++ iterators for Lists in many situations
2021-07-16 05:45:57 +02:00
for (GDScriptParser::AnnotationNode *&E : member.constant->annotations) {
GDScript: Allow constant expressions in annotations
2023-01-18 18:12:33 +01:00
resolve_annotation(E);
Use C++ iterators for Lists in many situations
2021-07-16 05:45:57 +02:00
E->apply(parser, member.constant);
Move GDSript annotation application after type-checking This ensures that annotations that rely on the datatype (such as @export) can validated it timely, allowing compound expressions instead of only literal values.
2021-03-17 14:57:30 +01:00
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
} break;
case GDScriptParser::ClassNode::Member::SIGNAL: {
Check for GDScript member and class naming conflicts in a variety of conditions.
2021-08-24 18:49:03 +02:00
check_class_member_name_conflict(p_class, member.signal->identifier->name, member.signal);
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
member.signal->set_datatype(resolving_datatype);
Add MethodInfo to signal datatype
2022-12-16 04:45:46 +01:00
// This is the _only_ way to declare a signal. Therefore, we can generate its
// MethodInfo inline so it's a tiny bit more efficient.
MethodInfo mi = MethodInfo(member.signal->identifier->name);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
for (int j = 0; j < member.signal->parameters.size(); j++) {
Add MethodInfo to signal datatype
2022-12-16 04:45:46 +01:00
GDScriptParser::ParameterNode *param = member.signal->parameters[j];
GDScript: Fix small inconsistencies with resolve_datatype
2023-01-12 00:03:53 +01:00
GDScriptParser::DataType param_type = type_from_metatype(resolve_datatype(param->datatype_specifier));
Add MethodInfo to signal datatype
2022-12-16 04:45:46 +01:00
param->set_datatype(param_type);
mi.arguments.push_back(PropertyInfo(param_type.builtin_type, param->identifier->name));
// TODO: add signal parameter default values
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
Add MethodInfo to signal datatype
2022-12-16 04:45:46 +01:00
member.signal->set_datatype(make_signal_type(mi));
Move GDSript annotation application after type-checking This ensures that annotations that rely on the datatype (such as @export) can validated it timely, allowing compound expressions instead of only literal values.
2021-03-17 14:57:30 +01:00
// Apply annotations.
Use C++ iterators for Lists in many situations
2021-07-16 05:45:57 +02:00
for (GDScriptParser::AnnotationNode *&E : member.signal->annotations) {
GDScript: Allow constant expressions in annotations
2023-01-18 18:12:33 +01:00
resolve_annotation(E);
Use C++ iterators for Lists in many situations
2021-07-16 05:45:57 +02:00
E->apply(parser, member.signal);
Move GDSript annotation application after type-checking This ensures that annotations that rely on the datatype (such as @export) can validated it timely, allowing compound expressions instead of only literal values.
2021-03-17 14:57:30 +01:00
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
} break;
case GDScriptParser::ClassNode::Member::ENUM: {
Check for GDScript member and class naming conflicts in a variety of conditions.
2021-08-24 18:49:03 +02:00
check_class_member_name_conflict(p_class, member.m_enum->identifier->name, member.m_enum);
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
member.m_enum->set_datatype(resolving_datatype);
Assorted enum and native type fixes
2022-12-04 04:02:03 +01:00
GDScriptParser::DataType enum_type = make_enum_type(member.m_enum->identifier->name, p_class->fqcn, true);
Added support for enums to be used as types in GDScript
2020-06-12 02:49:58 +02:00
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
const GDScriptParser::EnumNode *prev_enum = current_enum;
GDScript: Allow enum values to be set to constant expressions Also allow them to access previous values wihout referencing the enum.
2020-08-18 22:44:20 +02:00
current_enum = member.m_enum;
Fix usage of Enum as constant
2022-12-27 04:06:11 +01:00
Dictionary dictionary;
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
for (int j = 0; j < member.m_enum->values.size(); j++) {
GDScript: Allow enum values to be set to constant expressions Also allow them to access previous values wihout referencing the enum.
2020-08-18 22:44:20 +02:00
GDScriptParser::EnumNode::Value &element = member.m_enum->values.write[j];
if (element.custom_value) {
reduce_expression(element.custom_value);
if (!element.custom_value->is_constant) {
push_error(R"(Enum values must be constant.)", element.custom_value);
} else if (element.custom_value->reduced_value.get_type() != Variant::INT) {
push_error(R"(Enum values must be integers.)", element.custom_value);
} else {
element.value = element.custom_value->reduced_value;
element.resolved = true;
}
} else {
if (element.index > 0) {
element.value = element.parent_enum->values[element.index - 1].value + 1;
} else {
element.value = 0;
}
element.resolved = true;
}
enum_type.enum_values[element.identifier->name] = element.value;
Fix usage of Enum as constant
2022-12-27 04:06:11 +01:00
dictionary[String(element.identifier->name)] = element.value;
Added support for enums to be used as types in GDScript
2020-06-12 02:49:58 +02:00
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
current_enum = prev_enum;
GDScript: Allow enum values to be set to constant expressions Also allow them to access previous values wihout referencing the enum.
2020-08-18 22:44:20 +02:00
GDScript: Fix test for read-only state of constants
2023-01-22 10:07:48 +01:00
dictionary.make_read_only();
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
member.m_enum->set_datatype(enum_type);
Fix usage of Enum as constant
2022-12-27 04:06:11 +01:00
member.m_enum->dictionary = dictionary;
Move GDSript annotation application after type-checking This ensures that annotations that rely on the datatype (such as @export) can validated it timely, allowing compound expressions instead of only literal values.
2021-03-17 14:57:30 +01:00
// Apply annotations.
Use C++ iterators for Lists in many situations
2021-07-16 05:45:57 +02:00
for (GDScriptParser::AnnotationNode *&E : member.m_enum->annotations) {
GDScript: Allow constant expressions in annotations
2023-01-18 18:12:33 +01:00
resolve_annotation(E);
Use C++ iterators for Lists in many situations
2021-07-16 05:45:57 +02:00
E->apply(parser, member.m_enum);
Move GDSript annotation application after type-checking This ensures that annotations that rely on the datatype (such as @export) can validated it timely, allowing compound expressions instead of only literal values.
2021-03-17 14:57:30 +01:00
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
} break;
case GDScriptParser::ClassNode::Member::FUNCTION:
GDScript: Add warnings that are set to error by default - Adds a list of default levels for all warning so they can be set individually. - Add warnings set by default to error for: - Using `get_node()` without `@onready`. - Using `@onready` together with `@export`. - Inferring a static type with a Variant value. - Overriding a native engine method. - Adjust how annotations to ignore warnings are treated so they also apply to method parameters. - Clean up a bit how ignored warnings are set. There were two sets but only one was actually being used. - Set all warnings to the `WARN` level for tests, so they they can be properly tested. - Fix enum types in native methods signatures being set to `int`. - Fix native enums being treated as Dictionary by mistake. - Make name of native enum types use the class they are defined in, not the direct super class of the script. This ensures they are always equal even when coming from different sources. - Fix error for signature mismatch that was only showing the first default argument as having a default. Now it shows for all.
2023-02-02 15:57:22 +01:00
for (GDScriptParser::AnnotationNode *&E : member.function->annotations) {
resolve_annotation(E);
E->apply(parser, member.function);
}
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
resolve_function_signature(member.function, p_source);
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 00:14:56 +02:00
break;
GDScript: Allow enum values to be set to constant expressions Also allow them to access previous values wihout referencing the enum.
2020-08-18 22:44:20 +02:00
case GDScriptParser::ClassNode::Member::ENUM_VALUE: {
GDScript: Fix infinite recursion in resolution of enum values
2023-01-13 14:17:30 +01:00
member.enum_value.identifier->set_datatype(resolving_datatype);
GDScript: Allow enum values to be set to constant expressions Also allow them to access previous values wihout referencing the enum.
2020-08-18 22:44:20 +02:00
if (member.enum_value.custom_value) {
Check for GDScript member and class naming conflicts in a variety of conditions.
2021-08-24 18:49:03 +02:00
check_class_member_name_conflict(p_class, member.enum_value.identifier->name, member.enum_value.custom_value);
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
const GDScriptParser::EnumNode *prev_enum = current_enum;
GDScript: Allow enum values to be set to constant expressions Also allow them to access previous values wihout referencing the enum.
2020-08-18 22:44:20 +02:00
current_enum = member.enum_value.parent_enum;
reduce_expression(member.enum_value.custom_value);
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
current_enum = prev_enum;
GDScript: Allow enum values to be set to constant expressions Also allow them to access previous values wihout referencing the enum.
2020-08-18 22:44:20 +02:00
if (!member.enum_value.custom_value->is_constant) {
push_error(R"(Enum values must be constant.)", member.enum_value.custom_value);
} else if (member.enum_value.custom_value->reduced_value.get_type() != Variant::INT) {
push_error(R"(Enum values must be integers.)", member.enum_value.custom_value);
} else {
member.enum_value.value = member.enum_value.custom_value->reduced_value;
member.enum_value.resolved = true;
}
} else {
Check for GDScript member and class naming conflicts in a variety of conditions.
2021-08-24 18:49:03 +02:00
check_class_member_name_conflict(p_class, member.enum_value.identifier->name, member.enum_value.parent_enum);
GDScript: Allow enum values to be set to constant expressions Also allow them to access previous values wihout referencing the enum.
2020-08-18 22:44:20 +02:00
if (member.enum_value.index > 0) {
Fix enum value regression
2022-12-17 04:46:00 +01:00
const GDScriptParser::EnumNode::Value &prev_value = member.enum_value.parent_enum->values[member.enum_value.index - 1];
resolve_class_member(p_class, prev_value.identifier->name, member.enum_value.identifier);
member.enum_value.value = prev_value.value + 1;
GDScript: Allow enum values to be set to constant expressions Also allow them to access previous values wihout referencing the enum.
2020-08-18 22:44:20 +02:00
} else {
member.enum_value.value = 0;
}
member.enum_value.resolved = true;
}
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
GDScript: Allow enum values to be set to constant expressions Also allow them to access previous values wihout referencing the enum.
2020-08-18 22:44:20 +02:00
// Also update the original references.
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
member.enum_value.parent_enum->values.set(member.enum_value.index, member.enum_value);
Assorted enum and native type fixes
2022-12-04 04:02:03 +01:00
member.enum_value.identifier->set_datatype(make_enum_type(UNNAMED_ENUM, p_class->fqcn, false));
GDScript: Allow enum values to be set to constant expressions Also allow them to access previous values wihout referencing the enum.
2020-08-18 22:44:20 +02:00
} break;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
case GDScriptParser::ClassNode::Member::CLASS:
Check for GDScript member and class naming conflicts in a variety of conditions.
2021-08-24 18:49:03 +02:00
check_class_member_name_conflict(p_class, member.m_class->identifier->name, member.m_class);
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
// If it's already resolving, that's ok.
if (!member.m_class->base_type.is_resolving()) {
resolve_class_inheritance(member.m_class, p_source);
}
Check for GDScript member and class naming conflicts in a variety of conditions.
2021-08-24 18:49:03 +02:00
break;
Add grouping annotations for class properties in GDScript
2022-07-03 21:30:08 +02:00
case GDScriptParser::ClassNode::Member::GROUP:
// No-op, but needed to silence warnings.
break;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
case GDScriptParser::ClassNode::Member::UNDEFINED:
ERR_PRINT("Trying to resolve undefined member.");
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 00:14:56 +02:00
break;
}
GDScript: Add warnings that are set to error by default - Adds a list of default levels for all warning so they can be set individually. - Add warnings set by default to error for: - Using `get_node()` without `@onready`. - Using `@onready` together with `@export`. - Inferring a static type with a Variant value. - Overriding a native engine method. - Adjust how annotations to ignore warnings are treated so they also apply to method parameters. - Clean up a bit how ignored warnings are set. There were two sets but only one was actually being used. - Set all warnings to the `WARN` level for tests, so they they can be properly tested. - Fix enum types in native methods signatures being set to `int`. - Fix native enums being treated as Dictionary by mistake. - Make name of native enum types use the class they are defined in, not the direct super class of the script. This ensures they are always equal even when coming from different sources. - Fix error for signature mismatch that was only showing the first default argument as having a default. Now it shows for all.
2023-02-02 15:57:22 +01:00
#ifdef DEBUG_ENABLED
parser->ignored_warnings = previously_ignored_warnings;
#endif
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 00:14:56 +02:00
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
parser->current_class = previous_class;
}
void GDScriptAnalyzer::resolve_class_interface(GDScriptParser::ClassNode *p_class, const GDScriptParser::Node *p_source) {
if (p_source == nullptr && parser->has_class(p_class)) {
p_source = p_class;
}
Add support for static variables in GDScript Which allows editable data associated with a particular class instead of the instance. Scripts with static variables are kept in memory indefinitely unless the `@static_unload` annotation is used or the `static_unload()` method is called on the GDScript. If the custom function `_static_init()` exists it will be called when the class is loaded, after the static variables are set.
2023-04-19 16:10:35 +02:00
#ifdef DEBUG_ENABLED
bool has_static_data = p_class->has_static_data;
#endif
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
if (!p_class->resolved_interface) {
if (!parser->has_class(p_class)) {
String script_path = p_class->get_datatype().script_path;
Ref<GDScriptParserRef> parser_ref = get_parser_for(script_path);
if (parser_ref.is_null()) {
push_error(vformat(R"(Could not find script "%s".)", script_path), p_source);
return;
}
Error err = parser_ref->raise_status(GDScriptParserRef::PARSED);
if (err) {
push_error(vformat(R"(Could not resolve script "%s": %s.)", script_path, error_names[err]), p_source);
return;
}
ERR_FAIL_COND_MSG(!parser_ref->get_parser()->has_class(p_class), R"(Parser bug: Mismatched external parser.)");
GDScriptAnalyzer *other_analyzer = parser_ref->get_analyzer();
GDScriptParser *other_parser = parser_ref->get_parser();
int error_count = other_parser->errors.size();
other_analyzer->resolve_class_interface(p_class);
if (other_parser->errors.size() > error_count) {
push_error(vformat(R"(Could not resolve class "%s".)", p_class->fqcn), p_source);
}
return;
}
p_class->resolved_interface = true;
if (resolve_class_inheritance(p_class) != OK) {
return;
}
GDScriptParser::DataType base_type = p_class->base_type;
if (base_type.kind == GDScriptParser::DataType::CLASS) {
GDScriptParser::ClassNode *base_class = base_type.class_type;
resolve_class_interface(base_class, p_class);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
for (int i = 0; i < p_class->members.size(); i++) {
resolve_class_member(p_class, i);
Add support for static variables in GDScript Which allows editable data associated with a particular class instead of the instance. Scripts with static variables are kept in memory indefinitely unless the `@static_unload` annotation is used or the `static_unload()` method is called on the GDScript. If the custom function `_static_init()` exists it will be called when the class is loaded, after the static variables are set.
2023-04-19 16:10:35 +02:00
#ifdef DEBUG_ENABLED
if (!has_static_data) {
GDScriptParser::ClassNode::Member member = p_class->members[i];
if (member.type == GDScriptParser::ClassNode::Member::CLASS) {
has_static_data = member.m_class->has_static_data;
}
}
#endif
}
#ifdef DEBUG_ENABLED
if (!has_static_data && p_class->annotated_static_unload) {
GDScriptParser::Node *static_unload = nullptr;
for (GDScriptParser::AnnotationNode *node : p_class->annotations) {
if (node->name == "@static_unload") {
static_unload = node;
break;
}
}
parser->push_warning(static_unload ? static_unload : p_class, GDScriptWarning::REDUNDANT_STATIC_UNLOAD);
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
}
Add support for static variables in GDScript Which allows editable data associated with a particular class instead of the instance. Scripts with static variables are kept in memory indefinitely unless the `@static_unload` annotation is used or the `static_unload()` method is called on the GDScript. If the custom function `_static_init()` exists it will be called when the class is loaded, after the static variables are set.
2023-04-19 16:10:35 +02:00
#endif
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
void GDScriptAnalyzer::resolve_class_interface(GDScriptParser::ClassNode *p_class, bool p_recursive) {
resolve_class_interface(p_class);
if (p_recursive) {
for (int i = 0; i < p_class->members.size(); i++) {
GDScriptParser::ClassNode::Member member = p_class->members[i];
if (member.type == GDScriptParser::ClassNode::Member::CLASS) {
resolve_class_interface(member.m_class, true);
}
}
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
void GDScriptAnalyzer::resolve_class_body(GDScriptParser::ClassNode *p_class, const GDScriptParser::Node *p_source) {
if (p_source == nullptr && parser->has_class(p_class)) {
p_source = p_class;
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
if (p_class->resolved_body) {
return;
}
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
if (!parser->has_class(p_class)) {
String script_path = p_class->get_datatype().script_path;
Ref<GDScriptParserRef> parser_ref = get_parser_for(script_path);
if (parser_ref.is_null()) {
push_error(vformat(R"(Could not find script "%s".)", script_path), p_source);
return;
}
Error err = parser_ref->raise_status(GDScriptParserRef::PARSED);
if (err) {
push_error(vformat(R"(Could not resolve script "%s": %s.)", script_path, error_names[err]), p_source);
return;
}
ERR_FAIL_COND_MSG(!parser_ref->get_parser()->has_class(p_class), R"(Parser bug: Mismatched external parser.)");
GDScriptAnalyzer *other_analyzer = parser_ref->get_analyzer();
GDScriptParser *other_parser = parser_ref->get_parser();
int error_count = other_parser->errors.size();
other_analyzer->resolve_class_body(p_class);
if (other_parser->errors.size() > error_count) {
push_error(vformat(R"(Could not resolve class "%s".)", p_class->fqcn), p_source);
}
return;
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
p_class->resolved_body = true;
GDScriptParser::ClassNode *previous_class = parser->current_class;
parser->current_class = p_class;
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
resolve_class_interface(p_class, p_source);
GDScriptParser::DataType base_type = p_class->base_type;
if (base_type.kind == GDScriptParser::DataType::CLASS) {
GDScriptParser::ClassNode *base_class = base_type.class_type;
resolve_class_body(base_class, p_class);
}
GDScript: Fix broken export group annotations
2023-01-27 14:25:15 +01:00
// Do functions, properties, and groups now.
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
for (int i = 0; i < p_class->members.size(); i++) {
GDScriptParser::ClassNode::Member member = p_class->members[i];
GDScript: Report property type errors Inline getters & setters are now FunctionNodes. Their names are set in the parser, not in the compiler. GDScript-Analyzer will now run through getter and setter. Also report wrong type or signature errors regarding getset properties. Added GDScript tests for getters and setters. #53102
2021-09-06 07:04:43 +02:00
if (member.type == GDScriptParser::ClassNode::Member::FUNCTION) {
// Apply annotations.
for (GDScriptParser::AnnotationNode *&E : member.function->annotations) {
GDScript: Allow constant expressions in annotations
2023-01-18 18:12:33 +01:00
resolve_annotation(E);
GDScript: Report property type errors Inline getters & setters are now FunctionNodes. Their names are set in the parser, not in the compiler. GDScript-Analyzer will now run through getter and setter. Also report wrong type or signature errors regarding getset properties. Added GDScript tests for getters and setters. #53102
2021-09-06 07:04:43 +02:00
E->apply(parser, member.function);
}
GDScript: Add annotation to ignore warnings
2022-01-04 13:32:43 +01:00
resolve_function_body(member.function);
GDScript: Report property type errors Inline getters & setters are now FunctionNodes. Their names are set in the parser, not in the compiler. GDScript-Analyzer will now run through getter and setter. Also report wrong type or signature errors regarding getset properties. Added GDScript tests for getters and setters. #53102
2021-09-06 07:04:43 +02:00
} 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);
Move GDSript annotation application after type-checking This ensures that annotations that rely on the datatype (such as @export) can validated it timely, allowing compound expressions instead of only literal values.
2021-03-17 14:57:30 +01:00
GDScript: Report property type errors Inline getters & setters are now FunctionNodes. Their names are set in the parser, not in the compiler. GDScript-Analyzer will now run through getter and setter. Also report wrong type or signature errors regarding getset properties. Added GDScript tests for getters and setters. #53102
2021-09-06 07:04:43 +02:00
resolve_function_body(member.variable->getter);
}
if (member.variable->setter != nullptr) {
GDScript: Make setter parameter type same as variable type
2021-10-12 14:39:23 +02:00
resolve_function_signature(member.variable->setter);
GDScript: Report property type errors Inline getters & setters are now FunctionNodes. Their names are set in the parser, not in the compiler. GDScript-Analyzer will now run through getter and setter. Also report wrong type or signature errors regarding getset properties. Added GDScript tests for getters and setters. #53102
2021-09-06 07:04:43 +02:00
if (member.variable->setter->parameters.size() > 0) {
member.variable->setter->parameters[0]->datatype_specifier = member.variable->datatype_specifier;
GDScript: Make setter parameter type same as variable type
2021-10-12 14:39:23 +02:00
member.variable->setter->parameters[0]->set_datatype(member.get_datatype());
GDScript: Report property type errors Inline getters & setters are now FunctionNodes. Their names are set in the parser, not in the compiler. GDScript-Analyzer will now run through getter and setter. Also report wrong type or signature errors regarding getset properties. Added GDScript tests for getters and setters. #53102
2021-09-06 07:04:43 +02:00
}
resolve_function_body(member.variable->setter);
}
}
GDScript: Fix broken export group annotations
2023-01-27 14:25:15 +01:00
} else if (member.type == GDScriptParser::ClassNode::Member::GROUP) {
// Apply annotation (`@export_{category,group,subgroup}`).
resolve_annotation(member.annotation);
member.annotation->apply(parser, nullptr);
Move GDSript annotation application after type-checking This ensures that annotations that rely on the datatype (such as @export) can validated it timely, allowing compound expressions instead of only literal values.
2021-03-17 14:57:30 +01:00
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
GDScript: Report property type errors Inline getters & setters are now FunctionNodes. Their names are set in the parser, not in the compiler. GDScript-Analyzer will now run through getter and setter. Also report wrong type or signature errors regarding getset properties. Added GDScript tests for getters and setters. #53102
2021-09-06 07:04:43 +02:00
// Check unused variables and datatypes of property getters and setters.
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
for (int i = 0; i < p_class->members.size(); i++) {
GDScriptParser::ClassNode::Member member = p_class->members[i];
GDScript: Report property type errors Inline getters & setters are now FunctionNodes. Their names are set in the parser, not in the compiler. GDScript-Analyzer will now run through getter and setter. Also report wrong type or signature errors regarding getset properties. Added GDScript tests for getters and setters. #53102
2021-09-06 07:04:43 +02:00
if (member.type == GDScriptParser::ClassNode::Member::VARIABLE) {
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
#ifdef DEBUG_ENABLED
GDScript: Add warnings that are set to error by default - Adds a list of default levels for all warning so they can be set individually. - Add warnings set by default to error for: - Using `get_node()` without `@onready`. - Using `@onready` together with `@export`. - Inferring a static type with a Variant value. - Overriding a native engine method. - Adjust how annotations to ignore warnings are treated so they also apply to method parameters. - Clean up a bit how ignored warnings are set. There were two sets but only one was actually being used. - Set all warnings to the `WARN` level for tests, so they they can be properly tested. - Fix enum types in native methods signatures being set to `int`. - Fix native enums being treated as Dictionary by mistake. - Make name of native enum types use the class they are defined in, not the direct super class of the script. This ensures they are always equal even when coming from different sources. - Fix error for signature mismatch that was only showing the first default argument as having a default. Now it shows for all.
2023-02-02 15:57:22 +01:00
HashSet<GDScriptWarning::Code> previously_ignored_warnings = parser->ignored_warnings;
for (GDScriptWarning::Code ignored_warning : member.variable->ignored_warnings) {
parser->ignored_warnings.insert(ignored_warning);
GDScript: Add annotation to ignore warnings
2022-01-04 13:32:43 +01:00
}
GDScript: Report property type errors Inline getters & setters are now FunctionNodes. Their names are set in the parser, not in the compiler. GDScript-Analyzer will now run through getter and setter. Also report wrong type or signature errors regarding getset properties. Added GDScript tests for getters and setters. #53102
2021-09-06 07:04:43 +02:00
if (member.variable->usages == 0 && String(member.variable->identifier->name).begins_with("_")) {
parser->push_warning(member.variable->identifier, GDScriptWarning::UNUSED_PRIVATE_CLASS_VARIABLE, member.variable->identifier->name);
}
#endif
if (member.variable->property == GDScriptParser::VariableNode::PROP_SETGET) {
GDScriptParser::FunctionNode *getter_function = nullptr;
GDScriptParser::FunctionNode *setter_function = nullptr;
bool has_valid_getter = false;
bool has_valid_setter = false;
if (member.variable->getter_pointer != nullptr) {
if (p_class->has_function(member.variable->getter_pointer->name)) {
getter_function = p_class->get_member(member.variable->getter_pointer->name).function;
}
if (getter_function == nullptr) {
push_error(vformat(R"(Getter "%s" not found.)", member.variable->getter_pointer->name), member.variable);
} else {
[godot#68001] Fix property getter with custom return type
2022-10-30 02:38:26 +02:00
GDScriptParser::DataType return_datatype = getter_function->datatype;
if (getter_function->return_type != nullptr) {
return_datatype = getter_function->return_type->datatype;
return_datatype.is_meta_type = false;
}
if (getter_function->parameters.size() != 0 || return_datatype.has_no_type()) {
push_error(vformat(R"(Function "%s" cannot be used as getter because of its signature.)", getter_function->identifier->name), member.variable);
} else if (!is_type_compatible(member.variable->datatype, return_datatype, true)) {
push_error(vformat(R"(Function with return type "%s" cannot be used as getter for a property of type "%s".)", return_datatype.to_string(), member.variable->datatype.to_string()), member.variable);
GDScript: Report property type errors Inline getters & setters are now FunctionNodes. Their names are set in the parser, not in the compiler. GDScript-Analyzer will now run through getter and setter. Also report wrong type or signature errors regarding getset properties. Added GDScript tests for getters and setters. #53102
2021-09-06 07:04:43 +02:00
[godot#68001] Fix property getter with custom return type
2022-10-30 02:38:26 +02:00
} else {
has_valid_getter = true;
GDScript: Report property type errors Inline getters & setters are now FunctionNodes. Their names are set in the parser, not in the compiler. GDScript-Analyzer will now run through getter and setter. Also report wrong type or signature errors regarding getset properties. Added GDScript tests for getters and setters. #53102
2021-09-06 07:04:43 +02:00
#ifdef DEBUG_ENABLED
[godot#68001] Fix property getter with custom return type
2022-10-30 02:38:26 +02:00
if (member.variable->datatype.builtin_type == Variant::INT && return_datatype.builtin_type == Variant::FLOAT) {
parser->push_warning(member.variable, GDScriptWarning::NARROWING_CONVERSION);
}
GDScript: Report property type errors Inline getters & setters are now FunctionNodes. Their names are set in the parser, not in the compiler. GDScript-Analyzer will now run through getter and setter. Also report wrong type or signature errors regarding getset properties. Added GDScript tests for getters and setters. #53102
2021-09-06 07:04:43 +02:00
#endif
[godot#68001] Fix property getter with custom return type
2022-10-30 02:38:26 +02:00
}
GDScript: Report property type errors Inline getters & setters are now FunctionNodes. Their names are set in the parser, not in the compiler. GDScript-Analyzer will now run through getter and setter. Also report wrong type or signature errors regarding getset properties. Added GDScript tests for getters and setters. #53102
2021-09-06 07:04:43 +02:00
}
}
if (member.variable->setter_pointer != nullptr) {
if (p_class->has_function(member.variable->setter_pointer->name)) {
setter_function = p_class->get_member(member.variable->setter_pointer->name).function;
}
if (setter_function == nullptr) {
push_error(vformat(R"(Setter "%s" not found.)", member.variable->setter_pointer->name), member.variable);
} else if (setter_function->parameters.size() != 1) {
push_error(vformat(R"(Function "%s" cannot be used as setter because of its signature.)", setter_function->identifier->name), member.variable);
} else if (!is_type_compatible(member.variable->datatype, setter_function->parameters[0]->datatype, true)) {
push_error(vformat(R"(Function with argument type "%s" cannot be used as setter for a property of type "%s".)", setter_function->parameters[0]->datatype.to_string(), member.variable->datatype.to_string()), member.variable);
} else {
has_valid_setter = true;
#ifdef DEBUG_ENABLED
Fix incorrect debug check for setters the check read the return type of the setter, which doesn't exist and lead to a segmentation fault. Now we check the first function parameter. Probably a bad copy/paste of the getter case
2021-10-18 09:01:16 +02:00
if (member.variable->datatype.builtin_type == Variant::FLOAT && setter_function->parameters[0]->datatype.builtin_type == Variant::INT) {
GDScript: Report property type errors Inline getters & setters are now FunctionNodes. Their names are set in the parser, not in the compiler. GDScript-Analyzer will now run through getter and setter. Also report wrong type or signature errors regarding getset properties. Added GDScript tests for getters and setters. #53102
2021-09-06 07:04:43 +02:00
parser->push_warning(member.variable, GDScriptWarning::NARROWING_CONVERSION);
}
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
#endif
GDScript: Report property type errors Inline getters & setters are now FunctionNodes. Their names are set in the parser, not in the compiler. GDScript-Analyzer will now run through getter and setter. Also report wrong type or signature errors regarding getset properties. Added GDScript tests for getters and setters. #53102
2021-09-06 07:04:43 +02:00
}
}
if (member.variable->datatype.is_variant() && has_valid_getter && has_valid_setter) {
if (!is_type_compatible(getter_function->datatype, setter_function->parameters[0]->datatype, true)) {
push_error(vformat(R"(Getter with type "%s" cannot be used along with setter of type "%s".)", getter_function->datatype.to_string(), setter_function->parameters[0]->datatype.to_string()), member.variable);
}
}
GDScript: Fix warning ignoring for member variables
2023-04-18 13:08:48 +02:00
}
GDScript: Add annotation to ignore warnings
2022-01-04 13:32:43 +01:00
#ifdef DEBUG_ENABLED
GDScript: Fix warning ignoring for member variables
2023-04-18 13:08:48 +02:00
parser->ignored_warnings = previously_ignored_warnings;
GDScript: Add annotation to ignore warnings
2022-01-04 13:32:43 +01:00
#endif // DEBUG_ENABLED
GDScript: Report property type errors Inline getters & setters are now FunctionNodes. Their names are set in the parser, not in the compiler. GDScript-Analyzer will now run through getter and setter. Also report wrong type or signature errors regarding getset properties. Added GDScript tests for getters and setters. #53102
2021-09-06 07:04:43 +02:00
}
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
}
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
GDScript: Fix lambda resolution with cyclic references
2023-08-23 11:37:18 +02:00
if (!pending_body_resolution_lambdas.is_empty()) {
ERR_PRINT("GDScript bug (please report): Not all pending lambda bodies were resolved in time.");
resolve_pending_lambda_bodies();
}
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
parser->current_class = previous_class;
}
void GDScriptAnalyzer::resolve_class_body(GDScriptParser::ClassNode *p_class, bool p_recursive) {
resolve_class_body(p_class);
if (p_recursive) {
for (int i = 0; i < p_class->members.size(); i++) {
GDScriptParser::ClassNode::Member member = p_class->members[i];
if (member.type == GDScriptParser::ClassNode::Member::CLASS) {
resolve_class_body(member.m_class, true);
}
}
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
Implement RETURN_VALUE_DISCARDED warning in GDscript
2022-10-13 19:31:12 +02:00
void GDScriptAnalyzer::resolve_node(GDScriptParser::Node *p_node, bool p_is_root) {
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
ERR_FAIL_COND_MSG(p_node == nullptr, "Trying to resolve type of a null node.");
switch (p_node->type) {
case GDScriptParser::Node::NONE:
break; // Unreachable.
case GDScriptParser::Node::CLASS:
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
if (OK == resolve_class_inheritance(static_cast<GDScriptParser::ClassNode *>(p_node), true)) {
resolve_class_interface(static_cast<GDScriptParser::ClassNode *>(p_node), true);
resolve_class_body(static_cast<GDScriptParser::ClassNode *>(p_node), true);
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
break;
case GDScriptParser::Node::CONSTANT:
Unify typing of variables, constants and parameters in GDScript
2022-12-22 21:43:36 +01:00
resolve_constant(static_cast<GDScriptParser::ConstantNode *>(p_node), true);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
break;
case GDScriptParser::Node::FOR:
resolve_for(static_cast<GDScriptParser::ForNode *>(p_node));
break;
case GDScriptParser::Node::IF:
resolve_if(static_cast<GDScriptParser::IfNode *>(p_node));
break;
case GDScriptParser::Node::SUITE:
resolve_suite(static_cast<GDScriptParser::SuiteNode *>(p_node));
break;
case GDScriptParser::Node::VARIABLE:
Unify typing of variables, constants and parameters in GDScript
2022-12-22 21:43:36 +01:00
resolve_variable(static_cast<GDScriptParser::VariableNode *>(p_node), true);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
break;
case GDScriptParser::Node::WHILE:
resolve_while(static_cast<GDScriptParser::WhileNode *>(p_node));
break;
case GDScriptParser::Node::ANNOTATION:
resolve_annotation(static_cast<GDScriptParser::AnnotationNode *>(p_node));
break;
case GDScriptParser::Node::ASSERT:
resolve_assert(static_cast<GDScriptParser::AssertNode *>(p_node));
break;
case GDScriptParser::Node::MATCH:
resolve_match(static_cast<GDScriptParser::MatchNode *>(p_node));
break;
case GDScriptParser::Node::MATCH_BRANCH:
resolve_match_branch(static_cast<GDScriptParser::MatchBranchNode *>(p_node), nullptr);
break;
case GDScriptParser::Node::PARAMETER:
GDScript: parameter infer type bug fix Fix: #41772
2020-09-06 09:56:52 +02:00
resolve_parameter(static_cast<GDScriptParser::ParameterNode *>(p_node));
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
break;
case GDScriptParser::Node::PATTERN:
resolve_match_pattern(static_cast<GDScriptParser::PatternNode *>(p_node), nullptr);
break;
case GDScriptParser::Node::RETURN:
resolve_return(static_cast<GDScriptParser::ReturnNode *>(p_node));
break;
case GDScriptParser::Node::TYPE:
resolve_datatype(static_cast<GDScriptParser::TypeNode *>(p_node));
break;
// Resolving expression is the same as reducing them.
case GDScriptParser::Node::ARRAY:
case GDScriptParser::Node::ASSIGNMENT:
case GDScriptParser::Node::AWAIT:
case GDScriptParser::Node::BINARY_OPERATOR:
case GDScriptParser::Node::CALL:
case GDScriptParser::Node::CAST:
case GDScriptParser::Node::DICTIONARY:
case GDScriptParser::Node::GET_NODE:
case GDScriptParser::Node::IDENTIFIER:
GDScript: Add lambdas to the type analyzer - Lambdas are always callables (no specific signature match). - Captures from the current context are evaluated.
2021-03-26 13:03:16 +01:00
case GDScriptParser::Node::LAMBDA:
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
case GDScriptParser::Node::LITERAL:
case GDScriptParser::Node::PRELOAD:
case GDScriptParser::Node::SELF:
case GDScriptParser::Node::SUBSCRIPT:
case GDScriptParser::Node::TERNARY_OPERATOR:
GDScript: Rework type check
2023-02-17 00:16:24 +01:00
case GDScriptParser::Node::TYPE_TEST:
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
case GDScriptParser::Node::UNARY_OPERATOR:
Implement RETURN_VALUE_DISCARDED warning in GDscript
2022-10-13 19:31:12 +02:00
reduce_expression(static_cast<GDScriptParser::ExpressionNode *>(p_node), p_is_root);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
break;
case GDScriptParser::Node::BREAK:
case GDScriptParser::Node::BREAKPOINT:
case GDScriptParser::Node::CONTINUE:
case GDScriptParser::Node::ENUM:
GDScript: Fix typing of lambda functions
2022-12-28 06:41:03 +01:00
case GDScriptParser::Node::FUNCTION:
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
case GDScriptParser::Node::PASS:
case GDScriptParser::Node::SIGNAL:
// Nothing to do.
break;
}
}
void GDScriptAnalyzer::resolve_annotation(GDScriptParser::AnnotationNode *p_annotation) {
GDScript: Allow constant expressions in annotations
2023-01-18 18:12:33 +01:00
ERR_FAIL_COND_MSG(!parser->valid_annotations.has(p_annotation->name), vformat(R"(Annotation "%s" not found to validate.)", p_annotation->name));
GDScript: Add warnings that are set to error by default - Adds a list of default levels for all warning so they can be set individually. - Add warnings set by default to error for: - Using `get_node()` without `@onready`. - Using `@onready` together with `@export`. - Inferring a static type with a Variant value. - Overriding a native engine method. - Adjust how annotations to ignore warnings are treated so they also apply to method parameters. - Clean up a bit how ignored warnings are set. There were two sets but only one was actually being used. - Set all warnings to the `WARN` level for tests, so they they can be properly tested. - Fix enum types in native methods signatures being set to `int`. - Fix native enums being treated as Dictionary by mistake. - Make name of native enum types use the class they are defined in, not the direct super class of the script. This ensures they are always equal even when coming from different sources. - Fix error for signature mismatch that was only showing the first default argument as having a default. Now it shows for all.
2023-02-02 15:57:22 +01:00
if (p_annotation->is_resolved) {
return;
}
p_annotation->is_resolved = true;
GDScript: Allow constant expressions in annotations
2023-01-18 18:12:33 +01:00
const MethodInfo &annotation_info = parser->valid_annotations[p_annotation->name].info;
const List<PropertyInfo>::Element *E = annotation_info.arguments.front();
for (int i = 0; i < p_annotation->arguments.size(); i++) {
GDScriptParser::ExpressionNode *argument = p_annotation->arguments[i];
const PropertyInfo &argument_info = E->get();
if (E->next() != nullptr) {
E = E->next();
}
reduce_expression(argument);
if (!argument->is_constant) {
push_error(vformat(R"(Argument %d of annotation "%s" isn't a constant expression.)", i + 1, p_annotation->name), argument);
return;
}
Variant value = argument->reduced_value;
if (value.get_type() != argument_info.type) {
#ifdef DEBUG_ENABLED
if (argument_info.type == Variant::INT && value.get_type() == Variant::FLOAT) {
parser->push_warning(argument, GDScriptWarning::NARROWING_CONVERSION);
}
#endif
if (!Variant::can_convert_strict(value.get_type(), argument_info.type)) {
push_error(vformat(R"(Invalid argument for annotation "%s": argument %d should be "%s" but is "%s".)", p_annotation->name, i + 1, Variant::get_type_name(argument_info.type), argument->get_datatype().to_string()), argument);
return;
}
Variant converted_to;
const Variant *converted_from = &value;
Callable::CallError call_error;
Variant::construct(argument_info.type, converted_to, &converted_from, 1, call_error);
if (call_error.error != Callable::CallError::CALL_OK) {
push_error(vformat(R"(Cannot convert argument %d of annotation "%s" from "%s" to "%s".)", i + 1, p_annotation->name, Variant::get_type_name(value.get_type()), Variant::get_type_name(argument_info.type)), argument);
return;
}
value = converted_to;
}
p_annotation->resolved_arguments.push_back(value);
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
GDScript: Fix typing of lambda functions
2022-12-28 06:41:03 +01:00
void GDScriptAnalyzer::resolve_function_signature(GDScriptParser::FunctionNode *p_function, const GDScriptParser::Node *p_source, bool p_is_lambda) {
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
if (p_source == nullptr) {
p_source = p_function;
}
GDScript: Fix typing of lambda functions
2022-12-28 06:41:03 +01:00
StringName function_name = p_function->identifier != nullptr ? p_function->identifier->name : StringName();
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
if (p_function->get_datatype().is_resolving()) {
GDScript: Fix typing of lambda functions
2022-12-28 06:41:03 +01:00
push_error(vformat(R"(Could not resolve function "%s": Cyclic reference.)", function_name), p_source);
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
return;
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
if (p_function->resolved_signature) {
return;
}
p_function->resolved_signature = true;
GDScript: Add warnings that are set to error by default - Adds a list of default levels for all warning so they can be set individually. - Add warnings set by default to error for: - Using `get_node()` without `@onready`. - Using `@onready` together with `@export`. - Inferring a static type with a Variant value. - Overriding a native engine method. - Adjust how annotations to ignore warnings are treated so they also apply to method parameters. - Clean up a bit how ignored warnings are set. There were two sets but only one was actually being used. - Set all warnings to the `WARN` level for tests, so they they can be properly tested. - Fix enum types in native methods signatures being set to `int`. - Fix native enums being treated as Dictionary by mistake. - Make name of native enum types use the class they are defined in, not the direct super class of the script. This ensures they are always equal even when coming from different sources. - Fix error for signature mismatch that was only showing the first default argument as having a default. Now it shows for all.
2023-02-02 15:57:22 +01:00
#ifdef DEBUG_ENABLED
HashSet<GDScriptWarning::Code> previously_ignored_warnings = parser->ignored_warnings;
for (GDScriptWarning::Code ignored_warning : p_function->ignored_warnings) {
parser->ignored_warnings.insert(ignored_warning);
}
#endif
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
GDScriptParser::FunctionNode *previous_function = parser->current_function;
parser->current_function = p_function;
Add support for static variables in GDScript Which allows editable data associated with a particular class instead of the instance. Scripts with static variables are kept in memory indefinitely unless the `@static_unload` annotation is used or the `static_unload()` method is called on the GDScript. If the custom function `_static_init()` exists it will be called when the class is loaded, after the static variables are set.
2023-04-19 16:10:35 +02:00
bool previous_static_context = static_context;
static_context = p_function->is_static;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
GDScriptParser::DataType prev_datatype = p_function->get_datatype();
GDScriptParser::DataType resolving_datatype;
resolving_datatype.kind = GDScriptParser::DataType::RESOLVING;
p_function->set_datatype(resolving_datatype);
Fix default value count checking for inherited function
2022-03-14 15:55:37 +01:00
#ifdef TOOLS_ENABLED
int default_value_count = 0;
#endif // TOOLS_ENABLED
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
for (int i = 0; i < p_function->parameters.size(); i++) {
GDScript: parameter infer type bug fix Fix: #41772
2020-09-06 09:56:52 +02:00
resolve_parameter(p_function->parameters[i]);
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
#ifdef DEBUG_ENABLED
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
if (p_function->parameters[i]->usages == 0 && !String(p_function->parameters[i]->identifier->name).begins_with("_")) {
GDScript: Reorganize and unify warnings
2023-04-28 17:20:41 +02:00
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);
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
}
Fix for not being able to ignore shadowing warnings on class scope
2023-04-03 15:57:41 +02:00
is_shadowing(p_function->parameters[i]->identifier, "function parameter", true);
Documentation generation for GDScript - ClassDoc added to GDScript and property reflection data were extracted from parse tree - GDScript comments are collected from tokenizer for documentation and applied to the ClassDoc by the GDScript compiler - private docs were excluded (name with underscore prefix and doesn't have any doc comments) - default values (of non exported vars), arguments are extraced from the parser - Integrated with GDScript 2.0 and new enums were added. - merge conflicts fixed
2020-11-29 03:37:57 +01:00
#endif // DEBUG_ENABLED
#ifdef TOOLS_ENABLED
Unify typing of variables, constants and parameters in GDScript
2022-12-22 21:43:36 +01:00
if (p_function->parameters[i]->initializer) {
Fix default value count checking for inherited function
2022-03-14 15:55:37 +01:00
default_value_count++;
Unify typing of variables, constants and parameters in GDScript
2022-12-22 21:43:36 +01:00
if (p_function->parameters[i]->initializer->is_constant) {
p_function->default_arg_values.push_back(p_function->parameters[i]->initializer->reduced_value);
GDScript 2.0: Fix shift due to skip of non-constant default argument values
2022-11-10 17:22:52 +01:00
} else {
p_function->default_arg_values.push_back(Variant()); // Prevent shift.
Fix default value count checking for inherited function
2022-03-14 15:55:37 +01:00
}
Documentation generation for GDScript - ClassDoc added to GDScript and property reflection data were extracted from parse tree - GDScript comments are collected from tokenizer for documentation and applied to the ClassDoc by the GDScript compiler - private docs were excluded (name with underscore prefix and doesn't have any doc comments) - default values (of non exported vars), arguments are extraced from the parser - Integrated with GDScript 2.0 and new enums were added. - merge conflicts fixed
2020-11-29 03:37:57 +01:00
}
#endif // TOOLS_ENABLED
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
GDScript: Fix typing of lambda functions
2022-12-28 06:41:03 +01:00
if (!p_is_lambda && function_name == GDScriptLanguage::get_singleton()->strings._init) {
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
// Constructor.
GDScriptParser::DataType return_type = parser->current_class->get_datatype();
return_type.is_meta_type = false;
p_function->set_datatype(return_type);
if (p_function->return_type) {
Allow void as return type for constructors
2021-10-03 20:55:54 +02:00
GDScriptParser::DataType declared_return = resolve_datatype(p_function->return_type);
if (declared_return.kind != GDScriptParser::DataType::BUILTIN || declared_return.builtin_type != Variant::NIL) {
push_error("Constructor cannot have an explicit return type.", p_function->return_type);
}
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
}
Add support for static variables in GDScript Which allows editable data associated with a particular class instead of the instance. Scripts with static variables are kept in memory indefinitely unless the `@static_unload` annotation is used or the `static_unload()` method is called on the GDScript. If the custom function `_static_init()` exists it will be called when the class is loaded, after the static variables are set.
2023-04-19 16:10:35 +02:00
} else if (!p_is_lambda && function_name == GDScriptLanguage::get_singleton()->strings._static_init) {
// Static constructor.
GDScriptParser::DataType return_type;
return_type.kind = GDScriptParser::DataType::BUILTIN;
return_type.builtin_type = Variant::NIL;
p_function->set_datatype(return_type);
if (p_function->return_type) {
GDScriptParser::DataType declared_return = resolve_datatype(p_function->return_type);
if (declared_return.kind != GDScriptParser::DataType::BUILTIN || declared_return.builtin_type != Variant::NIL) {
push_error("Static constructor cannot have an explicit return type.", p_function->return_type);
}
}
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
} else {
GDScript: Don't show redundant await warning on unknown types Also avoid it when the type is known to be a signal.
2022-05-24 18:40:36 +02:00
if (p_function->return_type != nullptr) {
Assorted enum and native type fixes
2022-12-04 04:02:03 +01:00
p_function->set_datatype(type_from_metatype(resolve_datatype(p_function->return_type)));
GDScript: Don't show redundant await warning on unknown types Also avoid it when the type is known to be a signal.
2022-05-24 18:40:36 +02:00
} else {
// In case the function is not typed, we can safely assume it's a Variant, so it's okay to mark as "inferred" here.
// It's not "undetected" to not mix up with unknown functions.
GDScriptParser::DataType return_type;
return_type.type_source = GDScriptParser::DataType::INFERRED;
return_type.kind = GDScriptParser::DataType::VARIANT;
p_function->set_datatype(return_type);
}
GDScript: Check if method signature matches the parent To guarantee polymorphism, a method signature must be compatible with the parent. This checks if: 1. Return type is the same. 2. The subclass method takes at least the same amount of parameters. 3. The matching parameters have the same type. 4. If the subclass takes more parameters, all of the extra ones have a default value. 5. If the superclass has default values, so must have the subclass. There's a few test cases to ensure this holds up.
2022-03-06 15:09:12 +01:00
Restore building web platform by enclosing resolve_function_signature.
2022-03-07 08:01:52 +01:00
#ifdef TOOLS_ENABLED
GDScript: Check if method signature matches the parent To guarantee polymorphism, a method signature must be compatible with the parent. This checks if: 1. Return type is the same. 2. The subclass method takes at least the same amount of parameters. 3. The matching parameters have the same type. 4. If the subclass takes more parameters, all of the extra ones have a default value. 5. If the superclass has default values, so must have the subclass. There's a few test cases to ensure this holds up.
2022-03-06 15:09:12 +01:00
// Check if the function signature matches the parent. If not it's an error since it breaks polymorphism.
// Not for the constructor which can vary in signature.
GDScriptParser::DataType base_type = parser->current_class->base_type;
GDScript: Fix override signature check of script inheritance Avoid treating the super class as a meta type for signature check, since it is looking at the instance level for that.
2023-02-21 18:37:08 +01:00
base_type.is_meta_type = false;
GDScript: Check if method signature matches the parent To guarantee polymorphism, a method signature must be compatible with the parent. This checks if: 1. Return type is the same. 2. The subclass method takes at least the same amount of parameters. 3. The matching parameters have the same type. 4. If the subclass takes more parameters, all of the extra ones have a default value. 5. If the superclass has default values, so must have the subclass. There's a few test cases to ensure this holds up.
2022-03-06 15:09:12 +01:00
GDScriptParser::DataType parent_return_type;
List<GDScriptParser::DataType> parameters_types;
int default_par_count = 0;
GDScript: add errors when calling unimplemented virtual functions This PR does a small refactor of how method flags are handled in the GDScript analyzer. This way, it adds support for the analyzer to use any of MethodInfo's flags, where previously it could only use METHOD_FLAG_STATIC and METHOD_FLAG_VARARG. As a side-effect, this also normalizes behavior between editor and release templates, which fixes #76938. The tests added also brought a different issue to light, where using `super()` appears to generate a return variable discarded on calling super's _init(), which doesn't have a return value. This should be tackled in a different PR, which will have to change the output of this PR's tests.
2023-05-22 01:22:00 +02:00
BitField<MethodFlags> method_flags;
GDScript: Add warnings that are set to error by default - Adds a list of default levels for all warning so they can be set individually. - Add warnings set by default to error for: - Using `get_node()` without `@onready`. - Using `@onready` together with `@export`. - Inferring a static type with a Variant value. - Overriding a native engine method. - Adjust how annotations to ignore warnings are treated so they also apply to method parameters. - Clean up a bit how ignored warnings are set. There were two sets but only one was actually being used. - Set all warnings to the `WARN` level for tests, so they they can be properly tested. - Fix enum types in native methods signatures being set to `int`. - Fix native enums being treated as Dictionary by mistake. - Make name of native enum types use the class they are defined in, not the direct super class of the script. This ensures they are always equal even when coming from different sources. - Fix error for signature mismatch that was only showing the first default argument as having a default. Now it shows for all.
2023-02-02 15:57:22 +01:00
StringName native_base;
GDScript: add errors when calling unimplemented virtual functions This PR does a small refactor of how method flags are handled in the GDScript analyzer. This way, it adds support for the analyzer to use any of MethodInfo's flags, where previously it could only use METHOD_FLAG_STATIC and METHOD_FLAG_VARARG. As a side-effect, this also normalizes behavior between editor and release templates, which fixes #76938. The tests added also brought a different issue to light, where using `super()` appears to generate a return variable discarded on calling super's _init(), which doesn't have a return value. This should be tackled in a different PR, which will have to change the output of this PR's tests.
2023-05-22 01:22:00 +02:00
if (!p_is_lambda && get_function_signature(p_function, false, base_type, function_name, parent_return_type, parameters_types, default_par_count, method_flags, &native_base)) {
bool valid = p_function->is_static == method_flags.has_flag(METHOD_FLAG_STATIC);
GDScript: Check if method signature matches the parent To guarantee polymorphism, a method signature must be compatible with the parent. This checks if: 1. Return type is the same. 2. The subclass method takes at least the same amount of parameters. 3. The matching parameters have the same type. 4. If the subclass takes more parameters, all of the extra ones have a default value. 5. If the superclass has default values, so must have the subclass. There's a few test cases to ensure this holds up.
2022-03-06 15:09:12 +01:00
valid = valid && parent_return_type == p_function->get_datatype();
int par_count_diff = p_function->parameters.size() - parameters_types.size();
valid = valid && par_count_diff >= 0;
Fix default value count checking for inherited function
2022-03-14 15:55:37 +01:00
valid = valid && default_value_count >= default_par_count + par_count_diff;
GDScript: Check if method signature matches the parent To guarantee polymorphism, a method signature must be compatible with the parent. This checks if: 1. Return type is the same. 2. The subclass method takes at least the same amount of parameters. 3. The matching parameters have the same type. 4. If the subclass takes more parameters, all of the extra ones have a default value. 5. If the superclass has default values, so must have the subclass. There's a few test cases to ensure this holds up.
2022-03-06 15:09:12 +01:00
int i = 0;
for (const GDScriptParser::DataType &par_type : parameters_types) {
valid = valid && par_type == p_function->parameters[i++]->get_datatype();
}
if (!valid) {
// Compute parent signature as a string to show in the error message.
Assorted enum and native type fixes
2022-12-04 04:02:03 +01:00
String parent_signature = String(function_name) + "(";
GDScript: Check if method signature matches the parent To guarantee polymorphism, a method signature must be compatible with the parent. This checks if: 1. Return type is the same. 2. The subclass method takes at least the same amount of parameters. 3. The matching parameters have the same type. 4. If the subclass takes more parameters, all of the extra ones have a default value. 5. If the superclass has default values, so must have the subclass. There's a few test cases to ensure this holds up.
2022-03-06 15:09:12 +01:00
int j = 0;
for (const GDScriptParser::DataType &par_type : parameters_types) {
if (j > 0) {
parent_signature += ", ";
}
String parameter = par_type.to_string();
if (parameter == "null") {
parameter = "Variant";
}
parent_signature += parameter;
GDScript: Add warnings that are set to error by default - Adds a list of default levels for all warning so they can be set individually. - Add warnings set by default to error for: - Using `get_node()` without `@onready`. - Using `@onready` together with `@export`. - Inferring a static type with a Variant value. - Overriding a native engine method. - Adjust how annotations to ignore warnings are treated so they also apply to method parameters. - Clean up a bit how ignored warnings are set. There were two sets but only one was actually being used. - Set all warnings to the `WARN` level for tests, so they they can be properly tested. - Fix enum types in native methods signatures being set to `int`. - Fix native enums being treated as Dictionary by mistake. - Make name of native enum types use the class they are defined in, not the direct super class of the script. This ensures they are always equal even when coming from different sources. - Fix error for signature mismatch that was only showing the first default argument as having a default. Now it shows for all.
2023-02-02 15:57:22 +01:00
if (j >= parameters_types.size() - default_par_count) {
parent_signature += " = <default>";
GDScript: Check if method signature matches the parent To guarantee polymorphism, a method signature must be compatible with the parent. This checks if: 1. Return type is the same. 2. The subclass method takes at least the same amount of parameters. 3. The matching parameters have the same type. 4. If the subclass takes more parameters, all of the extra ones have a default value. 5. If the superclass has default values, so must have the subclass. There's a few test cases to ensure this holds up.
2022-03-06 15:09:12 +01:00
}
j++;
}
Improve parent signature error
2022-12-01 01:46:01 +01:00
parent_signature += ") -> ";
const String return_type = parent_return_type.is_hard_type() ? parent_return_type.to_string() : "Variant";
if (return_type == "null") {
parent_signature += "void";
} else {
parent_signature += return_type;
}
GDScript: Check if method signature matches the parent To guarantee polymorphism, a method signature must be compatible with the parent. This checks if: 1. Return type is the same. 2. The subclass method takes at least the same amount of parameters. 3. The matching parameters have the same type. 4. If the subclass takes more parameters, all of the extra ones have a default value. 5. If the superclass has default values, so must have the subclass. There's a few test cases to ensure this holds up.
2022-03-06 15:09:12 +01:00
push_error(vformat(R"(The function signature doesn't match the parent. Parent signature is "%s".)", parent_signature), p_function);
}
GDScript: Add warnings that are set to error by default - Adds a list of default levels for all warning so they can be set individually. - Add warnings set by default to error for: - Using `get_node()` without `@onready`. - Using `@onready` together with `@export`. - Inferring a static type with a Variant value. - Overriding a native engine method. - Adjust how annotations to ignore warnings are treated so they also apply to method parameters. - Clean up a bit how ignored warnings are set. There were two sets but only one was actually being used. - Set all warnings to the `WARN` level for tests, so they they can be properly tested. - Fix enum types in native methods signatures being set to `int`. - Fix native enums being treated as Dictionary by mistake. - Make name of native enum types use the class they are defined in, not the direct super class of the script. This ensures they are always equal even when coming from different sources. - Fix error for signature mismatch that was only showing the first default argument as having a default. Now it shows for all.
2023-02-02 15:57:22 +01:00
#ifdef DEBUG_ENABLED
if (native_base != StringName()) {
parser->push_warning(p_function, GDScriptWarning::NATIVE_METHOD_OVERRIDE, function_name, native_base);
}
#endif
GDScript: Check if method signature matches the parent To guarantee polymorphism, a method signature must be compatible with the parent. This checks if: 1. Return type is the same. 2. The subclass method takes at least the same amount of parameters. 3. The matching parameters have the same type. 4. If the subclass takes more parameters, all of the extra ones have a default value. 5. If the superclass has default values, so must have the subclass. There's a few test cases to ensure this holds up.
2022-03-06 15:09:12 +01:00
}
Fix default value count checking for inherited function
2022-03-14 15:55:37 +01:00
#endif // TOOLS_ENABLED
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
if (p_function->get_datatype().is_resolving()) {
p_function->set_datatype(prev_datatype);
}
GDScript: Add warnings that are set to error by default - Adds a list of default levels for all warning so they can be set individually. - Add warnings set by default to error for: - Using `get_node()` without `@onready`. - Using `@onready` together with `@export`. - Inferring a static type with a Variant value. - Overriding a native engine method. - Adjust how annotations to ignore warnings are treated so they also apply to method parameters. - Clean up a bit how ignored warnings are set. There were two sets but only one was actually being used. - Set all warnings to the `WARN` level for tests, so they they can be properly tested. - Fix enum types in native methods signatures being set to `int`. - Fix native enums being treated as Dictionary by mistake. - Make name of native enum types use the class they are defined in, not the direct super class of the script. This ensures they are always equal even when coming from different sources. - Fix error for signature mismatch that was only showing the first default argument as having a default. Now it shows for all.
2023-02-02 15:57:22 +01:00
#ifdef DEBUG_ENABLED
parser->ignored_warnings = previously_ignored_warnings;
#endif
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
parser->current_function = previous_function;
Add support for static variables in GDScript Which allows editable data associated with a particular class instead of the instance. Scripts with static variables are kept in memory indefinitely unless the `@static_unload` annotation is used or the `static_unload()` method is called on the GDScript. If the custom function `_static_init()` exists it will be called when the class is loaded, after the static variables are set.
2023-04-19 16:10:35 +02:00
static_context = previous_static_context;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
GDScript: Fix typing of lambda functions
2022-12-28 06:41:03 +01:00
void GDScriptAnalyzer::resolve_function_body(GDScriptParser::FunctionNode *p_function, bool p_is_lambda) {
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
if (p_function->resolved_body) {
return;
}
p_function->resolved_body = true;
GDScript: Add warnings that are set to error by default - Adds a list of default levels for all warning so they can be set individually. - Add warnings set by default to error for: - Using `get_node()` without `@onready`. - Using `@onready` together with `@export`. - Inferring a static type with a Variant value. - Overriding a native engine method. - Adjust how annotations to ignore warnings are treated so they also apply to method parameters. - Clean up a bit how ignored warnings are set. There were two sets but only one was actually being used. - Set all warnings to the `WARN` level for tests, so they they can be properly tested. - Fix enum types in native methods signatures being set to `int`. - Fix native enums being treated as Dictionary by mistake. - Make name of native enum types use the class they are defined in, not the direct super class of the script. This ensures they are always equal even when coming from different sources. - Fix error for signature mismatch that was only showing the first default argument as having a default. Now it shows for all.
2023-02-02 15:57:22 +01:00
#ifdef DEBUG_ENABLED
HashSet<GDScriptWarning::Code> previously_ignored_warnings = parser->ignored_warnings;
for (GDScriptWarning::Code ignored_warning : p_function->ignored_warnings) {
parser->ignored_warnings.insert(ignored_warning);
}
#endif
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
GDScriptParser::FunctionNode *previous_function = parser->current_function;
parser->current_function = p_function;
GDScript: Fix calling static func from non-static is allowed
2023-05-17 09:25:03 +02:00
bool previous_static_context = static_context;
static_context = p_function->is_static;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
resolve_suite(p_function->body);
Some code simplifications 1. `number_width` isn't used later 2. `return_type` is used only once 3. AudioServer::get_singleton()->get_channel_count() always returns a channel_count of 1 or larger 4. negative `aa->backward` conditional 5. `current_canvas` == `find_world_2d()->get_canvas()` 6. identical if `render_shadows`
2022-11-22 23:09:30 +01:00
if (!p_function->get_datatype().is_hard_type() && p_function->body->get_datatype().is_set()) {
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
// Use the suite inferred type if return isn't explicitly set.
p_function->set_datatype(p_function->body->get_datatype());
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
} else if (p_function->get_datatype().is_hard_type() && (p_function->get_datatype().kind != GDScriptParser::DataType::BUILTIN || p_function->get_datatype().builtin_type != Variant::NIL)) {
GDScript: Fix typing of lambda functions
2022-12-28 06:41:03 +01:00
if (!p_function->body->has_return && (p_is_lambda || p_function->identifier->name != GDScriptLanguage::get_singleton()->strings._init)) {
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
push_error(R"(Not all code paths return a value.)", p_function);
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
GDScript: Add warnings that are set to error by default - Adds a list of default levels for all warning so they can be set individually. - Add warnings set by default to error for: - Using `get_node()` without `@onready`. - Using `@onready` together with `@export`. - Inferring a static type with a Variant value. - Overriding a native engine method. - Adjust how annotations to ignore warnings are treated so they also apply to method parameters. - Clean up a bit how ignored warnings are set. There were two sets but only one was actually being used. - Set all warnings to the `WARN` level for tests, so they they can be properly tested. - Fix enum types in native methods signatures being set to `int`. - Fix native enums being treated as Dictionary by mistake. - Make name of native enum types use the class they are defined in, not the direct super class of the script. This ensures they are always equal even when coming from different sources. - Fix error for signature mismatch that was only showing the first default argument as having a default. Now it shows for all.
2023-02-02 15:57:22 +01:00
#ifdef DEBUG_ENABLED
parser->ignored_warnings = previously_ignored_warnings;
#endif
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
parser->current_function = previous_function;
GDScript: Fix calling static func from non-static is allowed
2023-05-17 09:25:03 +02:00
static_context = previous_static_context;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
void GDScriptAnalyzer::decide_suite_type(GDScriptParser::Node *p_suite, GDScriptParser::Node *p_statement) {
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
if (p_statement == nullptr) {
return;
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
switch (p_statement->type) {
case GDScriptParser::Node::IF:
case GDScriptParser::Node::FOR:
case GDScriptParser::Node::MATCH:
case GDScriptParser::Node::PATTERN:
case GDScriptParser::Node::RETURN:
case GDScriptParser::Node::WHILE:
// Use return or nested suite type as this suite type.
if (p_suite->get_datatype().is_set() && (p_suite->get_datatype() != p_statement->get_datatype())) {
// Mixed types.
// TODO: This could use the common supertype instead.
p_suite->datatype.kind = GDScriptParser::DataType::VARIANT;
p_suite->datatype.type_source = GDScriptParser::DataType::UNDETECTED;
} else {
p_suite->set_datatype(p_statement->get_datatype());
Change GDScript compiler to use codegen abstraction
2020-08-07 19:51:56 +02:00
p_suite->datatype.type_source = GDScriptParser::DataType::INFERRED;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
break;
default:
break;
}
}
void GDScriptAnalyzer::resolve_suite(GDScriptParser::SuiteNode *p_suite) {
for (int i = 0; i < p_suite->statements.size(); i++) {
GDScriptParser::Node *stmt = p_suite->statements[i];
GDScript: Allow constant expressions in annotations
2023-01-18 18:12:33 +01:00
// Apply annotations.
for (GDScriptParser::AnnotationNode *&E : stmt->annotations) {
resolve_annotation(E);
E->apply(parser, stmt);
GDScript: Add annotation to ignore warnings
2022-01-04 13:32:43 +01:00
}
#ifdef DEBUG_ENABLED
GDScript: Add warnings that are set to error by default - Adds a list of default levels for all warning so they can be set individually. - Add warnings set by default to error for: - Using `get_node()` without `@onready`. - Using `@onready` together with `@export`. - Inferring a static type with a Variant value. - Overriding a native engine method. - Adjust how annotations to ignore warnings are treated so they also apply to method parameters. - Clean up a bit how ignored warnings are set. There were two sets but only one was actually being used. - Set all warnings to the `WARN` level for tests, so they they can be properly tested. - Fix enum types in native methods signatures being set to `int`. - Fix native enums being treated as Dictionary by mistake. - Make name of native enum types use the class they are defined in, not the direct super class of the script. This ensures they are always equal even when coming from different sources. - Fix error for signature mismatch that was only showing the first default argument as having a default. Now it shows for all.
2023-02-02 15:57:22 +01:00
HashSet<GDScriptWarning::Code> previously_ignored_warnings = parser->ignored_warnings;
for (GDScriptWarning::Code ignored_warning : stmt->ignored_warnings) {
parser->ignored_warnings.insert(ignored_warning);
GDScript: Add annotation to ignore warnings
2022-01-04 13:32:43 +01:00
}
#endif // DEBUG_ENABLED
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
resolve_node(stmt);
GDScript: Fix lambda resolution with cyclic references
2023-08-23 11:37:18 +02:00
resolve_pending_lambda_bodies();
GDScript: Add annotation to ignore warnings
2022-01-04 13:32:43 +01:00
#ifdef DEBUG_ENABLED
GDScript: Add warnings that are set to error by default - Adds a list of default levels for all warning so they can be set individually. - Add warnings set by default to error for: - Using `get_node()` without `@onready`. - Using `@onready` together with `@export`. - Inferring a static type with a Variant value. - Overriding a native engine method. - Adjust how annotations to ignore warnings are treated so they also apply to method parameters. - Clean up a bit how ignored warnings are set. There were two sets but only one was actually being used. - Set all warnings to the `WARN` level for tests, so they they can be properly tested. - Fix enum types in native methods signatures being set to `int`. - Fix native enums being treated as Dictionary by mistake. - Make name of native enum types use the class they are defined in, not the direct super class of the script. This ensures they are always equal even when coming from different sources. - Fix error for signature mismatch that was only showing the first default argument as having a default. Now it shows for all.
2023-02-02 15:57:22 +01:00
parser->ignored_warnings = previously_ignored_warnings;
GDScript: Add annotation to ignore warnings
2022-01-04 13:32:43 +01:00
#endif // DEBUG_ENABLED
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
decide_suite_type(p_suite, stmt);
}
}
Unify typing of variables, constants and parameters in GDScript
2022-12-22 21:43:36 +01:00
void GDScriptAnalyzer::resolve_assignable(GDScriptParser::AssignableNode *p_assignable, const char *p_kind) {
GDScriptParser::DataType type;
type.kind = GDScriptParser::DataType::VARIANT;
bool is_constant = p_assignable->type == GDScriptParser::Node::CONSTANT;
GDScript: Fix bug with identifier shadowed below in current scope
2023-07-25 13:21:49 +02:00
#ifdef DEBUG_ENABLED
if (p_assignable->identifier != nullptr && p_assignable->identifier->suite != nullptr && p_assignable->identifier->suite->parent_block != nullptr) {
if (p_assignable->identifier->suite->parent_block->has_local(p_assignable->identifier->name)) {
const GDScriptParser::SuiteNode::Local &local = p_assignable->identifier->suite->parent_block->get_local(p_assignable->identifier->name);
parser->push_warning(p_assignable->identifier, GDScriptWarning::CONFUSABLE_LOCAL_DECLARATION, local.get_name(), p_assignable->identifier->name);
}
}
#endif
Unify typing of variables, constants and parameters in GDScript
2022-12-22 21:43:36 +01:00
GDScriptParser::DataType specified_type;
bool has_specified_type = p_assignable->datatype_specifier != nullptr;
if (has_specified_type) {
GDScript: Fix small inconsistencies with resolve_datatype
2023-01-12 00:03:53 +01:00
specified_type = type_from_metatype(resolve_datatype(p_assignable->datatype_specifier));
Unify typing of variables, constants and parameters in GDScript
2022-12-22 21:43:36 +01:00
type = specified_type;
}
if (p_assignable->initializer != nullptr) {
reduce_expression(p_assignable->initializer);
if (p_assignable->initializer->type == GDScriptParser::Node::ARRAY) {
GDScriptParser::ArrayNode *array = static_cast<GDScriptParser::ArrayNode *>(p_assignable->initializer);
GDScript: Fix issues with typed arrays
2022-11-27 08:56:53 +01:00
if (has_specified_type && specified_type.has_container_element_type()) {
update_array_literal_element_type(array, specified_type.get_container_element_type());
Unify typing of variables, constants and parameters in GDScript
2022-12-22 21:43:36 +01:00
}
}
GDScript: Fix issues with typed arrays
2022-11-27 08:56:53 +01:00
if (is_constant && !p_assignable->initializer->is_constant) {
bool is_initializer_value_reduced = false;
Variant initializer_value = make_expression_reduced_value(p_assignable->initializer, is_initializer_value_reduced);
if (is_initializer_value_reduced) {
p_assignable->initializer->is_constant = true;
p_assignable->initializer->reduced_value = initializer_value;
} else {
Unify typing of variables, constants and parameters in GDScript
2022-12-22 21:43:36 +01:00
push_error(vformat(R"(Assigned value for %s "%s" isn't a constant expression.)", p_kind, p_assignable->identifier->name), p_assignable->initializer);
}
}
GDScript: Fix constant conversions
2023-01-22 09:32:05 +01:00
if (has_specified_type && p_assignable->initializer->is_constant) {
update_const_expression_builtin_type(p_assignable->initializer, specified_type, "assign");
}
Unify typing of variables, constants and parameters in GDScript
2022-12-22 21:43:36 +01:00
GDScriptParser::DataType initializer_type = p_assignable->initializer->get_datatype();
if (p_assignable->infer_datatype) {
GDScript: Disallow type inference with untyped initializer
2023-01-13 19:51:29 +01:00
if (!initializer_type.is_set() || initializer_type.has_no_type() || !initializer_type.is_hard_type()) {
Unify typing of variables, constants and parameters in GDScript
2022-12-22 21:43:36 +01:00
push_error(vformat(R"(Cannot infer the type of "%s" %s because the value doesn't have a set type.)", p_assignable->identifier->name, p_kind), p_assignable->initializer);
} else if (initializer_type.kind == GDScriptParser::DataType::BUILTIN && initializer_type.builtin_type == Variant::NIL && !is_constant) {
push_error(vformat(R"(Cannot infer the type of "%s" %s because the value is "null".)", p_assignable->identifier->name, p_kind), p_assignable->initializer);
}
GDScript: Add warnings that are set to error by default - Adds a list of default levels for all warning so they can be set individually. - Add warnings set by default to error for: - Using `get_node()` without `@onready`. - Using `@onready` together with `@export`. - Inferring a static type with a Variant value. - Overriding a native engine method. - Adjust how annotations to ignore warnings are treated so they also apply to method parameters. - Clean up a bit how ignored warnings are set. There were two sets but only one was actually being used. - Set all warnings to the `WARN` level for tests, so they they can be properly tested. - Fix enum types in native methods signatures being set to `int`. - Fix native enums being treated as Dictionary by mistake. - Make name of native enum types use the class they are defined in, not the direct super class of the script. This ensures they are always equal even when coming from different sources. - Fix error for signature mismatch that was only showing the first default argument as having a default. Now it shows for all.
2023-02-02 15:57:22 +01:00
#ifdef DEBUG_ENABLED
if (initializer_type.is_hard_type() && initializer_type.is_variant()) {
parser->push_warning(p_assignable, GDScriptWarning::INFERENCE_ON_VARIANT, p_kind);
}
#endif
Unify typing of variables, constants and parameters in GDScript
2022-12-22 21:43:36 +01:00
} else {
if (!initializer_type.is_set()) {
push_error(vformat(R"(Could not resolve type for %s "%s".)", p_kind, p_assignable->identifier->name), p_assignable->initializer);
}
}
if (!has_specified_type) {
type = initializer_type;
if (!type.is_set() || (type.is_hard_type() && type.kind == GDScriptParser::DataType::BUILTIN && type.builtin_type == Variant::NIL && !is_constant)) {
type.kind = GDScriptParser::DataType::VARIANT;
}
if (p_assignable->infer_datatype || is_constant) {
type.type_source = GDScriptParser::DataType::ANNOTATED_INFERRED;
} else {
type.type_source = GDScriptParser::DataType::INFERRED;
}
} else if (!specified_type.is_variant()) {
if (initializer_type.is_variant() || !initializer_type.is_hard_type()) {
mark_node_unsafe(p_assignable->initializer);
GDScript: Fix missing conversion for default argument values
2023-01-06 10:49:06 +01:00
p_assignable->use_conversion_assign = true;
GDScript: Fix some issues with assignments that involve untyped things
2022-12-30 08:58:07 +01:00
if (!initializer_type.is_variant() && !is_type_compatible(specified_type, initializer_type, true, p_assignable->initializer)) {
downgrade_node_type_source(p_assignable->initializer);
}
Unify typing of variables, constants and parameters in GDScript
2022-12-22 21:43:36 +01:00
} else if (!is_type_compatible(specified_type, initializer_type, true, p_assignable->initializer)) {
GDScript: Fix constant conversions
2023-01-22 09:32:05 +01:00
if (!is_constant && is_type_compatible(initializer_type, specified_type)) {
Unify typing of variables, constants and parameters in GDScript
2022-12-22 21:43:36 +01:00
mark_node_unsafe(p_assignable->initializer);
GDScript: Fix missing conversion for default argument values
2023-01-06 10:49:06 +01:00
p_assignable->use_conversion_assign = true;
Unify typing of variables, constants and parameters in GDScript
2022-12-22 21:43:36 +01:00
} else {
push_error(vformat(R"(Cannot assign a value of type %s to %s "%s" with specified type %s.)", initializer_type.to_string(), p_kind, p_assignable->identifier->name, specified_type.to_string()), p_assignable->initializer);
}
GDScript: Fix issues with typed arrays
2022-11-27 08:56:53 +01:00
} else if (specified_type.has_container_element_type() && !initializer_type.has_container_element_type()) {
mark_node_unsafe(p_assignable->initializer);
Unify typing of variables, constants and parameters in GDScript
2022-12-22 21:43:36 +01:00
#ifdef DEBUG_ENABLED
} else if (specified_type.builtin_type == Variant::INT && initializer_type.builtin_type == Variant::FLOAT) {
parser->push_warning(p_assignable->initializer, GDScriptWarning::NARROWING_CONVERSION);
#endif
}
}
}
type.is_constant = is_constant;
GDScript: Fix infer on read-only property
2023-02-13 19:25:41 +01:00
type.is_read_only = false;
Unify typing of variables, constants and parameters in GDScript
2022-12-22 21:43:36 +01:00
p_assignable->set_datatype(type);
}
void GDScriptAnalyzer::resolve_variable(GDScriptParser::VariableNode *p_variable, bool p_is_local) {
static constexpr const char *kind = "variable";
resolve_assignable(p_variable, kind);
#ifdef DEBUG_ENABLED
if (p_is_local) {
if (p_variable->usages == 0 && !String(p_variable->identifier->name).begins_with("_")) {
parser->push_warning(p_variable, GDScriptWarning::UNUSED_VARIABLE, p_variable->identifier->name);
} else if (p_variable->assignments == 0) {
parser->push_warning(p_variable, GDScriptWarning::UNASSIGNED_VARIABLE, p_variable->identifier->name);
}
}
Fix for not being able to ignore shadowing warnings on class scope
2023-04-03 15:57:41 +02:00
is_shadowing(p_variable->identifier, kind, p_is_local);
Unify typing of variables, constants and parameters in GDScript
2022-12-22 21:43:36 +01:00
#endif
}
void GDScriptAnalyzer::resolve_constant(GDScriptParser::ConstantNode *p_constant, bool p_is_local) {
static constexpr const char *kind = "constant";
resolve_assignable(p_constant, kind);
#ifdef DEBUG_ENABLED
if (p_is_local) {
if (p_constant->usages == 0) {
parser->push_warning(p_constant, GDScriptWarning::UNUSED_LOCAL_CONSTANT, p_constant->identifier->name);
}
}
Fix for not being able to ignore shadowing warnings on class scope
2023-04-03 15:57:41 +02:00
is_shadowing(p_constant->identifier, kind, p_is_local);
Unify typing of variables, constants and parameters in GDScript
2022-12-22 21:43:36 +01:00
#endif
}
void GDScriptAnalyzer::resolve_parameter(GDScriptParser::ParameterNode *p_parameter) {
static constexpr const char *kind = "parameter";
resolve_assignable(p_parameter, kind);
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
void GDScriptAnalyzer::resolve_if(GDScriptParser::IfNode *p_if) {
reduce_expression(p_if->condition);
resolve_suite(p_if->true_block);
p_if->set_datatype(p_if->true_block->get_datatype());
if (p_if->false_block != nullptr) {
resolve_suite(p_if->false_block);
decide_suite_type(p_if, p_if->false_block);
}
}
void GDScriptAnalyzer::resolve_for(GDScriptParser::ForNode *p_for) {
bool list_resolved = false;
// Optimize constant range() call to not allocate an array.
Describe usage of float in range documentation
2022-02-18 00:48:33 +01:00
// Use int, Vector2i, Vector3i instead, which also can be used as range iterators.
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
if (p_for->list && p_for->list->type == GDScriptParser::Node::CALL) {
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
GDScriptParser::CallNode *call = static_cast<GDScriptParser::CallNode *>(p_for->list);
Fixing null callee crash.
2020-08-05 21:41:46 +02:00
GDScriptParser::Node::Type callee_type = call->get_callee_type();
if (callee_type == GDScriptParser::Node::IDENTIFIER) {
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
GDScriptParser::IdentifierNode *callee = static_cast<GDScriptParser::IdentifierNode *>(call->callee);
if (callee->name == "range") {
list_resolved = true;
if (call->arguments.size() < 1) {
push_error(R"*(Invalid call for "range()" function. Expected at least 1 argument, none given.)*", call->callee);
} else if (call->arguments.size() > 3) {
push_error(vformat(R"*(Invalid call for "range()" function. Expected at most 3 arguments, %d given.)*", call->arguments.size()), call->callee);
} else {
// Now we can optimize it.
GDScript: Fix range regression
2023-02-23 23:01:27 +01:00
bool can_reduce = true;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
Vector<Variant> args;
args.resize(call->arguments.size());
for (int i = 0; i < call->arguments.size(); i++) {
GDScript: Fix usage of enum value as range argument
2023-02-23 02:25:26 +01:00
GDScriptParser::ExpressionNode *argument = call->arguments[i];
reduce_expression(argument);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
GDScript: Fix range regression
2023-02-23 23:01:27 +01:00
if (argument->is_constant) {
if (argument->reduced_value.get_type() != Variant::INT && argument->reduced_value.get_type() != Variant::FLOAT) {
can_reduce = false;
push_error(vformat(R"*(Invalid argument for "range()" call. Argument %d should be int or float but "%s" was given.)*", i + 1, Variant::get_type_name(argument->reduced_value.get_type())), argument);
}
if (can_reduce) {
args.write[i] = argument->reduced_value;
}
} else {
can_reduce = false;
GDScriptParser::DataType argument_type = argument->get_datatype();
if (argument_type.is_variant() || !argument_type.is_hard_type()) {
mark_node_unsafe(argument);
}
if (!argument_type.is_variant() && (argument_type.builtin_type != Variant::INT && argument_type.builtin_type != Variant::FLOAT)) {
if (!argument_type.is_hard_type()) {
downgrade_node_type_source(argument);
} else {
push_error(vformat(R"*(Invalid argument for "range()" call. Argument %d should be int or float but "%s" was given.)*", i + 1, argument_type.to_string()), argument);
}
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
}
Variant reduced;
GDScript: Fix range regression
2023-02-23 23:01:27 +01:00
if (can_reduce) {
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
switch (args.size()) {
case 1:
GDScript Fix type mismatch in optimized single arg `range`
2022-11-01 17:07:40 +01:00
reduced = (int32_t)args[0];
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
break;
case 2:
reduced = Vector2i(args[0], args[1]);
break;
case 3:
reduced = Vector3i(args[0], args[1], args[2]);
break;
}
p_for->list->is_constant = true;
p_for->list->reduced_value = reduced;
}
}
GDScript: Fix range() being treated as array when optimized out The call of range() in a for loop is optimized to use int or vectors, to avoid allocating an array, however the type was set as array still. With the new typed VM this is an issue as the type mismatch the actual value, resulting in wrong instructions to be selected.
2020-11-25 15:35:07 +01:00
if (p_for->list->is_constant) {
p_for->list->set_datatype(type_from_variant(p_for->list->reduced_value, p_for->list));
} else {
GDScriptParser::DataType list_type;
list_type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
list_type.kind = GDScriptParser::DataType::BUILTIN;
list_type.builtin_type = Variant::ARRAY;
p_for->list->set_datatype(list_type);
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
}
}
Implement iterator variable typing in GDScript
2021-08-14 05:44:22 +02:00
GDScriptParser::DataType variable_type;
GDScript: Add static typing for `for` loop variable
2023-08-04 11:19:11 +02:00
String list_visible_type = "<unresolved type>";
Implement iterator variable typing in GDScript
2021-08-14 05:44:22 +02:00
if (list_resolved) {
variable_type.type_source = GDScriptParser::DataType::ANNOTATED_INFERRED;
variable_type.kind = GDScriptParser::DataType::BUILTIN;
GDScript: Fix typing of iterator in for loop
2023-01-12 19:18:23 +01:00
variable_type.builtin_type = Variant::INT;
GDScript: Add static typing for `for` loop variable
2023-08-04 11:19:11 +02:00
list_visible_type = "Array[int]"; // NOTE: `range()` has `Array` return type.
GDScript Check for null list in `for` loop
2021-10-02 19:53:56 +02:00
} else if (p_for->list) {
Implement RETURN_VALUE_DISCARDED warning in GDscript
2022-10-13 19:31:12 +02:00
resolve_node(p_for->list, false);
GDScript: Fix typing of iterator in for loop
2023-01-12 19:18:23 +01:00
GDScriptParser::DataType list_type = p_for->list->get_datatype();
GDScript: Add static typing for `for` loop variable
2023-08-04 11:19:11 +02:00
list_visible_type = list_type.to_string();
GDScript: Fix typing of iterator in for loop
2023-01-12 19:18:23 +01:00
if (!list_type.is_hard_type()) {
mark_node_unsafe(p_for->list);
}
if (list_type.is_variant()) {
variable_type.kind = GDScriptParser::DataType::VARIANT;
mark_node_unsafe(p_for->list);
} else if (list_type.has_container_element_type()) {
variable_type = list_type.get_container_element_type();
variable_type.type_source = list_type.type_source;
} else if (list_type.is_typed_container_type()) {
variable_type = list_type.get_typed_container_type();
variable_type.type_source = list_type.type_source;
} else if (list_type.builtin_type == Variant::INT || list_type.builtin_type == Variant::FLOAT || list_type.builtin_type == Variant::STRING) {
variable_type.type_source = list_type.type_source;
variable_type.kind = GDScriptParser::DataType::BUILTIN;
variable_type.builtin_type = list_type.builtin_type;
} else if (list_type.builtin_type == Variant::VECTOR2I || list_type.builtin_type == Variant::VECTOR3I) {
variable_type.type_source = list_type.type_source;
variable_type.kind = GDScriptParser::DataType::BUILTIN;
variable_type.builtin_type = Variant::INT;
} else if (list_type.builtin_type == Variant::VECTOR2 || list_type.builtin_type == Variant::VECTOR3) {
variable_type.type_source = list_type.type_source;
variable_type.kind = GDScriptParser::DataType::BUILTIN;
variable_type.builtin_type = Variant::FLOAT;
} else if (list_type.builtin_type == Variant::OBJECT) {
GDScriptParser::DataType return_type;
List<GDScriptParser::DataType> par_types;
int default_arg_count = 0;
GDScript: add errors when calling unimplemented virtual functions This PR does a small refactor of how method flags are handled in the GDScript analyzer. This way, it adds support for the analyzer to use any of MethodInfo's flags, where previously it could only use METHOD_FLAG_STATIC and METHOD_FLAG_VARARG. As a side-effect, this also normalizes behavior between editor and release templates, which fixes #76938. The tests added also brought a different issue to light, where using `super()` appears to generate a return variable discarded on calling super's _init(), which doesn't have a return value. This should be tackled in a different PR, which will have to change the output of this PR's tests.
2023-05-22 01:22:00 +02:00
BitField<MethodFlags> method_flags;
if (get_function_signature(p_for->list, false, list_type, CoreStringNames::get_singleton()->_iter_get, return_type, par_types, default_arg_count, method_flags)) {
GDScript: Fix typing of iterator in for loop
2023-01-12 19:18:23 +01:00
variable_type = return_type;
variable_type.type_source = list_type.type_source;
} else if (!list_type.is_hard_type()) {
variable_type.kind = GDScriptParser::DataType::VARIANT;
} else {
push_error(vformat(R"(Unable to iterate on object of type "%s".)", list_type.to_string()), p_for->list);
}
} else if (list_type.builtin_type == Variant::ARRAY || list_type.builtin_type == Variant::DICTIONARY || !list_type.is_hard_type()) {
Implement iterator variable typing in GDScript
2021-08-14 05:44:22 +02:00
variable_type.kind = GDScriptParser::DataType::VARIANT;
GDScript: Fix typing of iterator in for loop
2023-01-12 19:18:23 +01:00
} else {
push_error(vformat(R"(Unable to iterate on value of type "%s".)", list_type.to_string()), p_for->list);
Implement iterator variable typing in GDScript
2021-08-14 05:44:22 +02:00
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
GDScript: Add static typing for `for` loop variable
2023-08-04 11:19:11 +02:00
GDScript Check for null list in `for` loop
2021-10-02 19:53:56 +02:00
if (p_for->variable) {
GDScript: Add static typing for `for` loop variable
2023-08-04 11:19:11 +02:00
if (p_for->datatype_specifier) {
GDScriptParser::DataType specified_type = type_from_metatype(resolve_datatype(p_for->datatype_specifier));
if (!specified_type.is_variant()) {
if (variable_type.is_variant() || !variable_type.is_hard_type()) {
mark_node_unsafe(p_for->variable);
p_for->use_conversion_assign = true;
} else if (!is_type_compatible(specified_type, variable_type, true, p_for->variable)) {
if (is_type_compatible(variable_type, specified_type)) {
mark_node_unsafe(p_for->variable);
p_for->use_conversion_assign = true;
} else {
push_error(vformat(R"(Unable to iterate on value of type "%s" with variable of type "%s".)", list_visible_type, specified_type.to_string()), p_for->datatype_specifier);
}
} else if (!is_type_compatible(specified_type, variable_type)) {
p_for->use_conversion_assign = true;
#ifdef DEBUG_ENABLED
} else {
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
}
#ifdef DEBUG_ENABLED
} else {
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);
}
GDScript Check for null list in `for` loop
2021-10-02 19:53:56 +02:00
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
resolve_suite(p_for->loop);
p_for->set_datatype(p_for->loop->get_datatype());
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
#ifdef DEBUG_ENABLED
if (p_for->variable) {
Fix for not being able to ignore shadowing warnings on class scope
2023-04-03 15:57:41 +02:00
is_shadowing(p_for->variable, R"("for" iterator variable)", true);
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
}
#endif
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
void GDScriptAnalyzer::resolve_while(GDScriptParser::WhileNode *p_while) {
Implement RETURN_VALUE_DISCARDED warning in GDscript
2022-10-13 19:31:12 +02:00
resolve_node(p_while->condition, false);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
resolve_suite(p_while->loop);
p_while->set_datatype(p_while->loop->get_datatype());
}
void GDScriptAnalyzer::resolve_assert(GDScriptParser::AssertNode *p_assert) {
reduce_expression(p_assert->condition);
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
if (p_assert->message != nullptr) {
GDScript assert message parsing bug fixed Fix: #43540
2020-12-27 06:57:50 +01:00
reduce_expression(p_assert->message);
Allow non-constant string message for assert
2022-07-04 05:53:31 +02:00
if (!p_assert->message->get_datatype().has_no_type() && (p_assert->message->get_datatype().kind != GDScriptParser::DataType::BUILTIN || p_assert->message->get_datatype().builtin_type != Variant::STRING)) {
push_error(R"(Expected string for assert error message.)", p_assert->message);
GDScript assert message parsing bug fixed Fix: #43540
2020-12-27 06:57:50 +01:00
}
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
p_assert->set_datatype(p_assert->condition->get_datatype());
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
#ifdef DEBUG_ENABLED
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
if (p_assert->condition->is_constant) {
if (p_assert->condition->reduced_value.booleanize()) {
parser->push_warning(p_assert->condition, GDScriptWarning::ASSERT_ALWAYS_TRUE);
GDScript: Allow usage of literal false in assert without a warning
2023-03-17 04:36:50 +01:00
} else if (!(p_assert->condition->type == GDScriptParser::Node::LITERAL && static_cast<GDScriptParser::LiteralNode *>(p_assert->condition)->value.get_type() == Variant::BOOL)) {
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
parser->push_warning(p_assert->condition, GDScriptWarning::ASSERT_ALWAYS_FALSE);
}
}
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
#endif
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
void GDScriptAnalyzer::resolve_match(GDScriptParser::MatchNode *p_match) {
reduce_expression(p_match->test);
for (int i = 0; i < p_match->branches.size(); i++) {
resolve_match_branch(p_match->branches[i], p_match->test);
decide_suite_type(p_match, p_match->branches[i]);
}
}
void GDScriptAnalyzer::resolve_match_branch(GDScriptParser::MatchBranchNode *p_match_branch, GDScriptParser::ExpressionNode *p_match_test) {
for (int i = 0; i < p_match_branch->patterns.size(); i++) {
resolve_match_pattern(p_match_branch->patterns[i], p_match_test);
}
resolve_suite(p_match_branch->block);
decide_suite_type(p_match_branch, p_match_branch->block);
}
void GDScriptAnalyzer::resolve_match_pattern(GDScriptParser::PatternNode *p_match_pattern, GDScriptParser::ExpressionNode *p_match_test) {
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
if (p_match_pattern == nullptr) {
return;
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
GDScriptParser::DataType result;
switch (p_match_pattern->pattern_type) {
case GDScriptParser::PatternNode::PT_LITERAL:
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
if (p_match_pattern->literal) {
reduce_literal(p_match_pattern->literal);
result = p_match_pattern->literal->get_datatype();
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
break;
case GDScriptParser::PatternNode::PT_EXPRESSION:
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
if (p_match_pattern->expression) {
GDScript: Allow variables in match patterns To restore an ability available in 3.x and reduce compatibility changes.
2023-01-28 23:49:14 +01:00
GDScriptParser::ExpressionNode *expr = p_match_pattern->expression;
reduce_expression(expr);
result = expr->get_datatype();
if (!expr->is_constant) {
while (expr && expr->type == GDScriptParser::Node::SUBSCRIPT) {
GDScriptParser::SubscriptNode *sub = static_cast<GDScriptParser::SubscriptNode *>(expr);
if (!sub->is_attribute) {
expr = nullptr;
} else {
expr = sub->base;
}
}
if (!expr || expr->type != GDScriptParser::Node::IDENTIFIER) {
push_error(R"(Expression in match pattern must be a constant expression, an identifier, or an attribute access ("A.B").)", expr);
}
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
break;
case GDScriptParser::PatternNode::PT_BIND:
if (p_match_test != nullptr) {
result = p_match_test->get_datatype();
} else {
result.kind = GDScriptParser::DataType::VARIANT;
}
p_match_pattern->bind->set_datatype(result);
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
#ifdef DEBUG_ENABLED
Fix for not being able to ignore shadowing warnings on class scope
2023-04-03 15:57:41 +02:00
is_shadowing(p_match_pattern->bind, "pattern bind", true);
use correct error for unused bind match, suppress with underscore
2022-06-03 19:42:03 +02:00
if (p_match_pattern->bind->usages == 0 && !String(p_match_pattern->bind->name).begins_with("_")) {
parser->push_warning(p_match_pattern->bind, GDScriptWarning::UNUSED_VARIABLE, p_match_pattern->bind->name);
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
}
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
#endif
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
break;
case GDScriptParser::PatternNode::PT_ARRAY:
for (int i = 0; i < p_match_pattern->array.size(); i++) {
resolve_match_pattern(p_match_pattern->array[i], nullptr);
decide_suite_type(p_match_pattern, p_match_pattern->array[i]);
}
result = p_match_pattern->get_datatype();
break;
case GDScriptParser::PatternNode::PT_DICTIONARY:
for (int i = 0; i < p_match_pattern->dictionary.size(); i++) {
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
if (p_match_pattern->dictionary[i].key) {
reduce_expression(p_match_pattern->dictionary[i].key);
if (!p_match_pattern->dictionary[i].key->is_constant) {
Fix crash with non-constant keys in match statement Dictionary pattern
2022-01-25 21:10:07 +01:00
push_error(R"(Expression in dictionary pattern key must be a constant.)", p_match_pattern->dictionary[i].key);
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
if (p_match_pattern->dictionary[i].value_pattern) {
resolve_match_pattern(p_match_pattern->dictionary[i].value_pattern, nullptr);
decide_suite_type(p_match_pattern, p_match_pattern->dictionary[i].value_pattern);
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
result = p_match_pattern->get_datatype();
break;
case GDScriptParser::PatternNode::PT_WILDCARD:
case GDScriptParser::PatternNode::PT_REST:
result.kind = GDScriptParser::DataType::VARIANT;
break;
}
p_match_pattern->set_datatype(result);
}
void GDScriptAnalyzer::resolve_return(GDScriptParser::ReturnNode *p_return) {
GDScriptParser::DataType result;
GDScript: Report property type errors Inline getters & setters are now FunctionNodes. Their names are set in the parser, not in the compiler. GDScript-Analyzer will now run through getter and setter. Also report wrong type or signature errors regarding getset properties. Added GDScript tests for getters and setters. #53102
2021-09-06 07:04:43 +02:00
GDScriptParser::DataType expected_type;
GDScript: Fix implicit conversions for function returns
2023-01-24 22:21:54 +01:00
bool has_expected_type = parser->current_function != nullptr;
if (has_expected_type) {
GDScript: Report property type errors Inline getters & setters are now FunctionNodes. Their names are set in the parser, not in the compiler. GDScript-Analyzer will now run through getter and setter. Also report wrong type or signature errors regarding getset properties. Added GDScript tests for getters and setters. #53102
2021-09-06 07:04:43 +02:00
expected_type = parser->current_function->get_datatype();
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
if (p_return->return_value != nullptr) {
GDScript: Allow void functions to return calls to other void functions
2023-01-27 21:54:07 +01:00
bool is_void_function = has_expected_type && expected_type.is_hard_type() && expected_type.kind == GDScriptParser::DataType::BUILTIN && expected_type.builtin_type == Variant::NIL;
bool is_call = p_return->return_value->type == GDScriptParser::Node::CALL;
if (is_void_function && is_call) {
// Pretend the call is a root expression to allow those that are "void".
reduce_call(static_cast<GDScriptParser::CallNode *>(p_return->return_value), false, true);
} else {
reduce_expression(p_return->return_value);
GDScript: Disallow return with value in void functions
2022-12-28 06:12:16 +01:00
}
GDScript: Allow void functions to return calls to other void functions
2023-01-27 21:54:07 +01:00
if (is_void_function) {
p_return->void_return = true;
const GDScriptParser::DataType &return_type = p_return->return_value->datatype;
if (is_call && !return_type.is_hard_type()) {
String function_name = parser->current_function->identifier ? parser->current_function->identifier->name.operator String() : String("<anonymous function>");
String called_function_name = static_cast<GDScriptParser::CallNode *>(p_return->return_value)->function_name.operator String();
#ifdef DEBUG_ENABLED
parser->push_warning(p_return, GDScriptWarning::UNSAFE_VOID_RETURN, function_name, called_function_name);
#endif
mark_node_unsafe(p_return);
} else if (!is_call) {
push_error("A void function cannot return a value.", p_return);
}
result.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
result.kind = GDScriptParser::DataType::BUILTIN;
result.builtin_type = Variant::NIL;
result.is_constant = true;
} else {
if (p_return->return_value->type == GDScriptParser::Node::ARRAY && has_expected_type && expected_type.has_container_element_type()) {
update_array_literal_element_type(static_cast<GDScriptParser::ArrayNode *>(p_return->return_value), expected_type.get_container_element_type());
}
if (has_expected_type && expected_type.is_hard_type() && p_return->return_value->is_constant) {
update_const_expression_builtin_type(p_return->return_value, expected_type, "return");
}
result = p_return->return_value->get_datatype();
GDScript: Fix constant conversions
2023-01-22 09:32:05 +01:00
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
} else {
// Return type is null by default.
result.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
result.kind = GDScriptParser::DataType::BUILTIN;
result.builtin_type = Variant::NIL;
result.is_constant = true;
}
GDScript: Fix implicit conversions for function returns
2023-01-24 22:21:54 +01:00
if (has_expected_type && !expected_type.is_variant()) {
if (result.is_variant() || !result.is_hard_type()) {
mark_node_unsafe(p_return);
if (!is_type_compatible(expected_type, result, true, p_return)) {
downgrade_node_type_source(p_return);
}
} else if (!is_type_compatible(expected_type, result, true, p_return)) {
mark_node_unsafe(p_return);
if (!is_type_compatible(result, expected_type)) {
push_error(vformat(R"(Cannot return value of type "%s" because the function return type is "%s".)", result.to_string(), expected_type.to_string()), p_return);
}
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
#ifdef DEBUG_ENABLED
GDScript: Fix implicit conversions for function returns
2023-01-24 22:21:54 +01:00
} else if (expected_type.builtin_type == Variant::INT && result.builtin_type == Variant::FLOAT) {
parser->push_warning(p_return, GDScriptWarning::NARROWING_CONVERSION);
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
#endif
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
}
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
p_return->set_datatype(result);
}
GDScript: Remove error when coroutine is called without await In the case the call happens as a statement, since the return value isn't used in this case.
2021-10-15 01:12:01 +02:00
void GDScriptAnalyzer::reduce_expression(GDScriptParser::ExpressionNode *p_expression, bool p_is_root) {
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
// This one makes some magic happen.
Reintroduce code completion
2020-07-06 17:24:24 +02:00
if (p_expression == nullptr) {
return;
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
if (p_expression->reduced) {
// Don't do this more than once.
return;
}
p_expression->reduced = true;
switch (p_expression->type) {
case GDScriptParser::Node::ARRAY:
reduce_array(static_cast<GDScriptParser::ArrayNode *>(p_expression));
break;
case GDScriptParser::Node::ASSIGNMENT:
reduce_assignment(static_cast<GDScriptParser::AssignmentNode *>(p_expression));
break;
case GDScriptParser::Node::AWAIT:
reduce_await(static_cast<GDScriptParser::AwaitNode *>(p_expression));
break;
case GDScriptParser::Node::BINARY_OPERATOR:
reduce_binary_op(static_cast<GDScriptParser::BinaryOpNode *>(p_expression));
break;
case GDScriptParser::Node::CALL:
Implement RETURN_VALUE_DISCARDED warning in GDscript
2022-10-13 19:31:12 +02:00
reduce_call(static_cast<GDScriptParser::CallNode *>(p_expression), false, p_is_root);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
break;
case GDScriptParser::Node::CAST:
reduce_cast(static_cast<GDScriptParser::CastNode *>(p_expression));
break;
case GDScriptParser::Node::DICTIONARY:
reduce_dictionary(static_cast<GDScriptParser::DictionaryNode *>(p_expression));
break;
case GDScriptParser::Node::GET_NODE:
reduce_get_node(static_cast<GDScriptParser::GetNodeNode *>(p_expression));
break;
case GDScriptParser::Node::IDENTIFIER:
reduce_identifier(static_cast<GDScriptParser::IdentifierNode *>(p_expression));
break;
GDScript: Add lambdas to the type analyzer - Lambdas are always callables (no specific signature match). - Captures from the current context are evaluated.
2021-03-26 13:03:16 +01:00
case GDScriptParser::Node::LAMBDA:
reduce_lambda(static_cast<GDScriptParser::LambdaNode *>(p_expression));
break;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
case GDScriptParser::Node::LITERAL:
reduce_literal(static_cast<GDScriptParser::LiteralNode *>(p_expression));
break;
case GDScriptParser::Node::PRELOAD:
reduce_preload(static_cast<GDScriptParser::PreloadNode *>(p_expression));
break;
case GDScriptParser::Node::SELF:
reduce_self(static_cast<GDScriptParser::SelfNode *>(p_expression));
break;
case GDScriptParser::Node::SUBSCRIPT:
reduce_subscript(static_cast<GDScriptParser::SubscriptNode *>(p_expression));
break;
case GDScriptParser::Node::TERNARY_OPERATOR:
Allow standalone ternary expressions
2023-01-09 15:02:37 +01:00
reduce_ternary_op(static_cast<GDScriptParser::TernaryOpNode *>(p_expression), p_is_root);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
break;
GDScript: Rework type check
2023-02-17 00:16:24 +01:00
case GDScriptParser::Node::TYPE_TEST:
reduce_type_test(static_cast<GDScriptParser::TypeTestNode *>(p_expression));
break;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
case GDScriptParser::Node::UNARY_OPERATOR:
reduce_unary_op(static_cast<GDScriptParser::UnaryOpNode *>(p_expression));
break;
// Non-expressions. Here only to make sure new nodes aren't forgotten.
case GDScriptParser::Node::NONE:
case GDScriptParser::Node::ANNOTATION:
case GDScriptParser::Node::ASSERT:
case GDScriptParser::Node::BREAK:
case GDScriptParser::Node::BREAKPOINT:
case GDScriptParser::Node::CLASS:
case GDScriptParser::Node::CONSTANT:
case GDScriptParser::Node::CONTINUE:
case GDScriptParser::Node::ENUM:
case GDScriptParser::Node::FOR:
case GDScriptParser::Node::FUNCTION:
case GDScriptParser::Node::IF:
case GDScriptParser::Node::MATCH:
case GDScriptParser::Node::MATCH_BRANCH:
case GDScriptParser::Node::PARAMETER:
case GDScriptParser::Node::PASS:
case GDScriptParser::Node::PATTERN:
case GDScriptParser::Node::RETURN:
case GDScriptParser::Node::SIGNAL:
case GDScriptParser::Node::SUITE:
case GDScriptParser::Node::TYPE:
case GDScriptParser::Node::VARIABLE:
case GDScriptParser::Node::WHILE:
ERR_FAIL_MSG("Reaching unreachable case");
}
}
void GDScriptAnalyzer::reduce_array(GDScriptParser::ArrayNode *p_array) {
for (int i = 0; i < p_array->elements.size(); i++) {
GDScriptParser::ExpressionNode *element = p_array->elements[i];
reduce_expression(element);
}
// It's array in any case.
GDScriptParser::DataType arr_type;
arr_type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
arr_type.kind = GDScriptParser::DataType::BUILTIN;
arr_type.builtin_type = Variant::ARRAY;
arr_type.is_constant = true;
p_array->set_datatype(arr_type);
}
GDScript: Fix constant conversions
2023-01-22 09:32:05 +01:00
#ifdef DEBUG_ENABLED
static bool enum_has_value(const GDScriptParser::DataType p_type, int64_t p_value) {
for (const KeyValue<StringName, int64_t> &E : p_type.enum_values) {
if (E.value == p_value) {
return true;
}
}
return false;
}
#endif
void GDScriptAnalyzer::update_const_expression_builtin_type(GDScriptParser::ExpressionNode *p_expression, const GDScriptParser::DataType &p_type, const char *p_usage, bool p_is_cast) {
if (p_expression->get_datatype() == p_type) {
return;
}
if (p_type.kind != GDScriptParser::DataType::BUILTIN && p_type.kind != GDScriptParser::DataType::ENUM) {
return;
}
GDScriptParser::DataType expression_type = p_expression->get_datatype();
bool is_enum_cast = p_is_cast && p_type.kind == GDScriptParser::DataType::ENUM && p_type.is_meta_type == false && expression_type.builtin_type == Variant::INT;
if (!is_enum_cast && !is_type_compatible(p_type, expression_type, true, p_expression)) {
push_error(vformat(R"(Cannot %s a value of type "%s" as "%s".)", p_usage, expression_type.to_string(), p_type.to_string()), p_expression);
return;
}
GDScriptParser::DataType value_type = type_from_variant(p_expression->reduced_value, p_expression);
if (expression_type.is_variant() && !is_enum_cast && !is_type_compatible(p_type, value_type, true, p_expression)) {
push_error(vformat(R"(Cannot %s a value of type "%s" as "%s".)", p_usage, value_type.to_string(), p_type.to_string()), p_expression);
return;
}
#ifdef DEBUG_ENABLED
if (p_type.kind == GDScriptParser::DataType::ENUM && value_type.builtin_type == Variant::INT && !enum_has_value(p_type, p_expression->reduced_value)) {
parser->push_warning(p_expression, GDScriptWarning::INT_AS_ENUM_WITHOUT_MATCH, p_usage, p_expression->reduced_value.stringify(), p_type.to_string());
}
#endif
if (value_type.builtin_type == p_type.builtin_type) {
p_expression->set_datatype(p_type);
return;
}
Variant converted_to;
const Variant *converted_from = &p_expression->reduced_value;
Callable::CallError call_error;
Variant::construct(p_type.builtin_type, converted_to, &converted_from, 1, call_error);
if (call_error.error) {
push_error(vformat(R"(Failed to convert a value of type "%s" to "%s".)", value_type.to_string(), p_type.to_string()), p_expression);
return;
}
#ifdef DEBUG_ENABLED
if (p_type.builtin_type == Variant::INT && value_type.builtin_type == Variant::FLOAT) {
parser->push_warning(p_expression, GDScriptWarning::NARROWING_CONVERSION);
}
#endif
p_expression->reduced_value = converted_to;
p_expression->set_datatype(p_type);
}
Add typed arrays to GDScript - Use `Array[type]` for type-hints. e.g.: `var array: Array[int] = [1, 2, 3]` - Array literals are typed if their storage is typed (variable asssignment of as argument in function all). Otherwise they are untyped.
2021-03-09 16:32:35 +01:00
// When an array literal is stored (or passed as function argument) to a typed context, we then assume the array is typed.
// This function determines which type is that (if any).
GDScript: Fix issues with typed arrays
2022-11-27 08:56:53 +01:00
void GDScriptAnalyzer::update_array_literal_element_type(GDScriptParser::ArrayNode *p_array, const GDScriptParser::DataType &p_element_type) {
for (int i = 0; i < p_array->elements.size(); i++) {
GDScriptParser::ExpressionNode *element_node = p_array->elements[i];
if (element_node->is_constant) {
update_const_expression_builtin_type(element_node, p_element_type, "include");
}
const GDScriptParser::DataType &element_type = element_node->get_datatype();
if (element_type.has_no_type() || element_type.is_variant() || !element_type.is_hard_type()) {
mark_node_unsafe(element_node);
continue;
Add typed arrays to GDScript - Use `Array[type]` for type-hints. e.g.: `var array: Array[int] = [1, 2, 3]` - Array literals are typed if their storage is typed (variable asssignment of as argument in function all). Otherwise they are untyped.
2021-03-09 16:32:35 +01:00
}
GDScript: Fix issues with typed arrays
2022-11-27 08:56:53 +01:00
if (!is_type_compatible(p_element_type, element_type, true, p_array)) {
GDScript: Allow elements of a parent class in a typed array literal
2023-03-28 12:47:24 +02:00
if (is_type_compatible(element_type, p_element_type)) {
mark_node_unsafe(element_node);
continue;
}
GDScript: Fix issues with typed arrays
2022-11-27 08:56:53 +01:00
push_error(vformat(R"(Cannot have an element of type "%s" in an array of type "Array[%s]".)", element_type.to_string(), p_element_type.to_string()), element_node);
return;
Add typed arrays to GDScript - Use `Array[type]` for type-hints. e.g.: `var array: Array[int] = [1, 2, 3]` - Array literals are typed if their storage is typed (variable asssignment of as argument in function all). Otherwise they are untyped.
2021-03-09 16:32:35 +01:00
}
}
GDScript: Fix issues with typed arrays
2022-11-27 08:56:53 +01:00
GDScriptParser::DataType array_type = p_array->get_datatype();
array_type.set_container_element_type(p_element_type);
p_array->set_datatype(array_type);
Add typed arrays to GDScript - Use `Array[type]` for type-hints. e.g.: `var array: Array[int] = [1, 2, 3]` - Array literals are typed if their storage is typed (variable asssignment of as argument in function all). Otherwise they are untyped.
2021-03-09 16:32:35 +01:00
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
void GDScriptAnalyzer::reduce_assignment(GDScriptParser::AssignmentNode *p_assignment) {
reduce_expression(p_assignment->assignee);
reduce_expression(p_assignment->assigned_value);
Reintroduce code completion
2020-07-06 17:24:24 +02:00
if (p_assignment->assigned_value == nullptr || p_assignment->assignee == nullptr) {
return;
}
Add typed arrays to GDScript - Use `Array[type]` for type-hints. e.g.: `var array: Array[int] = [1, 2, 3]` - Array literals are typed if their storage is typed (variable asssignment of as argument in function all). Otherwise they are untyped.
2021-03-09 16:32:35 +01:00
GDScriptParser::DataType assignee_type = p_assignment->assignee->get_datatype();
GDScript: Fix some bugs with static variables and functions
2023-05-16 12:03:53 +02:00
if (assignee_type.is_constant) {
GDScript: Begin making constants deep, not shallow or flat
2023-01-08 04:41:06 +01:00
push_error("Cannot assign a new value to a constant.", p_assignment->assignee);
GDScript: Improve usability of setter chains - Consider PackedArrays non-shared since they are copied on C++/script boundaries. - Add error messages in the analyzer when assigning to read-only properties. - Add specific error message at runtime when assignment fails because the property is read-only.
2023-01-30 18:50:08 +01:00
return;
GDScript: Fix some bugs with static variables and functions
2023-05-16 12:03:53 +02:00
} else if (p_assignment->assignee->type == GDScriptParser::Node::SUBSCRIPT && static_cast<GDScriptParser::SubscriptNode *>(p_assignment->assignee)->base->is_constant) {
const GDScriptParser::DataType &base_type = static_cast<GDScriptParser::SubscriptNode *>(p_assignment->assignee)->base->datatype;
if (base_type.kind != GDScriptParser::DataType::SCRIPT && base_type.kind != GDScriptParser::DataType::CLASS) { // Static variables.
push_error("Cannot assign a new value to a constant.", p_assignment->assignee);
return;
}
GDScript: Improve usability of setter chains - Consider PackedArrays non-shared since they are copied on C++/script boundaries. - Add error messages in the analyzer when assigning to read-only properties. - Add specific error message at runtime when assignment fails because the property is read-only.
2023-01-30 18:50:08 +01:00
} else if (assignee_type.is_read_only) {
push_error("Cannot assign a new value to a read-only property.", p_assignment->assignee);
return;
} else if (p_assignment->assignee->type == GDScriptParser::Node::SUBSCRIPT) {
GDScriptParser::SubscriptNode *sub = static_cast<GDScriptParser::SubscriptNode *>(p_assignment->assignee);
while (sub) {
const GDScriptParser::DataType &base_type = sub->base->datatype;
if (base_type.is_hard_type() && base_type.is_read_only) {
if (base_type.kind == GDScriptParser::DataType::BUILTIN && !Variant::is_type_shared(base_type.builtin_type)) {
push_error("Cannot assign a new value to a read-only property.", p_assignment->assignee);
return;
}
} else {
break;
}
if (sub->base->type == GDScriptParser::Node::SUBSCRIPT) {
sub = static_cast<GDScriptParser::SubscriptNode *>(sub->base);
} else {
sub = nullptr;
}
}
GDScript: Begin making constants deep, not shallow or flat
2023-01-08 04:41:06 +01:00
}
Add typed arrays to GDScript - Use `Array[type]` for type-hints. e.g.: `var array: Array[int] = [1, 2, 3]` - Array literals are typed if their storage is typed (variable asssignment of as argument in function all). Otherwise they are untyped.
2021-03-09 16:32:35 +01:00
// Check if assigned value is an array literal, so we can make it a typed array too if appropriate.
GDScript: Fix issues with typed arrays
2022-11-27 08:56:53 +01:00
if (p_assignment->assigned_value->type == GDScriptParser::Node::ARRAY && assignee_type.has_container_element_type()) {
update_array_literal_element_type(static_cast<GDScriptParser::ArrayNode *>(p_assignment->assigned_value), assignee_type.get_container_element_type());
Add typed arrays to GDScript - Use `Array[type]` for type-hints. e.g.: `var array: Array[int] = [1, 2, 3]` - Array literals are typed if their storage is typed (variable asssignment of as argument in function all). Otherwise they are untyped.
2021-03-09 16:32:35 +01:00
}
GDScript: Fix constant conversions
2023-01-22 09:32:05 +01:00
if (p_assignment->operation == GDScriptParser::AssignmentNode::OP_NONE && assignee_type.is_hard_type() && p_assignment->assigned_value->is_constant) {
update_const_expression_builtin_type(p_assignment->assigned_value, assignee_type, "assign");
}
Add typed arrays to GDScript - Use `Array[type]` for type-hints. e.g.: `var array: Array[int] = [1, 2, 3]` - Array literals are typed if their storage is typed (variable asssignment of as argument in function all). Otherwise they are untyped.
2021-03-09 16:32:35 +01:00
GDScriptParser::DataType assigned_value_type = p_assignment->assigned_value->get_datatype();
GDScript: Fix some issues with assignments that involve untyped things
2022-12-30 08:58:07 +01:00
bool assignee_is_variant = assignee_type.is_variant();
bool assignee_is_hard = assignee_type.is_hard_type();
bool assigned_is_variant = assigned_value_type.is_variant();
bool assigned_is_hard = assigned_value_type.is_hard_type();
Fix type mutation upon compound assignment
2021-12-26 20:32:22 +01:00
bool compatible = true;
GDScript: Fix some issues with assignments that involve untyped things
2022-12-30 08:58:07 +01:00
bool downgrades_assignee = false;
bool downgrades_assigned = false;
Fix type mutation upon compound assignment
2021-12-26 20:32:22 +01:00
GDScriptParser::DataType op_type = assigned_value_type;
GDScript: Fix use of conversion assign for variant values
2023-01-11 00:01:11 +01:00
if (p_assignment->operation != GDScriptParser::AssignmentNode::OP_NONE && !op_type.is_variant()) {
Fix type mutation upon compound assignment
2021-12-26 20:32:22 +01:00
op_type = get_operation_type(p_assignment->variant_op, assignee_type, assigned_value_type, compatible, p_assignment->assigned_value);
GDScript: Fix some issues with assignments that involve untyped things
2022-12-30 08:58:07 +01:00
if (assignee_is_variant) {
// variant assignee
mark_node_unsafe(p_assignment);
} else if (!compatible) {
// incompatible hard types and non-variant assignee
mark_node_unsafe(p_assignment);
if (assigned_is_variant) {
// incompatible hard non-variant assignee and hard variant assigned
p_assignment->use_conversion_assign = true;
} else {
// incompatible hard non-variant types
push_error(vformat(R"(Invalid operands "%s" and "%s" for assignment operator.)", assignee_type.to_string(), assigned_value_type.to_string()), p_assignment);
}
} else if (op_type.type_source == GDScriptParser::DataType::UNDETECTED && !assigned_is_variant) {
// incompatible non-variant types (at least one weak)
downgrades_assignee = !assignee_is_hard;
downgrades_assigned = !assigned_is_hard;
}
Fix type mutation upon compound assignment
2021-12-26 20:32:22 +01:00
}
p_assignment->set_datatype(op_type);
GDScript arithmetic assignment type check bug fixed Fix: #40686
2020-07-25 04:27:58 +02:00
GDScript: Fix some issues with assignments that involve untyped things
2022-12-30 08:58:07 +01:00
if (assignee_is_variant) {
if (!assignee_is_hard) {
// weak variant assignee
mark_node_unsafe(p_assignment);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
Fix type adjustment skipped when value is considered both not hard and not variant
2022-07-04 00:10:16 +02:00
} else {
GDScript: Fix some issues with assignments that involve untyped things
2022-12-30 08:58:07 +01:00
if (assignee_is_hard && !assigned_is_hard) {
// hard non-variant assignee and weak assigned
mark_node_unsafe(p_assignment);
GDScript: Use analyzer data to decide assignment conversion Since there might be tricky cases in the analyzer (in the case of unsafe lines) which would need to be properly checked again. Instead, this splits the code generator in two functions and use information set by the analyzer to tell which function to use, without a need to re-check.
2021-05-26 19:05:31 +02:00
p_assignment->use_conversion_assign = true;
GDScript: Fix some issues with assignments that involve untyped things
2022-12-30 08:58:07 +01:00
downgrades_assigned = downgrades_assigned || (!assigned_is_variant && !is_type_compatible(assignee_type, op_type, true, p_assignment->assigned_value));
} else if (compatible) {
if (op_type.is_variant()) {
// non-variant assignee and variant result
mark_node_unsafe(p_assignment);
if (assignee_is_hard) {
// hard non-variant assignee and variant result
p_assignment->use_conversion_assign = true;
} else {
// weak non-variant assignee and variant result
downgrades_assignee = true;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
GDScript: Fix some issues with assignments that involve untyped things
2022-12-30 08:58:07 +01:00
} else if (!is_type_compatible(assignee_type, op_type, assignee_is_hard, p_assignment->assigned_value)) {
// non-variant assignee and incompatible result
mark_node_unsafe(p_assignment);
if (assignee_is_hard) {
GDScript: Fix constant conversions
2023-01-22 09:32:05 +01:00
if (is_type_compatible(op_type, assignee_type)) {
GDScript: Fix some issues with assignments that involve untyped things
2022-12-30 08:58:07 +01:00
// hard non-variant assignee and maybe compatible result
p_assignment->use_conversion_assign = true;
} else {
// hard non-variant assignee and incompatible result
push_error(vformat(R"(Value of type "%s" cannot be assigned to a variable of type "%s".)", assigned_value_type.to_string(), assignee_type.to_string()), p_assignment->assigned_value);
}
} else {
// weak non-variant assignee and incompatible result
downgrades_assignee = true;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
GDScript: Fix issues with typed arrays
2022-11-27 08:56:53 +01:00
} else if (assignee_type.has_container_element_type() && !op_type.has_container_element_type()) {
// typed array assignee and untyped array result
mark_node_unsafe(p_assignment);
GDScript: Fix some issues with assignments that involve untyped things
2022-12-30 08:58:07 +01:00
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
}
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
GDScript: Fix some issues with assignments that involve untyped things
2022-12-30 08:58:07 +01:00
if (downgrades_assignee) {
downgrade_node_type_source(p_assignment->assignee);
}
if (downgrades_assigned) {
downgrade_node_type_source(p_assignment->assigned_value);
}
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
#ifdef DEBUG_ENABLED
GDScript: Make using return of void function an error Remove the `VOID_ASSIGNMENT` warning since those cases will be errors now.
2022-12-30 15:57:25 +01:00
if (assignee_type.is_hard_type() && assignee_type.builtin_type == Variant::INT && assigned_value_type.builtin_type == Variant::FLOAT) {
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
parser->push_warning(p_assignment->assigned_value, GDScriptWarning::NARROWING_CONVERSION);
}
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
#endif
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
void GDScriptAnalyzer::reduce_await(GDScriptParser::AwaitNode *p_await) {
GDScript: Fix crash on 'await' completion
2020-07-27 14:50:36 +02:00
if (p_await->to_await == nullptr) {
GDScriptParser::DataType await_type;
await_type.kind = GDScriptParser::DataType::VARIANT;
p_await->set_datatype(await_type);
return;
}
GDScript: Fix typing for await expression Don't grab the type of the awaited value unless it's constant (which makes it synchronous) or call (which always use the proper return type).
2021-10-15 01:30:06 +02:00
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
if (p_await->to_await->type == GDScriptParser::Node::CALL) {
reduce_call(static_cast<GDScriptParser::CallNode *>(p_await->to_await), true);
} else {
reduce_expression(p_await->to_await);
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
GDScript: Fix `await` type inference
2023-02-03 18:51:00 +01:00
GDScriptParser::DataType await_type = p_await->to_await->get_datatype();
// We cannot infer the type of the result of waiting for a signal.
if (await_type.is_hard_type() && await_type.kind == GDScriptParser::DataType::BUILTIN && await_type.builtin_type == Variant::SIGNAL) {
await_type.kind = GDScriptParser::DataType::VARIANT;
await_type.type_source = GDScriptParser::DataType::UNDETECTED;
} else if (p_await->to_await->is_constant) {
GDScript: Fix typing for await expression Don't grab the type of the awaited value unless it's constant (which makes it synchronous) or call (which always use the proper return type).
2021-10-15 01:30:06 +02:00
p_await->is_constant = p_await->to_await->is_constant;
p_await->reduced_value = p_await->to_await->reduced_value;
}
GDScript: Fix `await` type inference
2023-02-03 18:51:00 +01:00
await_type.is_coroutine = false;
p_await->set_datatype(await_type);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
#ifdef DEBUG_ENABLED
GDScript: Fix `await` type inference
2023-02-03 18:51:00 +01:00
GDScriptParser::DataType to_await_type = p_await->to_await->get_datatype();
GDScript: Fix false positive `REDUNDANT_AWAIT` warning
2023-03-15 20:11:02 +01:00
if (!to_await_type.is_coroutine && !to_await_type.is_variant() && to_await_type.builtin_type != Variant::SIGNAL) {
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
parser->push_warning(p_await, GDScriptWarning::REDUNDANT_AWAIT);
}
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
#endif
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
void GDScriptAnalyzer::reduce_binary_op(GDScriptParser::BinaryOpNode *p_binary_op) {
reduce_expression(p_binary_op->left_operand);
GDScript: Rework type check
2023-02-17 00:16:24 +01:00
reduce_expression(p_binary_op->right_operand);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
GDScriptParser::DataType left_type;
if (p_binary_op->left_operand) {
Revert "GdScript: Use reduced constant expression result when doing binary operations. Fixes #50293" This reverts commit 62077086076fb99fb7fe014522c44ae83f87dc4d. It broke a GDScript test (which didn't exist back when the PR was made, so was missed prior to the merge). It choked on: ``` prints("a", test_instance.a, test_instance.a == Named.VALUE_A) ``` With: ``` Invalid operands "VALUE_A (enum value)" and "int" for "==" operator. ```
2021-09-30 18:56:33 +02:00
left_type = p_binary_op->left_operand->get_datatype();
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
}
GDScriptParser::DataType right_type;
if (p_binary_op->right_operand) {
Revert "GdScript: Use reduced constant expression result when doing binary operations. Fixes #50293" This reverts commit 62077086076fb99fb7fe014522c44ae83f87dc4d. It broke a GDScript test (which didn't exist back when the PR was made, so was missed prior to the merge). It choked on: ``` prints("a", test_instance.a, test_instance.a == Named.VALUE_A) ``` With: ``` Invalid operands "VALUE_A (enum value)" and "int" for "==" operator. ```
2021-09-30 18:56:33 +02:00
right_type = p_binary_op->right_operand->get_datatype();
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
}
if (!left_type.is_set() || !right_type.is_set()) {
return;
}
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
#ifdef DEBUG_ENABLED
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
if (p_binary_op->variant_op == Variant::OP_DIVIDE && left_type.builtin_type == Variant::INT && right_type.builtin_type == Variant::INT) {
parser->push_warning(p_binary_op, GDScriptWarning::INTEGER_DIVISION);
}
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
#endif
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
if (p_binary_op->left_operand->is_constant && p_binary_op->right_operand->is_constant) {
p_binary_op->is_constant = true;
if (p_binary_op->variant_op < Variant::OP_MAX) {
GDScript operator evaluation validation bug fix Fix: #40665
2020-07-24 20:02:29 +02:00
bool valid = false;
Variant::evaluate(p_binary_op->variant_op, p_binary_op->left_operand->reduced_value, p_binary_op->right_operand->reduced_value, p_binary_op->reduced_value, valid);
if (!valid) {
if (p_binary_op->reduced_value.get_type() == Variant::STRING) {
push_error(vformat(R"(%s in operator %s.)", p_binary_op->reduced_value, Variant::get_operator_name(p_binary_op->variant_op)), p_binary_op);
} else {
Fix subtracting colors and quats
2020-12-01 15:16:31 +01:00
push_error(vformat(R"(Invalid operands to operator %s, %s and %s.)",
GDScript operator evaluation validation bug fix Fix: #40665
2020-07-24 20:02:29 +02:00
Variant::get_operator_name(p_binary_op->variant_op),
Variant::get_type_name(p_binary_op->left_operand->reduced_value.get_type()),
Variant::get_type_name(p_binary_op->right_operand->reduced_value.get_type())),
p_binary_op);
}
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
} else {
GDScript: Rework type check
2023-02-17 00:16:24 +01:00
ERR_PRINT("Parser bug: unknown binary operation.");
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
GDScript: Don't try to parse constant scripts that aren't valid Since it's likely that they won't parse correctly.
2020-08-31 14:53:02 +02:00
p_binary_op->set_datatype(type_from_variant(p_binary_op->reduced_value, p_binary_op));
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
return;
}
GDScriptParser::DataType result;
GDScript: Rework type check
2023-02-17 00:16:24 +01:00
if ((p_binary_op->variant_op == Variant::OP_EQUAL || p_binary_op->variant_op == Variant::OP_NOT_EQUAL) &&
GDScript: Fix wrong marking of some lines related to Variant as unsafe
2022-11-25 10:01:18 +01:00
((left_type.kind == GDScriptParser::DataType::BUILTIN && left_type.builtin_type == Variant::NIL) || (right_type.kind == GDScriptParser::DataType::BUILTIN && right_type.builtin_type == Variant::NIL))) {
// "==" and "!=" operators always return a boolean when comparing to null.
result.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
result.kind = GDScriptParser::DataType::BUILTIN;
result.builtin_type = Variant::BOOL;
} else if (left_type.is_variant() || right_type.is_variant()) {
// Cannot infer type because one operand can be anything.
result.kind = GDScriptParser::DataType::VARIANT;
mark_node_unsafe(p_binary_op);
} else if (p_binary_op->variant_op < Variant::OP_MAX) {
bool valid = false;
result = get_operation_type(p_binary_op->variant_op, left_type, right_type, valid, p_binary_op);
if (!valid) {
push_error(vformat(R"(Invalid operands "%s" and "%s" for "%s" operator.)", left_type.to_string(), right_type.to_string(), Variant::get_operator_name(p_binary_op->variant_op)), p_binary_op);
GDScript: Fix wrong unsafety mark for binary operator
2023-02-26 00:35:53 +01:00
} else if (!result.is_hard_type()) {
GDScript: Fix missing unsafety mark for binary op with weak variables
2023-02-14 15:57:21 +01:00
mark_node_unsafe(p_binary_op);
GDScript: Fix wrong marking of some lines related to Variant as unsafe
2022-11-25 10:01:18 +01:00
}
} else {
ERR_PRINT("Parser bug: unknown binary operation.");
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
p_binary_op->set_datatype(result);
}
Clean up ProjectConverter3To4 architecture, move renames map to separate file This allows properly limiting what features depend on the RegEx module (doing the actual conversion) and what features only require the renames data (GDScript suggestions). Also better excludes the conversion command line options when actually disabling deprecated code. Fixes #73029.
2023-02-10 09:07:01 +01:00
#ifdef SUGGEST_GODOT4_RENAMES
const char *get_rename_from_map(const char *map[][2], String key) {
Add hint for identifiers renamed since Godot 3
2022-03-23 18:54:41 +01:00
for (int index = 0; map[index][0]; index++) {
if (map[index][0] == key) {
return map[index][1];
}
}
return nullptr;
}
// Checks if an identifier/function name has been renamed in Godot 4, uses ProjectConverter3To4 for rename map.
// Returns the new name if found, nullptr otherwise.
Clean up ProjectConverter3To4 architecture, move renames map to separate file This allows properly limiting what features depend on the RegEx module (doing the actual conversion) and what features only require the renames data (GDScript suggestions). Also better excludes the conversion command line options when actually disabling deprecated code. Fixes #73029.
2023-02-10 09:07:01 +01:00
const char *check_for_renamed_identifier(String identifier, GDScriptParser::Node::Type type) {
Add hint for identifiers renamed since Godot 3
2022-03-23 18:54:41 +01:00
switch (type) {
case GDScriptParser::Node::IDENTIFIER: {
// Check properties
Clean up ProjectConverter3To4 architecture, move renames map to separate file This allows properly limiting what features depend on the RegEx module (doing the actual conversion) and what features only require the renames data (GDScript suggestions). Also better excludes the conversion command line options when actually disabling deprecated code. Fixes #73029.
2023-02-10 09:07:01 +01:00
const char *result = get_rename_from_map(RenamesMap3To4::gdscript_properties_renames, identifier);
Add hint for identifiers renamed since Godot 3
2022-03-23 18:54:41 +01:00
if (result) {
return result;
}
// Check enum values
Clean up ProjectConverter3To4 architecture, move renames map to separate file This allows properly limiting what features depend on the RegEx module (doing the actual conversion) and what features only require the renames data (GDScript suggestions). Also better excludes the conversion command line options when actually disabling deprecated code. Fixes #73029.
2023-02-10 09:07:01 +01:00
result = get_rename_from_map(RenamesMap3To4::enum_renames, identifier);
Add hint for identifiers renamed since Godot 3
2022-03-23 18:54:41 +01:00
if (result) {
return result;
}
// Check color constants
Clean up ProjectConverter3To4 architecture, move renames map to separate file This allows properly limiting what features depend on the RegEx module (doing the actual conversion) and what features only require the renames data (GDScript suggestions). Also better excludes the conversion command line options when actually disabling deprecated code. Fixes #73029.
2023-02-10 09:07:01 +01:00
result = get_rename_from_map(RenamesMap3To4::color_renames, identifier);
Add hint for identifiers renamed since Godot 3
2022-03-23 18:54:41 +01:00
if (result) {
return result;
}
// Check type names
Clean up ProjectConverter3To4 architecture, move renames map to separate file This allows properly limiting what features depend on the RegEx module (doing the actual conversion) and what features only require the renames data (GDScript suggestions). Also better excludes the conversion command line options when actually disabling deprecated code. Fixes #73029.
2023-02-10 09:07:01 +01:00
result = get_rename_from_map(RenamesMap3To4::class_renames, identifier);
Add hint for identifiers renamed since Godot 3
2022-03-23 18:54:41 +01:00
if (result) {
return result;
}
Clean up ProjectConverter3To4 architecture, move renames map to separate file This allows properly limiting what features depend on the RegEx module (doing the actual conversion) and what features only require the renames data (GDScript suggestions). Also better excludes the conversion command line options when actually disabling deprecated code. Fixes #73029.
2023-02-10 09:07:01 +01:00
return get_rename_from_map(RenamesMap3To4::builtin_types_renames, identifier);
Add hint for identifiers renamed since Godot 3
2022-03-23 18:54:41 +01:00
}
case GDScriptParser::Node::CALL: {
Clean up ProjectConverter3To4 architecture, move renames map to separate file This allows properly limiting what features depend on the RegEx module (doing the actual conversion) and what features only require the renames data (GDScript suggestions). Also better excludes the conversion command line options when actually disabling deprecated code. Fixes #73029.
2023-02-10 09:07:01 +01:00
const char *result = get_rename_from_map(RenamesMap3To4::gdscript_function_renames, identifier);
Add hint for identifiers renamed since Godot 3
2022-03-23 18:54:41 +01:00
if (result) {
return result;
}
// Built-in Types are mistaken for function calls when the built-in type is not found.
// Check built-in types if function rename not found
Clean up ProjectConverter3To4 architecture, move renames map to separate file This allows properly limiting what features depend on the RegEx module (doing the actual conversion) and what features only require the renames data (GDScript suggestions). Also better excludes the conversion command line options when actually disabling deprecated code. Fixes #73029.
2023-02-10 09:07:01 +01:00
return get_rename_from_map(RenamesMap3To4::builtin_types_renames, identifier);
Add hint for identifiers renamed since Godot 3
2022-03-23 18:54:41 +01:00
}
// Signal references don't get parsed through the GDScriptAnalyzer. No support for signal rename hints.
default:
// No rename found, return null
return nullptr;
}
}
Clean up ProjectConverter3To4 architecture, move renames map to separate file This allows properly limiting what features depend on the RegEx module (doing the actual conversion) and what features only require the renames data (GDScript suggestions). Also better excludes the conversion command line options when actually disabling deprecated code. Fixes #73029.
2023-02-10 09:07:01 +01:00
#endif // SUGGEST_GODOT4_RENAMES
Add hint for identifiers renamed since Godot 3
2022-03-23 18:54:41 +01:00
GDScript: Remove error when coroutine is called without await In the case the call happens as a statement, since the return value isn't used in this case.
2021-10-15 01:12:01 +02:00
void GDScriptAnalyzer::reduce_call(GDScriptParser::CallNode *p_call, bool p_is_await, bool p_is_root) {
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
bool all_is_constant = true;
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
HashMap<int, GDScriptParser::ArrayNode *> arrays; // For array literal to potentially type when passing.
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
for (int i = 0; i < p_call->arguments.size(); i++) {
reduce_expression(p_call->arguments[i]);
Add typed arrays to GDScript - Use `Array[type]` for type-hints. e.g.: `var array: Array[int] = [1, 2, 3]` - Array literals are typed if their storage is typed (variable asssignment of as argument in function all). Otherwise they are untyped.
2021-03-09 16:32:35 +01:00
if (p_call->arguments[i]->type == GDScriptParser::Node::ARRAY) {
arrays[i] = static_cast<GDScriptParser::ArrayNode *>(p_call->arguments[i]);
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
all_is_constant = all_is_constant && p_call->arguments[i]->is_constant;
}
Fixing null callee crash.
2020-08-05 21:41:46 +02:00
GDScriptParser::Node::Type callee_type = p_call->get_callee_type();
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
GDScriptParser::DataType call_type;
Fixing null callee crash.
2020-08-05 21:41:46 +02:00
if (!p_call->is_super && callee_type == GDScriptParser::Node::IDENTIFIER) {
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
// Call to name directly.
StringName function_name = p_call->function_name;
Variant::Type builtin_type = GDScriptParser::get_builtin_type(function_name);
if (builtin_type < Variant::VARIANT_MAX) {
// Is a builtin constructor.
call_type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
call_type.kind = GDScriptParser::DataType::BUILTIN;
call_type.builtin_type = builtin_type;
if (builtin_type == Variant::OBJECT) {
call_type.kind = GDScriptParser::DataType::NATIVE;
call_type.native_type = function_name; // "Object".
}
GDScript: Don't construct ref values in compiler Values that are passed by reference are not suited for being constructed at compile time because in this case they would be shared across all the construction statements.
2020-11-30 13:42:22 +01:00
bool safe_to_fold = true;
switch (builtin_type) {
// Those are stored by reference so not suited for compile-time construction.
// Because in this case they would be the same reference in all constructed values.
case Variant::OBJECT:
Array/Dictionary marked as not safe to const fold Fix: #44459
2020-12-25 08:03:55 +01:00
case Variant::DICTIONARY:
case Variant::ARRAY:
GDScript: Don't construct ref values in compiler Values that are passed by reference are not suited for being constructed at compile time because in this case they would be shared across all the construction statements.
2020-11-30 13:42:22 +01:00
case Variant::PACKED_BYTE_ARRAY:
case Variant::PACKED_INT32_ARRAY:
case Variant::PACKED_INT64_ARRAY:
case Variant::PACKED_FLOAT32_ARRAY:
case Variant::PACKED_FLOAT64_ARRAY:
case Variant::PACKED_STRING_ARRAY:
case Variant::PACKED_VECTOR2_ARRAY:
case Variant::PACKED_VECTOR3_ARRAY:
case Variant::PACKED_COLOR_ARRAY:
safe_to_fold = false;
break;
default:
break;
}
if (all_is_constant && safe_to_fold) {
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
// Construct here.
Vector<const Variant *> args;
for (int i = 0; i < p_call->arguments.size(); i++) {
args.push_back(&(p_call->arguments[i]->reduced_value));
}
Callable::CallError err;
Refactored variant constructor logic
2020-11-09 04:19:09 +01:00
Variant value;
Variant::construct(builtin_type, value, (const Variant **)args.ptr(), args.size(), err);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
switch (err.error) {
case Callable::CallError::CALL_ERROR_INVALID_ARGUMENT:
Assorted enum and native type fixes
2022-12-04 04:02:03 +01:00
push_error(vformat(R"(Invalid argument for %s constructor: argument %d should be "%s" but is "%s".)", Variant::get_type_name(builtin_type), err.argument + 1,
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
Variant::get_type_name(Variant::Type(err.expected)), p_call->arguments[err.argument]->get_datatype().to_string()),
p_call->arguments[err.argument]);
break;
case Callable::CallError::CALL_ERROR_INVALID_METHOD: {
String signature = Variant::get_type_name(builtin_type) + "(";
for (int i = 0; i < p_call->arguments.size(); i++) {
if (i > 0) {
signature += ", ";
}
signature += p_call->arguments[i]->get_datatype().to_string();
}
GDScript: Allow implicit type conversion when constructing variants Incidentally fix error message when no valid constructor is found which was missing an end parenthesis.
2020-08-18 18:12:18 +02:00
signature += ")";
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
push_error(vformat(R"(No constructor of "%s" matches the signature "%s".)", Variant::get_type_name(builtin_type), signature), p_call->callee);
} break;
case Callable::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS:
push_error(vformat(R"(Too many arguments for %s constructor. Received %d but expected %d.)", Variant::get_type_name(builtin_type), p_call->arguments.size(), err.expected), p_call);
break;
case Callable::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS:
push_error(vformat(R"(Too few arguments for %s constructor. Received %d but expected %d.)", Variant::get_type_name(builtin_type), p_call->arguments.size(), err.expected), p_call);
break;
case Callable::CallError::CALL_ERROR_INSTANCE_IS_NULL:
Add a const call mode to Object, Variant and Script. For this to work safely (user not call queue_free or something in the expression), a const call mode was added to Object and Variant (and optionally Script). This mode ensures only const functions can be called, making it safe to use from the editor. Co-Authored-By: reduz <reduzio@gmail.com>
2022-06-27 22:10:04 +02:00
case Callable::CallError::CALL_ERROR_METHOD_NOT_CONST:
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
break; // Can't happen in a builtin constructor.
case Callable::CallError::CALL_OK:
p_call->is_constant = true;
p_call->reduced_value = value;
break;
}
} else {
// TODO: Check constructors without constants.
// If there's one argument, try to use copy constructor (those aren't explicitly defined).
if (p_call->arguments.size() == 1) {
GDScriptParser::DataType arg_type = p_call->arguments[0]->get_datatype();
if (arg_type.is_variant()) {
mark_node_unsafe(p_call->arguments[0]);
} else {
if (arg_type.kind == GDScriptParser::DataType::BUILTIN && arg_type.builtin_type == builtin_type) {
// Okay.
p_call->set_datatype(call_type);
return;
}
}
}
List<MethodInfo> constructors;
Variant::get_constructor_list(builtin_type, &constructors);
bool match = false;
Use C++ iterators for Lists in many situations
2021-07-16 05:45:57 +02:00
for (const MethodInfo &info : constructors) {
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
if (p_call->arguments.size() < info.arguments.size() - info.default_arguments.size()) {
continue;
}
if (p_call->arguments.size() > info.arguments.size()) {
continue;
}
bool types_match = true;
for (int i = 0; i < p_call->arguments.size(); i++) {
GDScript: Fix getting type from PropertyInfo for Variant arguments
2022-12-27 23:11:51 +01:00
GDScriptParser::DataType par_type = type_from_property(info.arguments[i], true);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
GDScript: Allow implicit type conversion when constructing variants Incidentally fix error message when no valid constructor is found which was missing an end parenthesis.
2020-08-18 18:12:18 +02:00
if (!is_type_compatible(par_type, p_call->arguments[i]->get_datatype(), true)) {
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
types_match = false;
break;
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
#ifdef DEBUG_ENABLED
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
} else {
Prevent NARROWING_CONVERSION warning for int(float) function in GDScript
2022-03-12 13:40:07 +01:00
if (par_type.builtin_type == Variant::INT && p_call->arguments[i]->get_datatype().builtin_type == Variant::FLOAT && builtin_type != Variant::INT) {
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
parser->push_warning(p_call, GDScriptWarning::NARROWING_CONVERSION, p_call->function_name);
}
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
#endif
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
}
if (types_match) {
GDScript: Fix constant conversions
2023-01-22 09:32:05 +01:00
for (int i = 0; i < p_call->arguments.size(); i++) {
if (p_call->arguments[i]->is_constant) {
update_const_expression_builtin_type(p_call->arguments[i], type_from_property(info.arguments[i], true), "pass");
}
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
match = true;
call_type = type_from_property(info.return_val);
break;
}
}
if (!match) {
String signature = Variant::get_type_name(builtin_type) + "(";
for (int i = 0; i < p_call->arguments.size(); i++) {
if (i > 0) {
signature += ", ";
}
signature += p_call->arguments[i]->get_datatype().to_string();
}
GDScript: Allow implicit type conversion when constructing variants Incidentally fix error message when no valid constructor is found which was missing an end parenthesis.
2020-08-18 18:12:18 +02:00
signature += ")";
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
push_error(vformat(R"(No constructor of "%s" matches the signature "%s".)", Variant::get_type_name(builtin_type), signature), p_call);
}
}
p_call->set_datatype(call_type);
return;
GDScript: Refactor builtin functions They are now called "utility functions" to avoid confusion with methods of builtin types, and be consistent with the naming in Variant. Core utility functions are now available in GDScript. The ones missing in core are added specifically to GDScript as helpers for convenience. Some functions were remove when there are better ways to do, reducing redundancy and cleaning up the global scope.
2020-11-26 15:56:32 +01:00
} else if (GDScriptUtilityFunctions::function_exists(function_name)) {
MethodInfo function_info = GDScriptUtilityFunctions::get_function_info(function_name);
GDScript: Allow using await on calls to void functions
2023-01-09 13:55:05 +01:00
if (!p_is_root && !p_is_await && function_info.return_val.type == Variant::NIL && ((function_info.return_val.usage & PROPERTY_USAGE_NIL_IS_VARIANT) == 0)) {
GDScript: Make using return of void function an error Remove the `VOID_ASSIGNMENT` warning since those cases will be errors now.
2022-12-30 15:57:25 +01:00
push_error(vformat(R"*(Cannot get return value of call to "%s()" because it returns "void".)*", function_name), p_call);
}
GDScript: Refactor builtin functions They are now called "utility functions" to avoid confusion with methods of builtin types, and be consistent with the naming in Variant. Core utility functions are now available in GDScript. The ones missing in core are added specifically to GDScript as helpers for convenience. Some functions were remove when there are better ways to do, reducing redundancy and cleaning up the global scope.
2020-11-26 15:56:32 +01:00
if (all_is_constant && GDScriptUtilityFunctions::is_function_constant(function_name)) {
// Can call on compilation.
Vector<const Variant *> args;
for (int i = 0; i < p_call->arguments.size(); i++) {
args.push_back(&(p_call->arguments[i]->reduced_value));
}
Variant value;
Callable::CallError err;
GDScriptUtilityFunctions::get_function(function_name)(&value, (const Variant **)args.ptr(), args.size(), err);
switch (err.error) {
case Callable::CallError::CALL_ERROR_INVALID_ARGUMENT: {
PropertyInfo wrong_arg = function_info.arguments[err.argument];
Assorted enum and native type fixes
2022-12-04 04:02:03 +01:00
push_error(vformat(R"*(Invalid argument for "%s()" function: argument %d should be "%s" but is "%s".)*", function_name, err.argument + 1,
GDScript: Fix getting type from PropertyInfo for Variant arguments
2022-12-27 23:11:51 +01:00
type_from_property(wrong_arg, true).to_string(), p_call->arguments[err.argument]->get_datatype().to_string()),
GDScript: Refactor builtin functions They are now called "utility functions" to avoid confusion with methods of builtin types, and be consistent with the naming in Variant. Core utility functions are now available in GDScript. The ones missing in core are added specifically to GDScript as helpers for convenience. Some functions were remove when there are better ways to do, reducing redundancy and cleaning up the global scope.
2020-11-26 15:56:32 +01:00
p_call->arguments[err.argument]);
} break;
case Callable::CallError::CALL_ERROR_INVALID_METHOD:
push_error(vformat(R"(Invalid call for function "%s".)", function_name), p_call);
break;
case Callable::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS:
push_error(vformat(R"*(Too many arguments for "%s()" call. Expected at most %d but received %d.)*", function_name, err.expected, p_call->arguments.size()), p_call);
break;
case Callable::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS:
push_error(vformat(R"*(Too few arguments for "%s()" call. Expected at least %d but received %d.)*", function_name, err.expected, p_call->arguments.size()), p_call);
break;
Add a const call mode to Object, Variant and Script. For this to work safely (user not call queue_free or something in the expression), a const call mode was added to Object and Variant (and optionally Script). This mode ensures only const functions can be called, making it safe to use from the editor. Co-Authored-By: reduz <reduzio@gmail.com>
2022-06-27 22:10:04 +02:00
case Callable::CallError::CALL_ERROR_METHOD_NOT_CONST:
GDScript: Refactor builtin functions They are now called "utility functions" to avoid confusion with methods of builtin types, and be consistent with the naming in Variant. Core utility functions are now available in GDScript. The ones missing in core are added specifically to GDScript as helpers for convenience. Some functions were remove when there are better ways to do, reducing redundancy and cleaning up the global scope.
2020-11-26 15:56:32 +01:00
case Callable::CallError::CALL_ERROR_INSTANCE_IS_NULL:
break; // Can't happen in a builtin constructor.
case Callable::CallError::CALL_OK:
p_call->is_constant = true;
p_call->reduced_value = value;
break;
}
} else {
validate_call_arg(function_info, p_call);
}
p_call->set_datatype(type_from_property(function_info.return_val));
return;
} else if (Variant::has_utility_function(function_name)) {
MethodInfo function_info = info_from_utility_func(function_name);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
GDScript: Allow using await on calls to void functions
2023-01-09 13:55:05 +01:00
if (!p_is_root && !p_is_await && function_info.return_val.type == Variant::NIL && ((function_info.return_val.usage & PROPERTY_USAGE_NIL_IS_VARIANT) == 0)) {
GDScript: Make using return of void function an error Remove the `VOID_ASSIGNMENT` warning since those cases will be errors now.
2022-12-30 15:57:25 +01:00
push_error(vformat(R"*(Cannot get return value of call to "%s()" because it returns "void".)*", function_name), p_call);
}
GDScript: Refactor builtin functions They are now called "utility functions" to avoid confusion with methods of builtin types, and be consistent with the naming in Variant. Core utility functions are now available in GDScript. The ones missing in core are added specifically to GDScript as helpers for convenience. Some functions were remove when there are better ways to do, reducing redundancy and cleaning up the global scope.
2020-11-26 15:56:32 +01:00
if (all_is_constant && Variant::get_utility_function_type(function_name) == Variant::UTILITY_FUNC_TYPE_MATH) {
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
// Can call on compilation.
Vector<const Variant *> args;
for (int i = 0; i < p_call->arguments.size(); i++) {
args.push_back(&(p_call->arguments[i]->reduced_value));
}
Variant value;
Callable::CallError err;
GDScript: Refactor builtin functions They are now called "utility functions" to avoid confusion with methods of builtin types, and be consistent with the naming in Variant. Core utility functions are now available in GDScript. The ones missing in core are added specifically to GDScript as helpers for convenience. Some functions were remove when there are better ways to do, reducing redundancy and cleaning up the global scope.
2020-11-26 15:56:32 +01:00
Variant::call_utility_function(function_name, &value, (const Variant **)args.ptr(), args.size(), err);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
switch (err.error) {
case Callable::CallError::CALL_ERROR_INVALID_ARGUMENT: {
Fix math utility functions crashing when invalid args passed
2022-10-30 22:24:39 +01:00
String expected_type_name;
if (err.argument < function_info.arguments.size()) {
GDScript: Fix getting type from PropertyInfo for Variant arguments
2022-12-27 23:11:51 +01:00
expected_type_name = type_from_property(function_info.arguments[err.argument], true).to_string();
Fix math utility functions crashing when invalid args passed
2022-10-30 22:24:39 +01:00
} else {
expected_type_name = Variant::get_type_name((Variant::Type)err.expected);
}
Assorted enum and native type fixes
2022-12-04 04:02:03 +01:00
push_error(vformat(R"*(Invalid argument for "%s()" function: argument %d should be "%s" but is "%s".)*", function_name, err.argument + 1,
Fix math utility functions crashing when invalid args passed
2022-10-30 22:24:39 +01:00
expected_type_name, p_call->arguments[err.argument]->get_datatype().to_string()),
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
p_call->arguments[err.argument]);
} break;
case Callable::CallError::CALL_ERROR_INVALID_METHOD:
GDScript: Refactor builtin functions They are now called "utility functions" to avoid confusion with methods of builtin types, and be consistent with the naming in Variant. Core utility functions are now available in GDScript. The ones missing in core are added specifically to GDScript as helpers for convenience. Some functions were remove when there are better ways to do, reducing redundancy and cleaning up the global scope.
2020-11-26 15:56:32 +01:00
push_error(vformat(R"(Invalid call for function "%s".)", function_name), p_call);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
break;
case Callable::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS:
GDScript: Refactor builtin functions They are now called "utility functions" to avoid confusion with methods of builtin types, and be consistent with the naming in Variant. Core utility functions are now available in GDScript. The ones missing in core are added specifically to GDScript as helpers for convenience. Some functions were remove when there are better ways to do, reducing redundancy and cleaning up the global scope.
2020-11-26 15:56:32 +01:00
push_error(vformat(R"*(Too many arguments for "%s()" call. Expected at most %d but received %d.)*", function_name, err.expected, p_call->arguments.size()), p_call);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
break;
case Callable::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS:
GDScript: Refactor builtin functions They are now called "utility functions" to avoid confusion with methods of builtin types, and be consistent with the naming in Variant. Core utility functions are now available in GDScript. The ones missing in core are added specifically to GDScript as helpers for convenience. Some functions were remove when there are better ways to do, reducing redundancy and cleaning up the global scope.
2020-11-26 15:56:32 +01:00
push_error(vformat(R"*(Too few arguments for "%s()" call. Expected at least %d but received %d.)*", function_name, err.expected, p_call->arguments.size()), p_call);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
break;
Add a const call mode to Object, Variant and Script. For this to work safely (user not call queue_free or something in the expression), a const call mode was added to Object and Variant (and optionally Script). This mode ensures only const functions can be called, making it safe to use from the editor. Co-Authored-By: reduz <reduzio@gmail.com>
2022-06-27 22:10:04 +02:00
case Callable::CallError::CALL_ERROR_METHOD_NOT_CONST:
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
case Callable::CallError::CALL_ERROR_INSTANCE_IS_NULL:
break; // Can't happen in a builtin constructor.
case Callable::CallError::CALL_OK:
p_call->is_constant = true;
p_call->reduced_value = value;
break;
}
} else {
validate_call_arg(function_info, p_call);
}
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
p_call->set_datatype(type_from_property(function_info.return_val));
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
return;
}
}
GDScriptParser::DataType base_type;
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
call_type.kind = GDScriptParser::DataType::VARIANT;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
bool is_self = false;
if (p_call->is_super) {
base_type = parser->current_class->base_type;
GDScript: Fix function signature check for self calls
2021-05-26 20:33:18 +02:00
base_type.is_meta_type = false;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
is_self = true;
GDScript: Fix issues with completion and `super` calls - Make call errors use the call node instead of the calle, which will be empty on super calls. - Don't allow `super()` to be used within lambdas.
2022-03-30 16:53:49 +02:00
GDScript: Fix lambda resolution with cyclic references
2023-08-23 11:37:18 +02:00
if (p_call->callee == nullptr && current_lambda != nullptr) {
GDScript: Fix issues with completion and `super` calls - Make call errors use the call node instead of the calle, which will be empty on super calls. - Don't allow `super()` to be used within lambdas.
2022-03-30 16:53:49 +02:00
push_error("Cannot use `super()` inside a lambda.", p_call);
}
Fixing null callee crash.
2020-08-05 21:41:46 +02:00
} else if (callee_type == GDScriptParser::Node::IDENTIFIER) {
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
base_type = parser->current_class->get_datatype();
GDScript: Fix function signature check for self calls
2021-05-26 20:33:18 +02:00
base_type.is_meta_type = false;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
is_self = true;
Fixing null callee crash.
2020-08-05 21:41:46 +02:00
} else if (callee_type == GDScriptParser::Node::SUBSCRIPT) {
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
GDScriptParser::SubscriptNode *subscript = static_cast<GDScriptParser::SubscriptNode *>(p_call->callee);
GDScript: Fix crash when base of an attribute is invalid In attribute expressions (`a.b`) it's possible that the base has an incorrect syntax and thus become a nullptr expression in the tree. This commit add the check for this case to fail gracefully instead of crashing.
2021-04-05 16:17:59 +02:00
if (subscript->base == nullptr) {
// Invalid syntax, error already set on parser.
p_call->set_datatype(call_type);
mark_node_unsafe(p_call);
return;
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
if (!subscript->is_attribute) {
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
// Invalid call. Error already sent in parser.
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
// TODO: Could check if Callable here.
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
p_call->set_datatype(call_type);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
mark_node_unsafe(p_call);
return;
}
GDScript: Add support for builtin static method calls
2021-05-16 16:48:53 +02:00
if (subscript->attribute == nullptr) {
// Invalid call. Error already sent in parser.
p_call->set_datatype(call_type);
mark_node_unsafe(p_call);
return;
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
GDScript: Add support for builtin static method calls
2021-05-16 16:48:53 +02:00
GDScriptParser::IdentifierNode *base_id = nullptr;
if (subscript->base->type == GDScriptParser::Node::IDENTIFIER) {
base_id = static_cast<GDScriptParser::IdentifierNode *>(subscript->base);
}
if (base_id && GDScriptParser::get_builtin_type(base_id->name) < Variant::VARIANT_MAX) {
base_type = make_builtin_meta_type(GDScriptParser::get_builtin_type(base_id->name));
} else {
reduce_expression(subscript->base);
base_type = subscript->base->get_datatype();
GDScript: Fix some issues with assignments that involve untyped things
2022-12-30 08:58:07 +01:00
is_self = subscript->base->type == GDScriptParser::Node::SELF;
GDScript: Add support for builtin static method calls
2021-05-16 16:48:53 +02:00
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
} else {
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
// Invalid call. Error already sent in parser.
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
// TODO: Could check if Callable here too.
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
p_call->set_datatype(call_type);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
mark_node_unsafe(p_call);
return;
}
int default_arg_count = 0;
GDScript: add errors when calling unimplemented virtual functions This PR does a small refactor of how method flags are handled in the GDScript analyzer. This way, it adds support for the analyzer to use any of MethodInfo's flags, where previously it could only use METHOD_FLAG_STATIC and METHOD_FLAG_VARARG. As a side-effect, this also normalizes behavior between editor and release templates, which fixes #76938. The tests added also brought a different issue to light, where using `super()` appears to generate a return variable discarded on calling super's _init(), which doesn't have a return value. This should be tackled in a different PR, which will have to change the output of this PR's tests.
2023-05-22 01:22:00 +02:00
BitField<MethodFlags> method_flags;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
GDScriptParser::DataType return_type;
List<GDScriptParser::DataType> par_types;
GDScript: Check if method signature matches the parent To guarantee polymorphism, a method signature must be compatible with the parent. This checks if: 1. Return type is the same. 2. The subclass method takes at least the same amount of parameters. 3. The matching parameters have the same type. 4. If the subclass takes more parameters, all of the extra ones have a default value. 5. If the superclass has default values, so must have the subclass. There's a few test cases to ensure this holds up.
2022-03-06 15:09:12 +01:00
bool is_constructor = (base_type.is_meta_type || (p_call->callee && p_call->callee->type == GDScriptParser::Node::IDENTIFIER)) && p_call->function_name == SNAME("new");
GDScript: add errors when calling unimplemented virtual functions This PR does a small refactor of how method flags are handled in the GDScript analyzer. This way, it adds support for the analyzer to use any of MethodInfo's flags, where previously it could only use METHOD_FLAG_STATIC and METHOD_FLAG_VARARG. As a side-effect, this also normalizes behavior between editor and release templates, which fixes #76938. The tests added also brought a different issue to light, where using `super()` appears to generate a return variable discarded on calling super's _init(), which doesn't have a return value. This should be tackled in a different PR, which will have to change the output of this PR's tests.
2023-05-22 01:22:00 +02:00
if (get_function_signature(p_call, is_constructor, base_type, p_call->function_name, return_type, par_types, default_arg_count, method_flags)) {
Add typed arrays to GDScript - Use `Array[type]` for type-hints. e.g.: `var array: Array[int] = [1, 2, 3]` - Array literals are typed if their storage is typed (variable asssignment of as argument in function all). Otherwise they are untyped.
2021-03-09 16:32:35 +01:00
// If the function require typed arrays we must make literals be typed.
Use range iterators for `Map`
2021-08-09 22:13:42 +02:00
for (const KeyValue<int, GDScriptParser::ArrayNode *> &E : arrays) {
int index = E.key;
Add typed arrays to GDScript - Use `Array[type]` for type-hints. e.g.: `var array: Array[int] = [1, 2, 3]` - Array literals are typed if their storage is typed (variable asssignment of as argument in function all). Otherwise they are untyped.
2021-03-09 16:32:35 +01:00
if (index < par_types.size() && par_types[index].has_container_element_type()) {
GDScript: Fix issues with typed arrays
2022-11-27 08:56:53 +01:00
update_array_literal_element_type(E.value, par_types[index].get_container_element_type());
Add typed arrays to GDScript - Use `Array[type]` for type-hints. e.g.: `var array: Array[int] = [1, 2, 3]` - Array literals are typed if their storage is typed (variable asssignment of as argument in function all). Otherwise they are untyped.
2021-03-09 16:32:35 +01:00
}
}
GDScript: add errors when calling unimplemented virtual functions This PR does a small refactor of how method flags are handled in the GDScript analyzer. This way, it adds support for the analyzer to use any of MethodInfo's flags, where previously it could only use METHOD_FLAG_STATIC and METHOD_FLAG_VARARG. As a side-effect, this also normalizes behavior between editor and release templates, which fixes #76938. The tests added also brought a different issue to light, where using `super()` appears to generate a return variable discarded on calling super's _init(), which doesn't have a return value. This should be tackled in a different PR, which will have to change the output of this PR's tests.
2023-05-22 01:22:00 +02:00
validate_call_arg(par_types, default_arg_count, method_flags.has_flag(METHOD_FLAG_VARARG), p_call);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
GDScript: Treat enum values as int and enum types as dictionary Since enums resolve to a dictionary at runtime, calling dictionary methods on an enum type is a valid use case. This ensures this is true by adding test cases. This also makes enum values be treated as ints when used in operations.
2022-02-02 17:57:24 +01:00
if (base_type.kind == GDScriptParser::DataType::ENUM && base_type.is_meta_type) {
// Enum type is treated as a dictionary value for function calls.
base_type.is_meta_type = false;
}
GDScript: add errors when calling unimplemented virtual functions This PR does a small refactor of how method flags are handled in the GDScript analyzer. This way, it adds support for the analyzer to use any of MethodInfo's flags, where previously it could only use METHOD_FLAG_STATIC and METHOD_FLAG_VARARG. As a side-effect, this also normalizes behavior between editor and release templates, which fixes #76938. The tests added also brought a different issue to light, where using `super()` appears to generate a return variable discarded on calling super's _init(), which doesn't have a return value. This should be tackled in a different PR, which will have to change the output of this PR's tests.
2023-05-22 01:22:00 +02:00
if (is_self && static_context && !method_flags.has_flag(METHOD_FLAG_STATIC)) {
Add support for static variables in GDScript Which allows editable data associated with a particular class instead of the instance. Scripts with static variables are kept in memory indefinitely unless the `@static_unload` annotation is used or the `static_unload()` method is called on the GDScript. If the custom function `_static_init()` exists it will be called when the class is loaded, after the static variables are set.
2023-04-19 16:10:35 +02:00
if (parser->current_function) {
// Get the parent function above any lambda.
GDScriptParser::FunctionNode *parent_function = parser->current_function;
while (parent_function->source_lambda) {
parent_function = parent_function->source_lambda->parent_function;
}
push_error(vformat(R"*(Cannot call non-static function "%s()" from static function "%s()".)*", p_call->function_name, parent_function->identifier->name), p_call);
} else {
push_error(vformat(R"*(Cannot call non-static function "%s()" for static variable initializer.)*", p_call->function_name), p_call);
GDScript: Allow using self in lambdas
2022-04-20 19:22:22 +02:00
}
GDScript: add errors when calling unimplemented virtual functions This PR does a small refactor of how method flags are handled in the GDScript analyzer. This way, it adds support for the analyzer to use any of MethodInfo's flags, where previously it could only use METHOD_FLAG_STATIC and METHOD_FLAG_VARARG. As a side-effect, this also normalizes behavior between editor and release templates, which fixes #76938. The tests added also brought a different issue to light, where using `super()` appears to generate a return variable discarded on calling super's _init(), which doesn't have a return value. This should be tackled in a different PR, which will have to change the output of this PR's tests.
2023-05-22 01:22:00 +02:00
} else if (!is_self && base_type.is_meta_type && !method_flags.has_flag(METHOD_FLAG_STATIC)) {
GDScript: Fix inner classes and preloaded scripts as types
2021-05-26 14:23:17 +02:00
base_type.is_meta_type = false; // For `to_string()`.
GDScript: Fix issues with completion and `super` calls - Make call errors use the call node instead of the calle, which will be empty on super calls. - Don't allow `super()` to be used within lambdas.
2022-03-30 16:53:49 +02:00
push_error(vformat(R"*(Cannot call non-static function "%s()" on the class "%s" directly. Make an instance instead.)*", p_call->function_name, base_type.to_string()), p_call);
GDScript: add errors when calling unimplemented virtual functions This PR does a small refactor of how method flags are handled in the GDScript analyzer. This way, it adds support for the analyzer to use any of MethodInfo's flags, where previously it could only use METHOD_FLAG_STATIC and METHOD_FLAG_VARARG. As a side-effect, this also normalizes behavior between editor and release templates, which fixes #76938. The tests added also brought a different issue to light, where using `super()` appears to generate a return variable discarded on calling super's _init(), which doesn't have a return value. This should be tackled in a different PR, which will have to change the output of this PR's tests.
2023-05-22 01:22:00 +02:00
} else if (is_self && !method_flags.has_flag(METHOD_FLAG_STATIC)) {
GDScript: Allow using self in lambdas
2022-04-20 19:22:22 +02:00
mark_lambda_use_self();
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
GDScript: Allow using await on calls to void functions
2023-01-09 13:55:05 +01:00
if (!p_is_root && !p_is_await && return_type.is_hard_type() && return_type.kind == GDScriptParser::DataType::BUILTIN && return_type.builtin_type == Variant::NIL) {
GDScript: Make using return of void function an error Remove the `VOID_ASSIGNMENT` warning since those cases will be errors now.
2022-12-30 15:57:25 +01:00
push_error(vformat(R"*(Cannot get return value of call to "%s()" because it returns "void".)*", p_call->function_name), p_call);
}
Implement RETURN_VALUE_DISCARDED warning in GDscript
2022-10-13 19:31:12 +02:00
#ifdef DEBUG_ENABLED
GDScript: do not warn of return value discarded for super() inside _init() DO NOT BATCH MERGE WITH #77324, WILL RESULT IN BROKEN CI Currently, calling super() inside _init() throws a RETURN_VALUE_DISCARDED warning. The analyzer identifies super() as being a constructor, which therefore returns an object of the relevant class. However, super() isn't really a constructor by itself: in this case, it is _part_ of the constructor, and so doesn't "return" a value. A test case for this is already in #77324, which contains the warning. I am duplicating it here, without the warning, and it should conflict with the other PR.
2023-05-22 15:21:25 +02:00
if (p_is_root && return_type.kind != GDScriptParser::DataType::UNRESOLVED && return_type.builtin_type != Variant::NIL &&
!(p_call->is_super && p_call->function_name == GDScriptLanguage::get_singleton()->strings._init)) {
Implement RETURN_VALUE_DISCARDED warning in GDscript
2022-10-13 19:31:12 +02:00
parser->push_warning(p_call, GDScriptWarning::RETURN_VALUE_DISCARDED, p_call->function_name);
}
Add STATIC_CALLED_ON_INSTANCE warning to highlight when static functions are called directly from objects
2022-10-13 21:42:11 +02:00
GDScript: add errors when calling unimplemented virtual functions This PR does a small refactor of how method flags are handled in the GDScript analyzer. This way, it adds support for the analyzer to use any of MethodInfo's flags, where previously it could only use METHOD_FLAG_STATIC and METHOD_FLAG_VARARG. As a side-effect, this also normalizes behavior between editor and release templates, which fixes #76938. The tests added also brought a different issue to light, where using `super()` appears to generate a return variable discarded on calling super's _init(), which doesn't have a return value. This should be tackled in a different PR, which will have to change the output of this PR's tests.
2023-05-22 01:22:00 +02:00
if (method_flags.has_flag(METHOD_FLAG_STATIC) && !is_constructor && !base_type.is_meta_type && !(is_self && static_context)) {
Ensure class name is printed in STATIC_CALLED_ON_INSTANCE warning
2022-11-24 21:06:11 +01:00
String caller_type = String(base_type.native_type);
if (caller_type.is_empty()) {
caller_type = base_type.to_string();
}
parser->push_warning(p_call, GDScriptWarning::STATIC_CALLED_ON_INSTANCE, p_call->function_name, caller_type);
Add STATIC_CALLED_ON_INSTANCE warning to highlight when static functions are called directly from objects
2022-10-13 21:42:11 +02:00
}
Implement RETURN_VALUE_DISCARDED warning in GDscript
2022-10-13 19:31:12 +02:00
#endif // DEBUG_ENABLED
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
call_type = return_type;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
} else {
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
bool found = false;
GDScript: Add support for static method calls in native types
2022-04-06 19:14:38 +02:00
Assorted enum and native type fixes
2022-12-04 04:02:03 +01:00
// Enums do not have functions other than the built-in dictionary ones.
if (base_type.kind == GDScriptParser::DataType::ENUM && base_type.is_meta_type) {
GDScript: Add warnings that are set to error by default - Adds a list of default levels for all warning so they can be set individually. - Add warnings set by default to error for: - Using `get_node()` without `@onready`. - Using `@onready` together with `@export`. - Inferring a static type with a Variant value. - Overriding a native engine method. - Adjust how annotations to ignore warnings are treated so they also apply to method parameters. - Clean up a bit how ignored warnings are set. There were two sets but only one was actually being used. - Set all warnings to the `WARN` level for tests, so they they can be properly tested. - Fix enum types in native methods signatures being set to `int`. - Fix native enums being treated as Dictionary by mistake. - Make name of native enum types use the class they are defined in, not the direct super class of the script. This ensures they are always equal even when coming from different sources. - Fix error for signature mismatch that was only showing the first default argument as having a default. Now it shows for all.
2023-02-02 15:57:22 +01:00
if (base_type.builtin_type == Variant::DICTIONARY) {
push_error(vformat(R"*(Enums only have Dictionary built-in methods. Function "%s()" does not exist for enum "%s".)*", p_call->function_name, base_type.enum_type), p_call->callee);
} else {
push_error(vformat(R"*(The native enum "%s" does not behave like Dictionary and does not have methods of its own.)*", base_type.enum_type), p_call->callee);
}
Assorted enum and native type fixes
2022-12-04 04:02:03 +01:00
} else if (!p_call->is_super && callee_type != GDScriptParser::Node::NONE) { // Check if the name exists as something else.
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
GDScriptParser::IdentifierNode *callee_id;
Fixing null callee crash.
2020-08-05 21:41:46 +02:00
if (callee_type == GDScriptParser::Node::IDENTIFIER) {
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
callee_id = static_cast<GDScriptParser::IdentifierNode *>(p_call->callee);
} else {
// Can only be attribute.
callee_id = static_cast<GDScriptParser::SubscriptNode *>(p_call->callee)->attribute;
}
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
if (callee_id) {
reduce_identifier_from_base(callee_id, &base_type);
Fixing null callee crash.
2020-08-05 21:41:46 +02:00
GDScriptParser::DataType callee_datatype = callee_id->get_datatype();
if (callee_datatype.is_set() && !callee_datatype.is_variant()) {
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
found = true;
Fixing null callee crash.
2020-08-05 21:41:46 +02:00
if (callee_datatype.builtin_type == Variant::CALLABLE) {
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
push_error(vformat(R"*(Name "%s" is a Callable. You can call it with "%s.call()" instead.)*", p_call->function_name, p_call->function_name), p_call->callee);
} else {
Fixing null callee crash.
2020-08-05 21:41:46 +02:00
push_error(vformat(R"*(Name "%s" called as a function but is a "%s".)*", p_call->function_name, callee_datatype.to_string()), p_call->callee);
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
}
#ifdef DEBUG_ENABLED
GDScript builtin invalid function call crash fix Fix: #44852
2021-01-03 14:14:01 +01:00
} else if (!is_self && !(base_type.is_hard_type() && base_type.kind == GDScriptParser::DataType::BUILTIN)) {
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
parser->push_warning(p_call, GDScriptWarning::UNSAFE_METHOD_ACCESS, p_call->function_name, base_type.to_string());
mark_node_unsafe(p_call);
#endif
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
}
}
}
GDScript builtin invalid function call crash fix Fix: #44852
2021-01-03 14:14:01 +01:00
if (!found && (is_self || (base_type.is_hard_type() && base_type.kind == GDScriptParser::DataType::BUILTIN))) {
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
String base_name = is_self && !p_call->is_super ? "self" : base_type.to_string();
Clean up ProjectConverter3To4 architecture, move renames map to separate file This allows properly limiting what features depend on the RegEx module (doing the actual conversion) and what features only require the renames data (GDScript suggestions). Also better excludes the conversion command line options when actually disabling deprecated code. Fixes #73029.
2023-02-10 09:07:01 +01:00
#ifdef SUGGEST_GODOT4_RENAMES
Add hint for identifiers renamed since Godot 3
2022-03-23 18:54:41 +01:00
String rename_hint = String();
GDScript: Reorganize and unify warnings
2023-04-28 17:20:41 +02:00
if (GLOBAL_GET(GDScriptWarning::get_settings_path_from_code(GDScriptWarning::Code::RENAMED_IN_GODOT_4_HINT)).booleanize()) {
Add hint for identifiers renamed since Godot 3
2022-03-23 18:54:41 +01:00
const char *renamed_function_name = check_for_renamed_identifier(p_call->function_name, p_call->type);
if (renamed_function_name) {
rename_hint = " " + vformat(R"(Did you mean to use "%s"?)", String(renamed_function_name) + "()");
}
}
push_error(vformat(R"*(Function "%s()" not found in base %s.%s)*", p_call->function_name, base_name, rename_hint), p_call->is_super ? p_call : p_call->callee);
#else
push_error(vformat(R"*(Function "%s()" not found in base %s.)*", p_call->function_name, base_name), p_call->is_super ? p_call : p_call->callee);
Clean up ProjectConverter3To4 architecture, move renames map to separate file This allows properly limiting what features depend on the RegEx module (doing the actual conversion) and what features only require the renames data (GDScript suggestions). Also better excludes the conversion command line options when actually disabling deprecated code. Fixes #73029.
2023-02-10 09:07:01 +01:00
#endif // SUGGEST_GODOT4_RENAMES
GDScript: Add support for static method calls in native types
2022-04-06 19:14:38 +02:00
} else if (!found && (!p_call->is_super && base_type.is_hard_type() && base_type.kind == GDScriptParser::DataType::NATIVE && base_type.is_meta_type)) {
Assorted enum and native type fixes
2022-12-04 04:02:03 +01:00
push_error(vformat(R"*(Static function "%s()" not found in base "%s".)*", p_call->function_name, base_type.native_type), p_call);
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
}
}
GDScript: Remove error when coroutine is called without await In the case the call happens as a statement, since the return value isn't used in this case.
2021-10-15 01:12:01 +02:00
if (call_type.is_coroutine && !p_is_await && !p_is_root) {
GDScript: Fix issues with completion and `super` calls - Make call errors use the call node instead of the calle, which will be empty on super calls. - Don't allow `super()` to be used within lambdas.
2022-03-30 16:53:49 +02:00
push_error(vformat(R"*(Function "%s()" is a coroutine, so it must be called with "await".)*", p_call->function_name), p_call);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
p_call->set_datatype(call_type);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
void GDScriptAnalyzer::reduce_cast(GDScriptParser::CastNode *p_cast) {
reduce_expression(p_cast->operand);
GDScript: Fix small inconsistencies with resolve_datatype
2023-01-12 00:03:53 +01:00
GDScriptParser::DataType cast_type = type_from_metatype(resolve_datatype(p_cast->cast_type));
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
if (!cast_type.is_set()) {
GDScript: Consolidate behavior for assigning enum types This makes sure that assigning values to enum-typed variables are consistent. Same enum is always valid, different enum is always invalid (without casting) and assigning `int` creates a warning if there is no casting. There are new test cases to ensure this behavior doesn't break in the future.
2022-01-27 15:34:33 +01:00
mark_node_unsafe(p_cast);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
return;
}
p_cast->set_datatype(cast_type);
GDScript: Fix constant conversions
2023-01-22 09:32:05 +01:00
if (p_cast->operand->is_constant) {
update_const_expression_builtin_type(p_cast->operand, cast_type, "cast", true);
if (cast_type.is_variant() || p_cast->operand->get_datatype() == cast_type) {
p_cast->is_constant = true;
p_cast->reduced_value = p_cast->operand->reduced_value;
}
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
GDScript: Fix issues with typed arrays
2022-11-27 08:56:53 +01:00
if (p_cast->operand->type == GDScriptParser::Node::ARRAY && cast_type.has_container_element_type()) {
update_array_literal_element_type(static_cast<GDScriptParser::ArrayNode *>(p_cast->operand), cast_type.get_container_element_type());
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
if (!cast_type.is_variant()) {
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
GDScriptParser::DataType op_type = p_cast->operand->get_datatype();
GDScript: Fix constant conversions
2023-01-22 09:32:05 +01:00
if (op_type.is_variant() || !op_type.is_hard_type()) {
mark_node_unsafe(p_cast);
#ifdef DEBUG_ENABLED
if (op_type.is_variant() && !op_type.is_hard_type()) {
parser->push_warning(p_cast, GDScriptWarning::UNSAFE_CAST, cast_type.to_string());
}
#endif
} else {
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
bool valid = false;
GDScript: Fix constant conversions
2023-01-22 09:32:05 +01:00
if (op_type.builtin_type == Variant::INT && cast_type.kind == GDScriptParser::DataType::ENUM) {
mark_node_unsafe(p_cast);
valid = true;
GDScript: Consolidate behavior for assigning enum types This makes sure that assigning values to enum-typed variables are consistent. Same enum is always valid, different enum is always invalid (without casting) and assigning `int` creates a warning if there is no casting. There are new test cases to ensure this behavior doesn't break in the future.
2022-01-27 15:34:33 +01:00
} else if (op_type.kind == GDScriptParser::DataType::BUILTIN && cast_type.kind == GDScriptParser::DataType::BUILTIN) {
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
valid = Variant::can_convert(op_type.builtin_type, cast_type.builtin_type);
} else if (op_type.kind != GDScriptParser::DataType::BUILTIN && cast_type.kind != GDScriptParser::DataType::BUILTIN) {
valid = is_type_compatible(cast_type, op_type) || is_type_compatible(op_type, cast_type);
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
GDScript: Fix constant conversions
2023-01-22 09:32:05 +01:00
if (!valid) {
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
push_error(vformat(R"(Invalid cast. Cannot convert from "%s" to "%s".)", op_type.to_string(), cast_type.to_string()), p_cast->cast_type);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
}
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
void GDScriptAnalyzer::reduce_dictionary(GDScriptParser::DictionaryNode *p_dictionary) {
Unify String and StringName
2022-12-06 03:46:47 +01:00
HashMap<Variant, GDScriptParser::ExpressionNode *, VariantHasher, StringLikeVariantComparator> elements;
GDScript: Check duplicate keys in dictionaries and enums
2020-08-19 16:14:16 +02:00
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
for (int i = 0; i < p_dictionary->elements.size(); i++) {
const GDScriptParser::DictionaryNode::Pair &element = p_dictionary->elements[i];
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
if (p_dictionary->style == GDScriptParser::DictionaryNode::PYTHON_DICT) {
reduce_expression(element.key);
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
reduce_expression(element.value);
GDScript: Check duplicate keys in dictionaries and enums
2020-08-19 16:14:16 +02:00
if (element.key->is_constant) {
if (elements.has(element.key->reduced_value)) {
push_error(vformat(R"(Key "%s" was already used in this dictionary (at line %d).)", element.key->reduced_value, elements[element.key->reduced_value]->start_line), element.key);
} else {
elements[element.key->reduced_value] = element.value;
}
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
// It's dictionary in any case.
GDScriptParser::DataType dict_type;
dict_type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
dict_type.kind = GDScriptParser::DataType::BUILTIN;
dict_type.builtin_type = Variant::DICTIONARY;
dict_type.is_constant = true;
p_dictionary->set_datatype(dict_type);
}
void GDScriptAnalyzer::reduce_get_node(GDScriptParser::GetNodeNode *p_get_node) {
GDScriptParser::DataType result;
GDScript: Check `get_node()` shorthand in static functions
2023-06-22 11:19:14 +02:00
result.kind = GDScriptParser::DataType::VARIANT;
if (!ClassDB::is_parent_class(parser->current_class->base_type.native_type, SNAME("Node"))) {
push_error(vformat(R"*(Cannot use shorthand "get_node()" notation ("%c") on a class that isn't a node.)*", p_get_node->use_dollar ? '$' : '%'), p_get_node);
p_get_node->set_datatype(result);
return;
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
GDScript: Check `get_node()` shorthand in static functions
2023-06-22 11:19:14 +02:00
if (static_context) {
push_error(vformat(R"*(Cannot use shorthand "get_node()" notation ("%c") in a static function.)*", p_get_node->use_dollar ? '$' : '%'), p_get_node);
p_get_node->set_datatype(result);
return;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
GDScript: Allow using self in lambdas
2022-04-20 19:22:22 +02:00
mark_lambda_use_self();
GDScript: Check `get_node()` shorthand in static functions
2023-06-22 11:19:14 +02:00
result.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
result.kind = GDScriptParser::DataType::NATIVE;
result.builtin_type = Variant::OBJECT;
result.native_type = SNAME("Node");
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
p_get_node->set_datatype(result);
}
GDScript: Give an error if dependency can't be parsed Otherwise this may lead to a crash when the dependency is not present.
2020-11-26 16:27:48 +01:00
GDScriptParser::DataType GDScriptAnalyzer::make_global_class_meta_type(const StringName &p_class_name, const GDScriptParser::Node *p_source) {
Fix a crash in GDScriptAnalyzer when a script class's file is not found
2022-02-28 12:20:00 +01:00
GDScriptParser::DataType type;
Add GDScript resource export.
2022-04-25 06:33:18 +02:00
String path = ScriptServer::get_global_class_path(p_class_name);
String ext = path.get_extension();
if (ext == GDScriptLanguage::get_singleton()->get_extension()) {
Ref<GDScriptParserRef> ref = get_parser_for(path);
if (ref.is_null()) {
push_error(vformat(R"(Could not find script for class "%s".)", p_class_name), p_source);
type.type_source = GDScriptParser::DataType::UNDETECTED;
type.kind = GDScriptParser::DataType::VARIANT;
return type;
}
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
Error err = ref->raise_status(GDScriptParserRef::INHERITANCE_SOLVED);
Add GDScript resource export.
2022-04-25 06:33:18 +02:00
if (err) {
push_error(vformat(R"(Could not resolve class "%s", because of a parser error.)", p_class_name), p_source);
type.type_source = GDScriptParser::DataType::UNDETECTED;
type.kind = GDScriptParser::DataType::VARIANT;
return type;
}
GDScript: Avoid using `get_global_class_native_base`
2022-11-25 11:21:15 +01:00
return ref->get_parser()->head->get_datatype();
Add GDScript resource export.
2022-04-25 06:33:18 +02:00
} else {
GDScript: Fix small inconsistencies with resolve_datatype
2023-01-12 00:03:53 +01:00
return make_script_meta_type(ResourceLoader::load(path, "Script"));
GDScript: Give an error if dependency can't be parsed Otherwise this may lead to a crash when the dependency is not present.
2020-11-26 16:27:48 +01:00
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
Fix GDScript base and outer classes, signals and functions lookup order - Add outer class lookup test - Add signal lookup test Co-authored-by: Dmitrii Maganov <vonagam@gmail.com>
2022-12-18 06:38:53 +01:00
void GDScriptAnalyzer::reduce_identifier_from_base_set_class(GDScriptParser::IdentifierNode *p_identifier, GDScriptParser::DataType p_identifier_datatype) {
ERR_FAIL_NULL(p_identifier);
p_identifier->set_datatype(p_identifier_datatype);
Error err = OK;
GDScript: Fix issues with typed arrays
2022-11-27 08:56:53 +01:00
Ref<GDScript> scr = GDScriptCache::get_shallow_script(p_identifier_datatype.script_path, err);
if (err) {
push_error(vformat(R"(Error while getting cache for script "%s".)", p_identifier_datatype.script_path), p_identifier);
return;
}
p_identifier->reduced_value = scr->find_class(p_identifier_datatype.class_type->fqcn);
Fix GDScript base and outer classes, signals and functions lookup order - Add outer class lookup test - Add signal lookup test Co-authored-by: Dmitrii Maganov <vonagam@gmail.com>
2022-12-18 06:38:53 +01:00
p_identifier->is_constant = true;
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
void GDScriptAnalyzer::reduce_identifier_from_base(GDScriptParser::IdentifierNode *p_identifier, GDScriptParser::DataType *p_base) {
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
if (!p_identifier->get_datatype().has_no_type()) {
return;
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
GDScriptParser::DataType base;
if (p_base == nullptr) {
base = type_from_metatype(parser->current_class->get_datatype());
} else {
base = *p_base;
}
Fix: Get constructor as Callable
2023-02-21 03:55:35 +01:00
StringName name = p_identifier->name;
Added support for enums to be used as types in GDScript
2020-06-12 02:49:58 +02:00
GDScript: Treat enum values as int and enum types as dictionary Since enums resolve to a dictionary at runtime, calling dictionary methods on an enum type is a valid use case. This ensures this is true by adding test cases. This also makes enum values be treated as ints when used in operations.
2022-02-02 17:57:24 +01:00
if (base.kind == GDScriptParser::DataType::ENUM) {
if (base.is_meta_type) {
if (base.enum_values.has(name)) {
Assorted enum and native type fixes
2022-12-04 04:02:03 +01:00
p_identifier->set_datatype(type_from_metatype(base));
GDScript: Treat enum values as int and enum types as dictionary Since enums resolve to a dictionary at runtime, calling dictionary methods on an enum type is a valid use case. This ensures this is true by adding test cases. This also makes enum values be treated as ints when used in operations.
2022-02-02 17:57:24 +01:00
p_identifier->is_constant = true;
p_identifier->reduced_value = base.enum_values[name];
return;
}
Assorted enum and native type fixes
2022-12-04 04:02:03 +01:00
// Enum does not have this value, return.
return;
GDScript: Treat enum values as int and enum types as dictionary Since enums resolve to a dictionary at runtime, calling dictionary methods on an enum type is a valid use case. This ensures this is true by adding test cases. This also makes enum values be treated as ints when used in operations.
2022-02-02 17:57:24 +01:00
} else {
push_error(R"(Cannot get property from enum value.)", p_identifier);
return;
}
}
Added support for enums to be used as types in GDScript
2020-06-12 02:49:58 +02:00
if (base.kind == GDScriptParser::DataType::BUILTIN) {
if (base.is_meta_type) {
bool valid = true;
Variant result = Variant::get_constant_value(base.builtin_type, name, &valid);
if (valid) {
p_identifier->is_constant = true;
p_identifier->reduced_value = result;
GDScript: Don't try to parse constant scripts that aren't valid Since it's likely that they won't parse correctly.
2020-08-31 14:53:02 +02:00
p_identifier->set_datatype(type_from_variant(result, p_identifier));
GDScript: Avoid inferred types from giving hard errors
2021-09-17 16:52:30 +02:00
} else if (base.is_hard_type()) {
Clean up ProjectConverter3To4 architecture, move renames map to separate file This allows properly limiting what features depend on the RegEx module (doing the actual conversion) and what features only require the renames data (GDScript suggestions). Also better excludes the conversion command line options when actually disabling deprecated code. Fixes #73029.
2023-02-10 09:07:01 +01:00
#ifdef SUGGEST_GODOT4_RENAMES
Add hint for identifiers renamed since Godot 3
2022-03-23 18:54:41 +01:00
String rename_hint = String();
GDScript: Reorganize and unify warnings
2023-04-28 17:20:41 +02:00
if (GLOBAL_GET(GDScriptWarning::get_settings_path_from_code(GDScriptWarning::Code::RENAMED_IN_GODOT_4_HINT)).booleanize()) {
Add hint for identifiers renamed since Godot 3
2022-03-23 18:54:41 +01:00
const char *renamed_identifier_name = check_for_renamed_identifier(name, p_identifier->type);
if (renamed_identifier_name) {
rename_hint = " " + vformat(R"(Did you mean to use "%s"?)", renamed_identifier_name);
}
}
push_error(vformat(R"(Cannot find constant "%s" on base "%s".%s)", name, base.to_string(), rename_hint), p_identifier);
#else
push_error(vformat(R"(Cannot find constant "%s" on base "%s".)", name, base.to_string()), p_identifier);
Clean up ProjectConverter3To4 architecture, move renames map to separate file This allows properly limiting what features depend on the RegEx module (doing the actual conversion) and what features only require the renames data (GDScript suggestions). Also better excludes the conversion command line options when actually disabling deprecated code. Fixes #73029.
2023-02-10 09:07:01 +01:00
#endif // SUGGEST_GODOT4_RENAMES
Added support for enums to be used as types in GDScript
2020-06-12 02:49:58 +02:00
}
} else {
fixed parser error when indexing a dictionary. Fix: #41707
2020-09-02 17:08:49 +02:00
switch (base.builtin_type) {
case Variant::NIL: {
GDScript: Avoid inferred types from giving hard errors
2021-09-17 16:52:30 +02:00
if (base.is_hard_type()) {
push_error(vformat(R"(Invalid get index "%s" on base Nil)", name), p_identifier);
}
Added support for enums to be used as types in GDScript
2020-06-12 02:49:58 +02:00
return;
}
fixed parser error when indexing a dictionary. Fix: #41707
2020-09-02 17:08:49 +02:00
case Variant::DICTIONARY: {
GDScriptParser::DataType dummy;
dummy.kind = GDScriptParser::DataType::VARIANT;
p_identifier->set_datatype(dummy);
return;
}
default: {
Callable::CallError temp;
Refactored variant constructor logic
2020-11-09 04:19:09 +01:00
Variant dummy;
Variant::construct(base.builtin_type, dummy, nullptr, 0, temp);
fixed parser error when indexing a dictionary. Fix: #41707
2020-09-02 17:08:49 +02:00
List<PropertyInfo> properties;
dummy.get_property_list(&properties);
Use C++ iterators for Lists in many situations
2021-07-16 05:45:57 +02:00
for (const PropertyInfo &prop : properties) {
fixed parser error when indexing a dictionary. Fix: #41707
2020-09-02 17:08:49 +02:00
if (prop.name == name) {
p_identifier->set_datatype(type_from_property(prop));
return;
}
}
GDScript: Avoid inferred types from giving hard errors
2021-09-17 16:52:30 +02:00
if (base.is_hard_type()) {
Clean up ProjectConverter3To4 architecture, move renames map to separate file This allows properly limiting what features depend on the RegEx module (doing the actual conversion) and what features only require the renames data (GDScript suggestions). Also better excludes the conversion command line options when actually disabling deprecated code. Fixes #73029.
2023-02-10 09:07:01 +01:00
#ifdef SUGGEST_GODOT4_RENAMES
Add hint for identifiers renamed since Godot 3
2022-03-23 18:54:41 +01:00
String rename_hint = String();
GDScript: Reorganize and unify warnings
2023-04-28 17:20:41 +02:00
if (GLOBAL_GET(GDScriptWarning::get_settings_path_from_code(GDScriptWarning::Code::RENAMED_IN_GODOT_4_HINT)).booleanize()) {
Add hint for identifiers renamed since Godot 3
2022-03-23 18:54:41 +01:00
const char *renamed_identifier_name = check_for_renamed_identifier(name, p_identifier->type);
if (renamed_identifier_name) {
rename_hint = " " + vformat(R"(Did you mean to use "%s"?)", renamed_identifier_name);
}
}
push_error(vformat(R"(Cannot find property "%s" on base "%s".%s)", name, base.to_string(), rename_hint), p_identifier);
#else
GDScript: Avoid inferred types from giving hard errors
2021-09-17 16:52:30 +02:00
push_error(vformat(R"(Cannot find property "%s" on base "%s".)", name, base.to_string()), p_identifier);
Clean up ProjectConverter3To4 architecture, move renames map to separate file This allows properly limiting what features depend on the RegEx module (doing the actual conversion) and what features only require the renames data (GDScript suggestions). Also better excludes the conversion command line options when actually disabling deprecated code. Fixes #73029.
2023-02-10 09:07:01 +01:00
#endif // SUGGEST_GODOT4_RENAMES
GDScript: Avoid inferred types from giving hard errors
2021-09-17 16:52:30 +02:00
}
fixed parser error when indexing a dictionary. Fix: #41707
2020-09-02 17:08:49 +02:00
}
Added support for enums to be used as types in GDScript
2020-06-12 02:49:58 +02:00
}
}
return;
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
GDScriptParser::ClassNode *base_class = base.class_type;
Fix GDScript base and outer classes, signals and functions lookup order - Add outer class lookup test - Add signal lookup test Co-authored-by: Dmitrii Maganov <vonagam@gmail.com>
2022-12-18 06:38:53 +01:00
List<GDScriptParser::ClassNode *> script_classes;
bool is_base = true;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
Fix GDScript base and outer classes, signals and functions lookup order - Add outer class lookup test - Add signal lookup test Co-authored-by: Dmitrii Maganov <vonagam@gmail.com>
2022-12-18 06:38:53 +01:00
if (base_class != nullptr) {
get_class_node_current_scope_classes(base_class, &script_classes);
}
Fix: Get constructor as Callable
2023-02-21 03:55:35 +01:00
bool is_constructor = base.is_meta_type && p_identifier->name == SNAME("new");
Fix GDScript base and outer classes, signals and functions lookup order - Add outer class lookup test - Add signal lookup test Co-authored-by: Dmitrii Maganov <vonagam@gmail.com>
2022-12-18 06:38:53 +01:00
for (GDScriptParser::ClassNode *script_class : script_classes) {
if (p_base == nullptr && script_class->identifier && script_class->identifier->name == name) {
reduce_identifier_from_base_set_class(p_identifier, script_class->get_datatype());
GDScript: Fix "Identifier not found" error when accessing inner class from inside
2023-08-11 10:22:01 +02:00
if (script_class->outer != nullptr) {
p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_CLASS;
}
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
return;
}
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
Fix: Get constructor as Callable
2023-02-21 03:55:35 +01:00
if (is_constructor) {
name = "_init";
}
Fix GDScript base and outer classes, signals and functions lookup order - Add outer class lookup test - Add signal lookup test Co-authored-by: Dmitrii Maganov <vonagam@gmail.com>
2022-12-18 06:38:53 +01:00
if (script_class->has_member(name)) {
resolve_class_member(script_class, name, p_identifier);
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
Fix GDScript base and outer classes, signals and functions lookup order - Add outer class lookup test - Add signal lookup test Co-authored-by: Dmitrii Maganov <vonagam@gmail.com>
2022-12-18 06:38:53 +01:00
GDScriptParser::ClassNode::Member member = script_class->get_member(name);
Added support for enums to be used as types in GDScript
2020-06-12 02:49:58 +02:00
switch (member.type) {
Fix GDScript base and outer classes, signals and functions lookup order - Add outer class lookup test - Add signal lookup test Co-authored-by: Dmitrii Maganov <vonagam@gmail.com>
2022-12-18 06:38:53 +01:00
case GDScriptParser::ClassNode::Member::CONSTANT: {
p_identifier->set_datatype(member.get_datatype());
Added support for enums to be used as types in GDScript
2020-06-12 02:49:58 +02:00
p_identifier->is_constant = true;
p_identifier->reduced_value = member.constant->initializer->reduced_value;
p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_CONSTANT;
p_identifier->constant_source = member.constant;
Fix GDScript base and outer classes, signals and functions lookup order - Add outer class lookup test - Add signal lookup test Co-authored-by: Dmitrii Maganov <vonagam@gmail.com>
2022-12-18 06:38:53 +01:00
return;
}
case GDScriptParser::ClassNode::Member::ENUM_VALUE: {
p_identifier->set_datatype(member.get_datatype());
Added support for enums to be used as types in GDScript
2020-06-12 02:49:58 +02:00
p_identifier->is_constant = true;
p_identifier->reduced_value = member.enum_value.value;
GDScript: Add lambdas to the type analyzer - Lambdas are always callables (no specific signature match). - Captures from the current context are evaluated.
2021-03-26 13:03:16 +01:00
p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_CONSTANT;
Fix GDScript base and outer classes, signals and functions lookup order - Add outer class lookup test - Add signal lookup test Co-authored-by: Dmitrii Maganov <vonagam@gmail.com>
2022-12-18 06:38:53 +01:00
return;
}
case GDScriptParser::ClassNode::Member::ENUM: {
p_identifier->set_datatype(member.get_datatype());
Fix usage of Enum as constant
2022-12-27 04:06:11 +01:00
p_identifier->is_constant = true;
p_identifier->reduced_value = member.m_enum->dictionary;
p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_CONSTANT;
Assorted enum and native type fixes
2022-12-04 04:02:03 +01:00
return;
}
Fix GDScript base and outer classes, signals and functions lookup order - Add outer class lookup test - Add signal lookup test Co-authored-by: Dmitrii Maganov <vonagam@gmail.com>
2022-12-18 06:38:53 +01:00
case GDScriptParser::ClassNode::Member::VARIABLE: {
Add support for static variables in GDScript Which allows editable data associated with a particular class instead of the instance. Scripts with static variables are kept in memory indefinitely unless the `@static_unload` annotation is used or the `static_unload()` method is called on the GDScript. If the custom function `_static_init()` exists it will be called when the class is loaded, after the static variables are set.
2023-04-19 16:10:35 +02:00
if (is_base && (!base.is_meta_type || member.variable->is_static)) {
Fix GDScript base and outer classes, signals and functions lookup order - Add outer class lookup test - Add signal lookup test Co-authored-by: Dmitrii Maganov <vonagam@gmail.com>
2022-12-18 06:38:53 +01:00
p_identifier->set_datatype(member.get_datatype());
Add support for static variables in GDScript Which allows editable data associated with a particular class instead of the instance. Scripts with static variables are kept in memory indefinitely unless the `@static_unload` annotation is used or the `static_unload()` method is called on the GDScript. If the custom function `_static_init()` exists it will be called when the class is loaded, after the static variables are set.
2023-04-19 16:10:35 +02:00
p_identifier->source = member.variable->is_static ? GDScriptParser::IdentifierNode::STATIC_VARIABLE : GDScriptParser::IdentifierNode::MEMBER_VARIABLE;
Fix GDScript base and outer classes, signals and functions lookup order - Add outer class lookup test - Add signal lookup test Co-authored-by: Dmitrii Maganov <vonagam@gmail.com>
2022-12-18 06:38:53 +01:00
p_identifier->variable_source = member.variable;
member.variable->usages += 1;
return;
}
} break;
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
Fix GDScript base and outer classes, signals and functions lookup order - Add outer class lookup test - Add signal lookup test Co-authored-by: Dmitrii Maganov <vonagam@gmail.com>
2022-12-18 06:38:53 +01:00
case GDScriptParser::ClassNode::Member::SIGNAL: {
if (is_base && !base.is_meta_type) {
p_identifier->set_datatype(member.get_datatype());
p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_SIGNAL;
return;
Fix constant base typing in extended GDScript class
2022-12-04 22:55:40 +01:00
}
Fix GDScript base and outer classes, signals and functions lookup order - Add outer class lookup test - Add signal lookup test Co-authored-by: Dmitrii Maganov <vonagam@gmail.com>
2022-12-18 06:38:53 +01:00
} break;
case GDScriptParser::ClassNode::Member::FUNCTION: {
GDScript: Fix some bugs with static variables and functions
2023-05-16 12:03:53 +02:00
if (is_base && (!base.is_meta_type || member.function->is_static)) {
Fix GDScript base and outer classes, signals and functions lookup order - Add outer class lookup test - Add signal lookup test Co-authored-by: Dmitrii Maganov <vonagam@gmail.com>
2022-12-18 06:38:53 +01:00
p_identifier->set_datatype(make_callable_type(member.function->info));
GDScript: Fix bug with identifier shadowed below in current scope
2023-07-25 13:21:49 +02:00
p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_FUNCTION;
Fix GDScript base and outer classes, signals and functions lookup order - Add outer class lookup test - Add signal lookup test Co-authored-by: Dmitrii Maganov <vonagam@gmail.com>
2022-12-18 06:38:53 +01:00
return;
}
} break;
case GDScriptParser::ClassNode::Member::CLASS: {
reduce_identifier_from_base_set_class(p_identifier, member.get_datatype());
GDScript: Fix bug with identifier shadowed below in current scope
2023-07-25 13:21:49 +02:00
p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_CLASS;
Fix GDScript base and outer classes, signals and functions lookup order - Add outer class lookup test - Add signal lookup test Co-authored-by: Dmitrii Maganov <vonagam@gmail.com>
2022-12-18 06:38:53 +01:00
return;
}
default: {
// Do nothing
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
}
}
Fix GDScript base and outer classes, signals and functions lookup order - Add outer class lookup test - Add signal lookup test Co-authored-by: Dmitrii Maganov <vonagam@gmail.com>
2022-12-18 06:38:53 +01:00
if (is_base) {
is_base = script_class->base_type.class_type != nullptr;
if (!is_base && p_base != nullptr) {
break;
}
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
Fix ability to overload "script" variable
2022-11-08 23:41:50 +01:00
// Check native members. No need for native class recursion because Node exposes all Object's properties.
Remove underscore hacks Way less cruft. :) Co-authored-by: Ignacio Roldán Etcheverry <neikeq@users.noreply.github.com>
2021-08-17 15:06:54 +02:00
const StringName &native = base.native_type;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
if (class_exists(native)) {
Fix: Get constructor as Callable
2023-02-21 03:55:35 +01:00
if (is_constructor) {
name = "_init";
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
MethodInfo method_info;
GDScript: Use getter return type for the property type The PropertyInfo hints are more relevant for the inspector. The getter return type is more reliable and less likely to be incorrect and it is what's going to be called in the end.
2021-09-21 20:29:06 +02:00
if (ClassDB::has_property(native, name)) {
StringName getter_name = ClassDB::get_property_getter(native, name);
MethodBind *getter = ClassDB::get_method(native, getter_name);
if (getter != nullptr) {
GDScript: Improve usability of setter chains - Consider PackedArrays non-shared since they are copied on C++/script boundaries. - Add error messages in the analyzer when assigning to read-only properties. - Add specific error message at runtime when assignment fails because the property is read-only.
2023-01-30 18:50:08 +01:00
bool has_setter = ClassDB::get_property_setter(native, name) != StringName();
p_identifier->set_datatype(type_from_property(getter->get_return_info(), false, !has_setter));
GDScript: Allow using self in lambdas
2022-04-20 19:22:22 +02:00
p_identifier->source = GDScriptParser::IdentifierNode::INHERITED_VARIABLE;
GDScript: Use getter return type for the property type The PropertyInfo hints are more relevant for the inspector. The getter return type is more reliable and less likely to be incorrect and it is what's going to be called in the end.
2021-09-21 20:29:06 +02:00
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
return;
}
if (ClassDB::get_method_info(native, name, &method_info)) {
// Method is callable.
p_identifier->set_datatype(make_callable_type(method_info));
GDScript: Allow using self in lambdas
2022-04-20 19:22:22 +02:00
p_identifier->source = GDScriptParser::IdentifierNode::INHERITED_VARIABLE;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
return;
}
if (ClassDB::get_signal(native, name, &method_info)) {
// Signal is a type too.
p_identifier->set_datatype(make_signal_type(method_info));
GDScript: Allow using self in lambdas
2022-04-20 19:22:22 +02:00
p_identifier->source = GDScriptParser::IdentifierNode::INHERITED_VARIABLE;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
return;
}
Added support for enums to be used as types in GDScript
2020-06-12 02:49:58 +02:00
if (ClassDB::has_enum(native, name)) {
Assorted enum and native type fixes
2022-12-04 04:02:03 +01:00
p_identifier->set_datatype(make_native_enum_type(name, native));
GDScript: Allow using self in lambdas
2022-04-20 19:22:22 +02:00
p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_CONSTANT;
Added support for enums to be used as types in GDScript
2020-06-12 02:49:58 +02:00
return;
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
bool valid = false;
Assorted enum and native type fixes
2022-12-04 04:02:03 +01:00
Make enum/constant binds 64-bit.
2022-05-09 11:47:10 +02:00
int64_t int_constant = ClassDB::get_integer_constant(native, name, &valid);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
if (valid) {
p_identifier->is_constant = true;
p_identifier->reduced_value = int_constant;
GDScript: Allow using self in lambdas
2022-04-20 19:22:22 +02:00
p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_CONSTANT;
Assorted enum and native type fixes
2022-12-04 04:02:03 +01:00
// Check whether this constant, which exists, belongs to an enum
StringName enum_name = ClassDB::get_integer_constant_enum(native, name);
if (enum_name != StringName()) {
p_identifier->set_datatype(make_native_enum_type(enum_name, native, false));
} else {
p_identifier->set_datatype(type_from_variant(int_constant, p_identifier));
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
}
}
Added support for enums to be used as types in GDScript
2020-06-12 02:49:58 +02:00
void GDScriptAnalyzer::reduce_identifier(GDScriptParser::IdentifierNode *p_identifier, bool can_be_builtin) {
Assorted enum and native type fixes
2022-12-04 04:02:03 +01:00
// TODO: This is an opportunity to further infer types.
GDScript: Allow enum values to be set to constant expressions Also allow them to access previous values wihout referencing the enum.
2020-08-18 22:44:20 +02:00
Assorted enum and native type fixes
2022-12-04 04:02:03 +01:00
// Check if we are inside an enum. This allows enum values to access other elements of the same enum.
GDScript: Allow enum values to be set to constant expressions Also allow them to access previous values wihout referencing the enum.
2020-08-18 22:44:20 +02:00
if (current_enum) {
for (int i = 0; i < current_enum->values.size(); i++) {
const GDScriptParser::EnumNode::Value &element = current_enum->values[i];
if (element.identifier->name == p_identifier->name) {
Fix unnammed enum crash regression
2023-01-18 15:12:27 +01:00
StringName enum_name = current_enum->identifier ? current_enum->identifier->name : UNNAMED_ENUM;
Assorted enum and native type fixes
2022-12-04 04:02:03 +01:00
GDScriptParser::DataType type = make_enum_type(enum_name, parser->current_class->fqcn, false);
GDScript: Allow enum values to be set to constant expressions Also allow them to access previous values wihout referencing the enum.
2020-08-18 22:44:20 +02:00
if (element.parent_enum->identifier) {
type.enum_type = element.parent_enum->identifier->name;
}
p_identifier->set_datatype(type);
if (element.resolved) {
p_identifier->is_constant = true;
p_identifier->reduced_value = element.value;
} else {
push_error(R"(Cannot use another enum element before it was declared.)", p_identifier);
}
return; // Found anyway.
}
}
}
GDScript: Add lambdas to the type analyzer - Lambdas are always callables (no specific signature match). - Captures from the current context are evaluated.
2021-03-26 13:03:16 +01:00
bool found_source = false;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
// Check if identifier is local.
// If that's the case, the declaration already was solved before.
switch (p_identifier->source) {
case GDScriptParser::IdentifierNode::FUNCTION_PARAMETER:
p_identifier->set_datatype(p_identifier->parameter_source->get_datatype());
GDScript: Add lambdas to the type analyzer - Lambdas are always callables (no specific signature match). - Captures from the current context are evaluated.
2021-03-26 13:03:16 +01:00
found_source = true;
break;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
case GDScriptParser::IdentifierNode::LOCAL_CONSTANT:
case GDScriptParser::IdentifierNode::MEMBER_CONSTANT:
p_identifier->set_datatype(p_identifier->constant_source->get_datatype());
p_identifier->is_constant = true;
// TODO: Constant should have a value on the node itself.
p_identifier->reduced_value = p_identifier->constant_source->initializer->reduced_value;
GDScript: Add lambdas to the type analyzer - Lambdas are always callables (no specific signature match). - Captures from the current context are evaluated.
2021-03-26 13:03:16 +01:00
found_source = true;
break;
Fix using signals in lambda functions
2022-11-21 20:38:02 +01:00
case GDScriptParser::IdentifierNode::MEMBER_SIGNAL:
GDScript: Allow using self in lambdas
2022-04-20 19:22:22 +02:00
case GDScriptParser::IdentifierNode::INHERITED_VARIABLE:
mark_lambda_use_self();
break;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
case GDScriptParser::IdentifierNode::MEMBER_VARIABLE:
GDScript: Allow using self in lambdas
2022-04-20 19:22:22 +02:00
mark_lambda_use_self();
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
p_identifier->variable_source->usages++;
[[fallthrough]];
Add support for static variables in GDScript Which allows editable data associated with a particular class instead of the instance. Scripts with static variables are kept in memory indefinitely unless the `@static_unload` annotation is used or the `static_unload()` method is called on the GDScript. If the custom function `_static_init()` exists it will be called when the class is loaded, after the static variables are set.
2023-04-19 16:10:35 +02:00
case GDScriptParser::IdentifierNode::STATIC_VARIABLE:
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
case GDScriptParser::IdentifierNode::LOCAL_VARIABLE:
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
p_identifier->set_datatype(p_identifier->variable_source->get_datatype());
GDScript: Add lambdas to the type analyzer - Lambdas are always callables (no specific signature match). - Captures from the current context are evaluated.
2021-03-26 13:03:16 +01:00
found_source = true;
break;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
case GDScriptParser::IdentifierNode::LOCAL_ITERATOR:
p_identifier->set_datatype(p_identifier->bind_source->get_datatype());
GDScript: Add lambdas to the type analyzer - Lambdas are always callables (no specific signature match). - Captures from the current context are evaluated.
2021-03-26 13:03:16 +01:00
found_source = true;
break;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
case GDScriptParser::IdentifierNode::LOCAL_BIND: {
GDScriptParser::DataType result = p_identifier->bind_source->get_datatype();
result.is_constant = true;
p_identifier->set_datatype(result);
GDScript: Add lambdas to the type analyzer - Lambdas are always callables (no specific signature match). - Captures from the current context are evaluated.
2021-03-26 13:03:16 +01:00
found_source = true;
} break;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
case GDScriptParser::IdentifierNode::UNDEFINED_SOURCE:
GDScript: Fix bug with identifier shadowed below in current scope
2023-07-25 13:21:49 +02:00
case GDScriptParser::IdentifierNode::MEMBER_FUNCTION:
case GDScriptParser::IdentifierNode::MEMBER_CLASS:
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
break;
}
GDScript: Fix bug with identifier shadowed below in current scope
2023-07-25 13:21:49 +02:00
#ifdef DEBUG_ENABLED
if (!found_source && p_identifier->suite != nullptr && p_identifier->suite->has_local(p_identifier->name)) {
parser->push_warning(p_identifier, GDScriptWarning::CONFUSABLE_LOCAL_USAGE, p_identifier->name);
}
#endif
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
// Not a local, so check members.
GDScript: Add lambdas to the type analyzer - Lambdas are always callables (no specific signature match). - Captures from the current context are evaluated.
2021-03-26 13:03:16 +01:00
if (!found_source) {
reduce_identifier_from_base(p_identifier);
if (p_identifier->source != GDScriptParser::IdentifierNode::UNDEFINED_SOURCE || p_identifier->get_datatype().is_set()) {
// Found.
found_source = true;
}
}
if (found_source) {
Fix GDScript base and outer classes, signals and functions lookup order - Add outer class lookup test - Add signal lookup test Co-authored-by: Dmitrii Maganov <vonagam@gmail.com>
2022-12-18 06:38:53 +01:00
bool source_is_variable = p_identifier->source == GDScriptParser::IdentifierNode::MEMBER_VARIABLE || p_identifier->source == GDScriptParser::IdentifierNode::INHERITED_VARIABLE;
bool source_is_signal = p_identifier->source == GDScriptParser::IdentifierNode::MEMBER_SIGNAL;
Add support for static variables in GDScript Which allows editable data associated with a particular class instead of the instance. Scripts with static variables are kept in memory indefinitely unless the `@static_unload` annotation is used or the `static_unload()` method is called on the GDScript. If the custom function `_static_init()` exists it will be called when the class is loaded, after the static variables are set.
2023-04-19 16:10:35 +02:00
if ((source_is_variable || source_is_signal) && static_context) {
if (parser->current_function) {
// Get the parent function above any lambda.
GDScriptParser::FunctionNode *parent_function = parser->current_function;
while (parent_function->source_lambda) {
parent_function = parent_function->source_lambda->parent_function;
}
push_error(vformat(R"*(Cannot access %s "%s" from the static function "%s()".)*", source_is_signal ? "signal" : "instance variable", p_identifier->name, parent_function->identifier->name), p_identifier);
} else {
push_error(vformat(R"*(Cannot access %s "%s" for a static variable initializer.)*", source_is_signal ? "signal" : "instance variable", p_identifier->name), p_identifier);
GDScript: Allow using self in lambdas
2022-04-20 19:22:22 +02:00
}
GDScript: Add lambdas to the type analyzer - Lambdas are always callables (no specific signature match). - Captures from the current context are evaluated.
2021-03-26 13:03:16 +01:00
}
GDScript: Fix lambda resolution with cyclic references
2023-08-23 11:37:18 +02:00
if (current_lambda != nullptr) {
Fix GDScript base and outer classes, signals and functions lookup order - Add outer class lookup test - Add signal lookup test Co-authored-by: Dmitrii Maganov <vonagam@gmail.com>
2022-12-18 06:38:53 +01:00
// If the identifier is a member variable (including the native class properties) or a signal, we consider the lambda to be using `self`, so we keep a reference to the current instance.
if (source_is_variable || source_is_signal) {
GDScript: Allow using self in lambdas
2022-04-20 19:22:22 +02:00
mark_lambda_use_self();
return; // No need to capture.
}
// If the identifier is local, check if it's any kind of capture by comparing their source function.
// Only capture locals and enum values. Constants are still accessible from the lambda using the script reference. If not, this method is done.
if (p_identifier->source == GDScriptParser::IdentifierNode::UNDEFINED_SOURCE || p_identifier->source == GDScriptParser::IdentifierNode::MEMBER_CONSTANT) {
return;
}
GDScript: Fix lambda resolution with cyclic references
2023-08-23 11:37:18 +02:00
GDScriptParser::FunctionNode *function_test = current_lambda->function;
GDScript: Allow using self in lambdas
2022-04-20 19:22:22 +02:00
// Make sure we aren't capturing variable in the same lambda.
// This also add captures for nested lambdas.
while (function_test != nullptr && function_test != p_identifier->source_function && function_test->source_lambda != nullptr && !function_test->source_lambda->captures_indices.has(p_identifier->name)) {
function_test->source_lambda->captures_indices[p_identifier->name] = function_test->source_lambda->captures.size();
function_test->source_lambda->captures.push_back(p_identifier);
function_test = function_test->source_lambda->parent_function;
}
GDScript: Add lambdas to the type analyzer - Lambdas are always callables (no specific signature match). - Captures from the current context are evaluated.
2021-03-26 13:03:16 +01:00
}
GDScript: Allow using self in lambdas
2022-04-20 19:22:22 +02:00
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
return;
}
StringName name = p_identifier->name;
p_identifier->source = GDScriptParser::IdentifierNode::UNDEFINED_SOURCE;
Fixed ParseError when calling Object.new() Fixes #41462 where calling Object.new() in GDScript gave an error. I fixed it by adding exclusion when checking if the name is a builtin type to exclude objects with a comment detailing why.
2020-08-25 21:00:56 +02:00
// Check globals. We make an exception for Variant::OBJECT because it's the base class for
// non-builtin types so we allow doing e.g. Object.new()
Variant::Type builtin_type = GDScriptParser::get_builtin_type(name);
if (builtin_type != Variant::OBJECT && builtin_type < Variant::VARIANT_MAX) {
Added support for enums to be used as types in GDScript
2020-06-12 02:49:58 +02:00
if (can_be_builtin) {
Fixed ParseError when calling Object.new() Fixes #41462 where calling Object.new() in GDScript gave an error. I fixed it by adding exclusion when checking if the name is a builtin type to exclude objects with a comment detailing why.
2020-08-25 21:00:56 +02:00
p_identifier->set_datatype(make_builtin_meta_type(builtin_type));
Added support for enums to be used as types in GDScript
2020-06-12 02:49:58 +02:00
return;
} else {
push_error(R"(Builtin type cannot be used as a name on its own.)", p_identifier);
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
if (class_exists(name)) {
p_identifier->set_datatype(make_native_meta_type(name));
return;
}
if (ScriptServer::is_global_class(name)) {
GDScript: Give an error if dependency can't be parsed Otherwise this may lead to a crash when the dependency is not present.
2020-11-26 16:27:48 +01:00
p_identifier->set_datatype(make_global_class_meta_type(name, p_identifier));
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
return;
}
GDScript: Fix analysis of singleton dependencies Sometimes a singleton might depend on another before they are fully compiled so we can't rely on globals in this case.
2020-09-01 01:08:46 +02:00
// Try singletons.
// Do this before globals because this might be a singleton loading another one before it's compiled.
if (ProjectSettings::get_singleton()->has_autoload(name)) {
const ProjectSettings::AutoloadInfo &autoload = ProjectSettings::get_singleton()->get_autoload(name);
if (autoload.is_singleton) {
// Singleton exists, so it's at least a Node.
GDScriptParser::DataType result;
result.kind = GDScriptParser::DataType::NATIVE;
result.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
Fix cyclic references in GDScript 2.0
2022-10-09 18:41:28 +02:00
if (ResourceLoader::get_resource_type(autoload.path) == "GDScript") {
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 11:53:28 +02:00
Ref<GDScriptParserRef> singl_parser = get_parser_for(autoload.path);
if (singl_parser.is_valid()) {
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
Error err = singl_parser->raise_status(GDScriptParserRef::INHERITANCE_SOLVED);
GDScript: Fix analysis of singleton dependencies Sometimes a singleton might depend on another before they are fully compiled so we can't rely on globals in this case.
2020-09-01 01:08:46 +02:00
if (err == OK) {
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 11:53:28 +02:00
result = type_from_metatype(singl_parser->get_parser()->head->get_datatype());
GDScript: Fix analysis of singleton dependencies Sometimes a singleton might depend on another before they are fully compiled so we can't rely on globals in this case.
2020-09-01 01:08:46 +02:00
}
}
[godot#61386] Fix autoload scenes implicit types
2022-11-22 05:24:10 +01:00
} else if (ResourceLoader::get_resource_type(autoload.path) == "PackedScene") {
Unify GDScriptAnalyzer in-editor and runtime autoload checks
2022-12-20 05:09:32 +01:00
if (GDScriptLanguage::get_singleton()->has_any_global_constant(name)) {
Variant constant = GDScriptLanguage::get_singleton()->get_any_global_constant(name);
Fix singleton scene cyclic loading
2022-11-24 00:13:13 +01:00
Node *node = Object::cast_to<Node>(constant);
if (node != nullptr) {
GDScript: Fix subclass script path issues
2022-12-01 11:20:42 +01:00
Ref<GDScript> scr = node->get_script();
Fix singleton scene cyclic loading
2022-11-24 00:13:13 +01:00
if (scr.is_valid()) {
GDScript: Fix subclass script path issues
2022-12-01 11:20:42 +01:00
Ref<GDScriptParserRef> singl_parser = get_parser_for(scr->get_script_path());
Fix singleton scene cyclic loading
2022-11-24 00:13:13 +01:00
if (singl_parser.is_valid()) {
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
Error err = singl_parser->raise_status(GDScriptParserRef::INHERITANCE_SOLVED);
Fix singleton scene cyclic loading
2022-11-24 00:13:13 +01:00
if (err == OK) {
result = type_from_metatype(singl_parser->get_parser()->head->get_datatype());
}
}
[godot#61386] Fix autoload scenes implicit types
2022-11-22 05:24:10 +01:00
}
}
}
GDScript: Fix analysis of singleton dependencies Sometimes a singleton might depend on another before they are fully compiled so we can't rely on globals in this case.
2020-09-01 01:08:46 +02:00
}
result.is_constant = true;
p_identifier->set_datatype(result);
return;
}
}
Make global scope enums accessible as types in GDScript Add functions to CoreConstant so enums can be properly deduced. Also add the enums in release builds to make consistent with ClassDB enums and avoid differences in script compilation between debug and release.
2023-02-19 16:57:09 +01:00
if (CoreConstants::is_global_constant(name)) {
int index = CoreConstants::get_global_constant_index(name);
StringName enum_name = CoreConstants::get_global_constant_enum(index);
int64_t value = CoreConstants::get_global_constant_value(index);
if (enum_name != StringName()) {
p_identifier->set_datatype(make_global_enum_type(enum_name, StringName(), false));
} else {
p_identifier->set_datatype(type_from_variant(value, p_identifier));
}
p_identifier->is_constant = true;
p_identifier->reduced_value = value;
return;
}
Unify GDScriptAnalyzer in-editor and runtime autoload checks
2022-12-20 05:09:32 +01:00
if (GDScriptLanguage::get_singleton()->has_any_global_constant(name)) {
Variant constant = GDScriptLanguage::get_singleton()->get_any_global_constant(name);
GDScript: Don't try to parse constant scripts that aren't valid Since it's likely that they won't parse correctly.
2020-08-31 14:53:02 +02:00
p_identifier->set_datatype(type_from_variant(constant, p_identifier));
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
p_identifier->is_constant = true;
p_identifier->reduced_value = constant;
return;
}
Make global scope enums accessible as types in GDScript Add functions to CoreConstant so enums can be properly deduced. Also add the enums in release builds to make consistent with ClassDB enums and avoid differences in script compilation between debug and release.
2023-02-19 16:57:09 +01:00
if (CoreConstants::is_global_enum(name)) {
p_identifier->set_datatype(make_global_enum_type(name, StringName(), true));
if (!can_be_builtin) {
push_error(vformat(R"(Global enum "%s" cannot be used on its own.)", name), p_identifier);
}
return;
}
// Allow "Variant" here since it might be used for nested enums.
if (can_be_builtin && name == SNAME("Variant")) {
GDScriptParser::DataType variant;
variant.kind = GDScriptParser::DataType::VARIANT;
variant.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
variant.is_meta_type = true;
variant.is_pseudo_type = true;
p_identifier->set_datatype(variant);
return;
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
// Not found.
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
// Check if it's a builtin function.
GDScript: Refactor builtin functions They are now called "utility functions" to avoid confusion with methods of builtin types, and be consistent with the naming in Variant. Core utility functions are now available in GDScript. The ones missing in core are added specifically to GDScript as helpers for convenience. Some functions were remove when there are better ways to do, reducing redundancy and cleaning up the global scope.
2020-11-26 15:56:32 +01:00
if (GDScriptUtilityFunctions::function_exists(name)) {
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
push_error(vformat(R"(Built-in function "%s" cannot be used as an identifier.)", name), p_identifier);
} else {
Clean up ProjectConverter3To4 architecture, move renames map to separate file This allows properly limiting what features depend on the RegEx module (doing the actual conversion) and what features only require the renames data (GDScript suggestions). Also better excludes the conversion command line options when actually disabling deprecated code. Fixes #73029.
2023-02-10 09:07:01 +01:00
#ifdef SUGGEST_GODOT4_RENAMES
Add hint for identifiers renamed since Godot 3
2022-03-23 18:54:41 +01:00
String rename_hint = String();
GDScript: Reorganize and unify warnings
2023-04-28 17:20:41 +02:00
if (GLOBAL_GET(GDScriptWarning::get_settings_path_from_code(GDScriptWarning::Code::RENAMED_IN_GODOT_4_HINT)).booleanize()) {
Add hint for identifiers renamed since Godot 3
2022-03-23 18:54:41 +01:00
const char *renamed_identifier_name = check_for_renamed_identifier(name, p_identifier->type);
if (renamed_identifier_name) {
rename_hint = " " + vformat(R"(Did you mean to use "%s"?)", renamed_identifier_name);
}
}
push_error(vformat(R"(Identifier "%s" not declared in the current scope.%s)", name, rename_hint), p_identifier);
#else
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
push_error(vformat(R"(Identifier "%s" not declared in the current scope.)", name), p_identifier);
Clean up ProjectConverter3To4 architecture, move renames map to separate file This allows properly limiting what features depend on the RegEx module (doing the actual conversion) and what features only require the renames data (GDScript suggestions). Also better excludes the conversion command line options when actually disabling deprecated code. Fixes #73029.
2023-02-10 09:07:01 +01:00
#endif // SUGGEST_GODOT4_RENAMES
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
GDScriptParser::DataType dummy;
dummy.kind = GDScriptParser::DataType::VARIANT;
p_identifier->set_datatype(dummy); // Just so type is set to something.
}
GDScript: Add lambdas to the type analyzer - Lambdas are always callables (no specific signature match). - Captures from the current context are evaluated.
2021-03-26 13:03:16 +01:00
void GDScriptAnalyzer::reduce_lambda(GDScriptParser::LambdaNode *p_lambda) {
// Lambda is always a Callable.
GDScriptParser::DataType lambda_type;
lambda_type.type_source = GDScriptParser::DataType::ANNOTATED_INFERRED;
lambda_type.kind = GDScriptParser::DataType::BUILTIN;
lambda_type.builtin_type = Variant::CALLABLE;
p_lambda->set_datatype(lambda_type);
if (p_lambda->function == nullptr) {
return;
}
GDScript: Fix lambda resolution with cyclic references
2023-08-23 11:37:18 +02:00
GDScriptParser::LambdaNode *previous_lambda = current_lambda;
current_lambda = p_lambda;
GDScript: Fix typing of lambda functions
2022-12-28 06:41:03 +01:00
resolve_function_signature(p_lambda->function, p_lambda, true);
GDScript: Fix lambda resolution with cyclic references
2023-08-23 11:37:18 +02:00
current_lambda = previous_lambda;
GDScript: Add lambdas to the type analyzer - Lambdas are always callables (no specific signature match). - Captures from the current context are evaluated.
2021-03-26 13:03:16 +01:00
GDScript: Fix lambda resolution with cyclic references
2023-08-23 11:37:18 +02:00
pending_body_resolution_lambdas.push_back(p_lambda);
GDScript: Add lambdas to the type analyzer - Lambdas are always callables (no specific signature match). - Captures from the current context are evaluated.
2021-03-26 13:03:16 +01:00
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
void GDScriptAnalyzer::reduce_literal(GDScriptParser::LiteralNode *p_literal) {
p_literal->reduced_value = p_literal->value;
p_literal->is_constant = true;
GDScript: Don't try to parse constant scripts that aren't valid Since it's likely that they won't parse correctly.
2020-08-31 14:53:02 +02:00
p_literal->set_datatype(type_from_variant(p_literal->reduced_value, p_literal));
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
void GDScriptAnalyzer::reduce_preload(GDScriptParser::PreloadNode *p_preload) {
GDScript: Allow preload() to be used with constant expressions
2020-08-19 15:45:00 +02:00
if (!p_preload->path) {
return;
}
reduce_expression(p_preload->path);
if (!p_preload->path->is_constant) {
push_error("Preloaded path must be a constant string.", p_preload->path);
return;
}
if (p_preload->path->reduced_value.get_type() != Variant::STRING) {
push_error("Preloaded path must be a constant string.", p_preload->path);
} else {
p_preload->resolved_path = p_preload->path->reduced_value;
// TODO: Save this as script dependency.
Rename String::is_rel_path to String::is_relative_path
2021-08-30 01:43:47 +02:00
if (p_preload->resolved_path.is_relative_path()) {
Rename String `plus_file` to `path_join`
2022-08-30 02:34:01 +02:00
p_preload->resolved_path = parser->script_path.get_base_dir().path_join(p_preload->resolved_path);
GDScript: Allow preload() to be used with constant expressions
2020-08-19 15:45:00 +02:00
}
p_preload->resolved_path = p_preload->resolved_path.simplify_path();
Fix GDScript `preload` fails in standalone build unless files are present in directory Fixes #56343.
2022-08-31 17:52:37 +02:00
if (!ResourceLoader::exists(p_preload->resolved_path)) {
Clarified reason why a resource cannot be loaded.
2022-10-16 05:20:57 +02:00
Ref<FileAccess> file_check = FileAccess::create(FileAccess::ACCESS_RESOURCES);
if (file_check->file_exists(p_preload->resolved_path)) {
push_error(vformat(R"(Preload file "%s" has no resource loaders (unrecognized file extension).)", p_preload->resolved_path), p_preload->path);
} else {
push_error(vformat(R"(Preload file "%s" does not exist.)", p_preload->resolved_path), p_preload->path);
}
GDScript: Allow preload() to be used with constant expressions
2020-08-19 15:45:00 +02:00
} else {
// TODO: Don't load if validating: use completion cache.
Fix cyclic references in GDScript 2.0
2022-10-09 18:41:28 +02:00
// Must load GDScript and PackedScenes separately to permit cyclic references
// as ResourceLoader::load() detect and reject those.
if (ResourceLoader::get_resource_type(p_preload->resolved_path) == "GDScript") {
Error err = OK;
Ref<GDScript> res = GDScriptCache::get_shallow_script(p_preload->resolved_path, err, parser->script_path);
p_preload->resource = res;
if (err != OK) {
push_error(vformat(R"(Could not preload resource script "%s".)", p_preload->resolved_path), p_preload->path);
}
} else if (ResourceLoader::get_resource_type(p_preload->resolved_path) == "PackedScene") {
Error err = OK;
Ref<PackedScene> res = GDScriptCache::get_packed_scene(p_preload->resolved_path, err, parser->script_path);
p_preload->resource = res;
if (err != OK) {
push_error(vformat(R"(Could not preload resource scene "%s".)", p_preload->resolved_path), p_preload->path);
}
} else {
p_preload->resource = ResourceLoader::load(p_preload->resolved_path);
if (p_preload->resource.is_null()) {
push_error(vformat(R"(Could not preload resource file "%s".)", p_preload->resolved_path), p_preload->path);
}
GDScript: Allow preload() to be used with constant expressions
2020-08-19 15:45:00 +02:00
}
}
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
p_preload->is_constant = true;
p_preload->reduced_value = p_preload->resource;
GDScript: Don't try to parse constant scripts that aren't valid Since it's likely that they won't parse correctly.
2020-08-31 14:53:02 +02:00
p_preload->set_datatype(type_from_variant(p_preload->reduced_value, p_preload));
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
void GDScriptAnalyzer::reduce_self(GDScriptParser::SelfNode *p_self) {
p_self->is_constant = false;
p_self->set_datatype(type_from_metatype(parser->current_class->get_datatype()));
GDScript: Allow using self in lambdas
2022-04-20 19:22:22 +02:00
mark_lambda_use_self();
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
Make global scope enums accessible as types in GDScript Add functions to CoreConstant so enums can be properly deduced. Also add the enums in release builds to make consistent with ClassDB enums and avoid differences in script compilation between debug and release.
2023-02-19 16:57:09 +01:00
void GDScriptAnalyzer::reduce_subscript(GDScriptParser::SubscriptNode *p_subscript, bool p_can_be_pseudo_type) {
Fix crash when writing $. in the editor
2021-06-24 22:03:40 +02:00
if (p_subscript->base == nullptr) {
return;
}
Added support for enums to be used as types in GDScript
2020-06-12 02:49:58 +02:00
if (p_subscript->base->type == GDScriptParser::Node::IDENTIFIER) {
reduce_identifier(static_cast<GDScriptParser::IdentifierNode *>(p_subscript->base), true);
Make global scope enums accessible as types in GDScript Add functions to CoreConstant so enums can be properly deduced. Also add the enums in release builds to make consistent with ClassDB enums and avoid differences in script compilation between debug and release.
2023-02-19 16:57:09 +01:00
} else if (p_subscript->base->type == GDScriptParser::Node::SUBSCRIPT) {
reduce_subscript(static_cast<GDScriptParser::SubscriptNode *>(p_subscript->base), true);
Added support for enums to be used as types in GDScript
2020-06-12 02:49:58 +02:00
} else {
reduce_expression(p_subscript->base);
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
GDScriptParser::DataType result_type;
if (p_subscript->is_attribute) {
Reintroduce code completion
2020-07-06 17:24:24 +02:00
if (p_subscript->attribute == nullptr) {
return;
}
Fix subscript of preloaded script
2022-12-11 13:59:43 +01:00
GDScriptParser::DataType base_type = p_subscript->base->get_datatype();
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
bool valid = false;
// If the base is a metatype, use the analyzer instead.
if (p_subscript->base->is_constant && !base_type.is_meta_type) {
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
// Just try to get it.
Refactored variant setters/getters -Discern between named, indexed and keyed -Get direct access to functions for typed GDScript and GDNative bindings -Small changes to some classes in order to work with the new setget binder
2020-11-07 02:29:22 +01:00
Variant value = p_subscript->base->reduced_value.get_named(p_subscript->attribute->name, valid);
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
if (valid) {
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
p_subscript->is_constant = true;
p_subscript->reduced_value = value;
GDScript: Don't try to parse constant scripts that aren't valid Since it's likely that they won't parse correctly.
2020-08-31 14:53:02 +02:00
result_type = type_from_variant(value, p_subscript);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
} else if (base_type.is_variant() || !base_type.is_hard_type()) {
Make global scope enums accessible as types in GDScript Add functions to CoreConstant so enums can be properly deduced. Also add the enums in release builds to make consistent with ClassDB enums and avoid differences in script compilation between debug and release.
2023-02-19 16:57:09 +01:00
valid = !base_type.is_pseudo_type || p_can_be_pseudo_type;
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
result_type.kind = GDScriptParser::DataType::VARIANT;
Make global scope enums accessible as types in GDScript Add functions to CoreConstant so enums can be properly deduced. Also add the enums in release builds to make consistent with ClassDB enums and avoid differences in script compilation between debug and release.
2023-02-19 16:57:09 +01:00
if (base_type.is_variant() && base_type.is_hard_type() && base_type.is_meta_type && base_type.is_pseudo_type) {
// Special case: it may be a global enum with pseudo base (e.g. Variant.Type).
String enum_name;
if (p_subscript->base->type == GDScriptParser::Node::IDENTIFIER) {
enum_name = String(static_cast<GDScriptParser::IdentifierNode *>(p_subscript->base)->name) + ENUM_SEPARATOR + String(p_subscript->attribute->name);
}
if (CoreConstants::is_global_enum(enum_name)) {
result_type = make_global_enum_type(enum_name, StringName());
} else {
valid = false;
mark_node_unsafe(p_subscript);
}
} else {
mark_node_unsafe(p_subscript);
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
} else {
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
reduce_identifier_from_base(p_subscript->attribute, &base_type);
GDScriptParser::DataType attr_type = p_subscript->attribute->get_datatype();
if (attr_type.is_set()) {
Make global scope enums accessible as types in GDScript Add functions to CoreConstant so enums can be properly deduced. Also add the enums in release builds to make consistent with ClassDB enums and avoid differences in script compilation between debug and release.
2023-02-19 16:57:09 +01:00
valid = !attr_type.is_pseudo_type || p_can_be_pseudo_type;
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
result_type = attr_type;
p_subscript->is_constant = p_subscript->attribute->is_constant;
p_subscript->reduced_value = p_subscript->attribute->reduced_value;
Fix autoload subscript regression
2022-12-19 00:36:41 +01:00
} else if (!base_type.is_meta_type || !base_type.is_constant) {
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
valid = base_type.kind != GDScriptParser::DataType::BUILTIN;
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
#ifdef DEBUG_ENABLED
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
if (valid) {
parser->push_warning(p_subscript, GDScriptWarning::UNSAFE_PROPERTY_ACCESS, p_subscript->attribute->name, base_type.to_string());
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
#endif
result_type.kind = GDScriptParser::DataType::VARIANT;
GDScript: Fix marking of line with unsafe property access as unsafe
2023-01-25 00:45:40 +01:00
mark_node_unsafe(p_subscript);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
}
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
if (!valid) {
Make global scope enums accessible as types in GDScript Add functions to CoreConstant so enums can be properly deduced. Also add the enums in release builds to make consistent with ClassDB enums and avoid differences in script compilation between debug and release.
2023-02-19 16:57:09 +01:00
GDScriptParser::DataType attr_type = p_subscript->attribute->get_datatype();
if (!p_can_be_pseudo_type && (attr_type.is_pseudo_type || result_type.is_pseudo_type)) {
push_error(vformat(R"(Type "%s" in base "%s" cannot be used on its own.)", p_subscript->attribute->name, type_from_metatype(base_type).to_string()), p_subscript->attribute);
} else {
push_error(vformat(R"(Cannot find member "%s" in base "%s".)", p_subscript->attribute->name, type_from_metatype(base_type).to_string()), p_subscript->attribute);
}
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
result_type.kind = GDScriptParser::DataType::VARIANT;
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
} else {
GDScript: Fix resolution of dictionary keys There was a mixup between String and StringName keys. Now they're clearly separated. This also means you have to consider which type you're using for the dictionary keys and how you are accessing them.
2021-04-23 20:42:33 +02:00
if (p_subscript->index == nullptr) {
return;
}
reduce_expression(p_subscript->index);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
if (p_subscript->base->is_constant && p_subscript->index->is_constant) {
// Just try to get it.
bool valid = false;
Variant value = p_subscript->base->reduced_value.get(p_subscript->index->reduced_value, &valid);
if (!valid) {
push_error(vformat(R"(Cannot get index "%s" from "%s".)", p_subscript->index->reduced_value, p_subscript->base->reduced_value), p_subscript->index);
GDScript: Fix type for index subscript on constant
2023-01-08 04:41:06 +01:00
result_type.kind = GDScriptParser::DataType::VARIANT;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
} else {
p_subscript->is_constant = true;
p_subscript->reduced_value = value;
GDScript: Don't try to parse constant scripts that aren't valid Since it's likely that they won't parse correctly.
2020-08-31 14:53:02 +02:00
result_type = type_from_variant(value, p_subscript);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
} else {
GDScriptParser::DataType base_type = p_subscript->base->get_datatype();
GDScriptParser::DataType index_type = p_subscript->index->get_datatype();
if (base_type.is_variant()) {
result_type.kind = GDScriptParser::DataType::VARIANT;
mark_node_unsafe(p_subscript);
} else {
if (base_type.kind == GDScriptParser::DataType::BUILTIN && !index_type.is_variant()) {
// Check if indexing is valid.
bool error = index_type.kind != GDScriptParser::DataType::BUILTIN && base_type.builtin_type != Variant::DICTIONARY;
if (!error) {
switch (base_type.builtin_type) {
// Expect int or real as index.
case Variant::PACKED_BYTE_ARRAY:
case Variant::PACKED_COLOR_ARRAY:
case Variant::PACKED_FLOAT32_ARRAY:
case Variant::PACKED_FLOAT64_ARRAY:
case Variant::PACKED_INT32_ARRAY:
case Variant::PACKED_INT64_ARRAY:
case Variant::PACKED_STRING_ARRAY:
case Variant::PACKED_VECTOR2_ARRAY:
case Variant::PACKED_VECTOR3_ARRAY:
case Variant::ARRAY:
case Variant::STRING:
error = index_type.builtin_type != Variant::INT && index_type.builtin_type != Variant::FLOAT;
break;
// Expect String only.
case Variant::RECT2:
case Variant::RECT2I:
case Variant::PLANE:
Rename Quat to Quaternion
2021-01-20 08:02:02 +01:00
case Variant::QUATERNION:
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
case Variant::AABB:
case Variant::OBJECT:
Unify String and StringName
2022-12-06 03:46:47 +01:00
error = index_type.builtin_type != Variant::STRING && index_type.builtin_type != Variant::STRING_NAME;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
break;
// Expect String or number.
case Variant::BASIS:
case Variant::VECTOR2:
case Variant::VECTOR2I:
case Variant::VECTOR3:
case Variant::VECTOR3I:
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
case Variant::VECTOR4:
case Variant::VECTOR4I:
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
case Variant::TRANSFORM2D:
Rename Variant TRANSFORM to TRANSFORM3D Also _transform to _transform3d
2021-04-28 09:36:08 +02:00
case Variant::TRANSFORM3D:
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
case Variant::PROJECTION:
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
error = index_type.builtin_type != Variant::INT && index_type.builtin_type != Variant::FLOAT &&
Unify String and StringName
2022-12-06 03:46:47 +01:00
index_type.builtin_type != Variant::STRING && index_type.builtin_type != Variant::STRING_NAME;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
break;
// Expect String or int.
case Variant::COLOR:
Unify String and StringName
2022-12-06 03:46:47 +01:00
error = index_type.builtin_type != Variant::INT && index_type.builtin_type != Variant::STRING && index_type.builtin_type != Variant::STRING_NAME;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
break;
// Don't support indexing, but we will check it later.
Variant: Rename Type::_RID to Type::RID The underscore prefix was used to avoid the conflict between the `RID` class name and the matching enum value in `Variant::Type`. This can be fixed differently by prefixing uses of the `RID` class in `Variant` with the scope resolution operator, as done already for `AABB`.
2020-11-09 14:53:05 +01:00
case Variant::RID:
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
case Variant::BOOL:
case Variant::CALLABLE:
case Variant::FLOAT:
case Variant::INT:
case Variant::NIL:
case Variant::NODE_PATH:
case Variant::SIGNAL:
case Variant::STRING_NAME:
break;
// Here for completeness.
case Variant::DICTIONARY:
case Variant::VARIANT_MAX:
break;
}
if (error) {
push_error(vformat(R"(Invalid index type "%s" for a base of type "%s".)", index_type.to_string(), base_type.to_string()), p_subscript->index);
}
}
} else if (base_type.kind != GDScriptParser::DataType::BUILTIN && !index_type.is_variant()) {
if (index_type.builtin_type != Variant::STRING && index_type.builtin_type != Variant::STRING_NAME) {
push_error(vformat(R"(Only String or StringName can be used as index for type "%s", but received a "%s".)", base_type.to_string(), index_type.to_string()), p_subscript->index);
}
}
// Check resulting type if possible.
result_type.builtin_type = Variant::NIL;
result_type.kind = GDScriptParser::DataType::BUILTIN;
GDScript: Make subscript access be properly type checked
2020-08-19 19:35:26 +02:00
result_type.type_source = base_type.is_hard_type() ? GDScriptParser::DataType::ANNOTATED_INFERRED : GDScriptParser::DataType::INFERRED;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
GDScript: Allow subscript on self and object types
2021-10-06 17:01:34 +02:00
if (base_type.kind != GDScriptParser::DataType::BUILTIN) {
base_type.builtin_type = Variant::OBJECT;
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
switch (base_type.builtin_type) {
// Can't index at all.
Variant: Rename Type::_RID to Type::RID The underscore prefix was used to avoid the conflict between the `RID` class name and the matching enum value in `Variant::Type`. This can be fixed differently by prefixing uses of the `RID` class in `Variant` with the scope resolution operator, as done already for `AABB`.
2020-11-09 14:53:05 +01:00
case Variant::RID:
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
case Variant::BOOL:
case Variant::CALLABLE:
case Variant::FLOAT:
case Variant::INT:
case Variant::NIL:
case Variant::NODE_PATH:
case Variant::SIGNAL:
case Variant::STRING_NAME:
result_type.kind = GDScriptParser::DataType::VARIANT;
push_error(vformat(R"(Cannot use subscript operator on a base of type "%s".)", base_type.to_string()), p_subscript->base);
break;
// Return int.
case Variant::PACKED_BYTE_ARRAY:
case Variant::PACKED_INT32_ARRAY:
case Variant::PACKED_INT64_ARRAY:
case Variant::VECTOR2I:
case Variant::VECTOR3I:
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
case Variant::VECTOR4I:
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
result_type.builtin_type = Variant::INT;
break;
// Return float.
case Variant::PACKED_FLOAT32_ARRAY:
case Variant::PACKED_FLOAT64_ARRAY:
case Variant::VECTOR2:
case Variant::VECTOR3:
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
case Variant::VECTOR4:
Rename Quat to Quaternion
2021-01-20 08:02:02 +01:00
case Variant::QUATERNION:
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
result_type.builtin_type = Variant::FLOAT;
break;
// Return Color.
case Variant::PACKED_COLOR_ARRAY:
result_type.builtin_type = Variant::COLOR;
break;
// Return String.
case Variant::PACKED_STRING_ARRAY:
case Variant::STRING:
result_type.builtin_type = Variant::STRING;
break;
// Return Vector2.
case Variant::PACKED_VECTOR2_ARRAY:
case Variant::TRANSFORM2D:
case Variant::RECT2:
result_type.builtin_type = Variant::VECTOR2;
break;
// Return Vector2I.
case Variant::RECT2I:
result_type.builtin_type = Variant::VECTOR2I;
break;
// Return Vector3.
case Variant::PACKED_VECTOR3_ARRAY:
case Variant::AABB:
case Variant::BASIS:
result_type.builtin_type = Variant::VECTOR3;
break;
// Depends on the index.
Rename Variant TRANSFORM to TRANSFORM3D Also _transform to _transform3d
2021-04-28 09:36:08 +02:00
case Variant::TRANSFORM3D:
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
case Variant::PROJECTION:
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
case Variant::PLANE:
case Variant::COLOR:
case Variant::DICTIONARY:
GDScript: Allow subscript on self and object types
2021-10-06 17:01:34 +02:00
case Variant::OBJECT:
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
result_type.kind = GDScriptParser::DataType::VARIANT;
result_type.type_source = GDScriptParser::DataType::UNDETECTED;
break;
Add typed arrays to GDScript - Use `Array[type]` for type-hints. e.g.: `var array: Array[int] = [1, 2, 3]` - Array literals are typed if their storage is typed (variable asssignment of as argument in function all). Otherwise they are untyped.
2021-03-09 16:32:35 +01:00
// Can have an element type.
case Variant::ARRAY:
if (base_type.has_container_element_type()) {
result_type = base_type.get_container_element_type();
result_type.type_source = base_type.type_source;
} else {
result_type.kind = GDScriptParser::DataType::VARIANT;
result_type.type_source = GDScriptParser::DataType::UNDETECTED;
}
break;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
// Here for completeness.
case Variant::VARIANT_MAX:
break;
}
}
}
}
p_subscript->set_datatype(result_type);
}
Allow standalone ternary expressions
2023-01-09 15:02:37 +01:00
void GDScriptAnalyzer::reduce_ternary_op(GDScriptParser::TernaryOpNode *p_ternary_op, bool p_is_root) {
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
reduce_expression(p_ternary_op->condition);
Allow standalone ternary expressions
2023-01-09 15:02:37 +01:00
reduce_expression(p_ternary_op->true_expr, p_is_root);
reduce_expression(p_ternary_op->false_expr, p_is_root);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
GDScriptParser::DataType result;
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
if (p_ternary_op->condition && p_ternary_op->condition->is_constant && p_ternary_op->true_expr->is_constant && p_ternary_op->false_expr && p_ternary_op->false_expr->is_constant) {
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
p_ternary_op->is_constant = true;
if (p_ternary_op->condition->reduced_value.booleanize()) {
p_ternary_op->reduced_value = p_ternary_op->true_expr->reduced_value;
} else {
p_ternary_op->reduced_value = p_ternary_op->false_expr->reduced_value;
}
}
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
GDScriptParser::DataType true_type;
if (p_ternary_op->true_expr) {
true_type = p_ternary_op->true_expr->get_datatype();
} else {
true_type.kind = GDScriptParser::DataType::VARIANT;
}
GDScriptParser::DataType false_type;
if (p_ternary_op->false_expr) {
false_type = p_ternary_op->false_expr->get_datatype();
} else {
false_type.kind = GDScriptParser::DataType::VARIANT;
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
if (true_type.is_variant() || false_type.is_variant()) {
result.kind = GDScriptParser::DataType::VARIANT;
} else {
result = true_type;
if (!is_type_compatible(true_type, false_type)) {
result = false_type;
if (!is_type_compatible(false_type, true_type)) {
result.kind = GDScriptParser::DataType::VARIANT;
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
#ifdef DEBUG_ENABLED
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
parser->push_warning(p_ternary_op, GDScriptWarning::INCOMPATIBLE_TERNARY);
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
#endif
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
}
}
GDScript: Fix type certainty for result of ternary operator
2023-02-01 13:52:18 +01:00
result.type_source = true_type.is_hard_type() && false_type.is_hard_type() ? GDScriptParser::DataType::ANNOTATED_INFERRED : GDScriptParser::DataType::INFERRED;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
p_ternary_op->set_datatype(result);
}
GDScript: Rework type check
2023-02-17 00:16:24 +01:00
void GDScriptAnalyzer::reduce_type_test(GDScriptParser::TypeTestNode *p_type_test) {
GDScriptParser::DataType result;
result.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
result.kind = GDScriptParser::DataType::BUILTIN;
result.builtin_type = Variant::BOOL;
p_type_test->set_datatype(result);
if (!p_type_test->operand || !p_type_test->test_type) {
return;
}
reduce_expression(p_type_test->operand);
GDScriptParser::DataType operand_type = p_type_test->operand->get_datatype();
GDScriptParser::DataType test_type = type_from_metatype(resolve_datatype(p_type_test->test_type));
p_type_test->test_datatype = test_type;
if (!operand_type.is_set() || !test_type.is_set()) {
return;
}
if (p_type_test->operand->is_constant) {
p_type_test->is_constant = true;
p_type_test->reduced_value = false;
if (!is_type_compatible(test_type, operand_type)) {
push_error(vformat(R"(Expression is of type "%s" so it can't be of type "%s".)", operand_type.to_string(), test_type.to_string()), p_type_test->operand);
} else if (is_type_compatible(test_type, type_from_variant(p_type_test->operand->reduced_value, p_type_test->operand))) {
p_type_test->reduced_value = test_type.builtin_type != Variant::OBJECT || !p_type_test->operand->reduced_value.is_null();
}
return;
}
if (!is_type_compatible(test_type, operand_type) && !is_type_compatible(operand_type, test_type)) {
if (operand_type.is_hard_type()) {
push_error(vformat(R"(Expression is of type "%s" so it can't be of type "%s".)", operand_type.to_string(), test_type.to_string()), p_type_test->operand);
} else {
downgrade_node_type_source(p_type_test->operand);
}
}
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
void GDScriptAnalyzer::reduce_unary_op(GDScriptParser::UnaryOpNode *p_unary_op) {
reduce_expression(p_unary_op->operand);
GDScriptParser::DataType result;
GDSript: Prevent crash when completing unary operators
2020-08-18 01:49:04 +02:00
if (p_unary_op->operand == nullptr) {
result.kind = GDScriptParser::DataType::VARIANT;
p_unary_op->set_datatype(result);
return;
}
Fixed GDScript crashed when two consecutive unary operators are analysed
2022-12-15 23:15:53 +01:00
GDScriptParser::DataType operand_type = p_unary_op->operand->get_datatype();
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
if (p_unary_op->operand->is_constant) {
p_unary_op->is_constant = true;
p_unary_op->reduced_value = Variant::evaluate(p_unary_op->variant_op, p_unary_op->operand->reduced_value, Variant());
GDScript: Don't try to parse constant scripts that aren't valid Since it's likely that they won't parse correctly.
2020-08-31 14:53:02 +02:00
result = type_from_variant(p_unary_op->reduced_value, p_unary_op);
Fix unary op warnings never showing
2022-10-02 02:13:06 +02:00
}
if (operand_type.is_variant()) {
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
result.kind = GDScriptParser::DataType::VARIANT;
mark_node_unsafe(p_unary_op);
} else {
bool valid = false;
Fix unary op warnings never showing
2022-10-02 02:13:06 +02:00
result = get_operation_type(p_unary_op->variant_op, operand_type, valid, p_unary_op);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
if (!valid) {
Fix unary op warnings never showing
2022-10-02 02:13:06 +02:00
push_error(vformat(R"(Invalid operand of type "%s" for unary operator "%s".)", operand_type.to_string(), Variant::get_operator_name(p_unary_op->variant_op)), p_unary_op);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
}
p_unary_op->set_datatype(result);
}
GDScript: Fix issues with typed arrays
2022-11-27 08:56:53 +01:00
Variant GDScriptAnalyzer::make_expression_reduced_value(GDScriptParser::ExpressionNode *p_expression, bool &is_reduced) {
Variant value;
GDScript: Fix getting reduced value of incomplete subscript
2023-02-02 01:14:25 +01:00
if (p_expression == nullptr) {
return value;
}
GDScript: Fix issues with typed arrays
2022-11-27 08:56:53 +01:00
if (p_expression->is_constant) {
is_reduced = true;
value = p_expression->reduced_value;
} else if (p_expression->type == GDScriptParser::Node::ARRAY) {
value = make_array_reduced_value(static_cast<GDScriptParser::ArrayNode *>(p_expression), is_reduced);
} else if (p_expression->type == GDScriptParser::Node::DICTIONARY) {
value = make_dictionary_reduced_value(static_cast<GDScriptParser::DictionaryNode *>(p_expression), is_reduced);
} else if (p_expression->type == GDScriptParser::Node::SUBSCRIPT) {
value = make_subscript_reduced_value(static_cast<GDScriptParser::SubscriptNode *>(p_expression), is_reduced);
}
return value;
}
Variant GDScriptAnalyzer::make_array_reduced_value(GDScriptParser::ArrayNode *p_array, bool &is_reduced) {
Array array = p_array->get_datatype().has_container_element_type() ? make_array_from_element_datatype(p_array->get_datatype().get_container_element_type()) : Array();
array.resize(p_array->elements.size());
Array/Dictinoary no more reduced to array/dictionary variant Fix: #41377 Fix: #20436 Fix: #41953
2020-09-11 16:16:20 +02:00
for (int i = 0; i < p_array->elements.size(); i++) {
GDScriptParser::ExpressionNode *element = p_array->elements[i];
Fixes GDScript define nested dictionary and array as constants #50285
2022-04-13 20:03:13 +02:00
GDScript: Fix issues with typed arrays
2022-11-27 08:56:53 +01:00
bool is_element_value_reduced = false;
Variant element_value = make_expression_reduced_value(element, is_element_value_reduced);
if (!is_element_value_reduced) {
return Variant();
Fixes GDScript define nested dictionary and array as constants #50285
2022-04-13 20:03:13 +02:00
}
GDScript: Fix issues with typed arrays
2022-11-27 08:56:53 +01:00
array[i] = element_value;
Array/Dictinoary no more reduced to array/dictionary variant Fix: #41377 Fix: #20436 Fix: #41953
2020-09-11 16:16:20 +02:00
}
GDScript: Fix issues with typed arrays
2022-11-27 08:56:53 +01:00
array.make_read_only();
is_reduced = true;
return array;
Array/Dictinoary no more reduced to array/dictionary variant Fix: #41377 Fix: #20436 Fix: #41953
2020-09-11 16:16:20 +02:00
}
GDScript: Fix issues with typed arrays
2022-11-27 08:56:53 +01:00
Variant GDScriptAnalyzer::make_dictionary_reduced_value(GDScriptParser::DictionaryNode *p_dictionary, bool &is_reduced) {
Dictionary dictionary;
Array/Dictinoary no more reduced to array/dictionary variant Fix: #41377 Fix: #20436 Fix: #41953
2020-09-11 16:16:20 +02:00
for (int i = 0; i < p_dictionary->elements.size(); i++) {
const GDScriptParser::DictionaryNode::Pair &element = p_dictionary->elements[i];
Fixes GDScript define nested dictionary and array as constants #50285
2022-04-13 20:03:13 +02:00
GDScript: Fix issues with typed arrays
2022-11-27 08:56:53 +01:00
bool is_element_key_reduced = false;
Variant element_key = make_expression_reduced_value(element.key, is_element_key_reduced);
if (!is_element_key_reduced) {
return Variant();
Fixes GDScript define nested dictionary and array as constants #50285
2022-04-13 20:03:13 +02:00
}
GDScript: Fix issues with typed arrays
2022-11-27 08:56:53 +01:00
bool is_element_value_reduced = false;
Variant element_value = make_expression_reduced_value(element.value, is_element_value_reduced);
if (!is_element_value_reduced) {
return Variant();
Array/Dictinoary no more reduced to array/dictionary variant Fix: #41377 Fix: #20436 Fix: #41953
2020-09-11 16:16:20 +02:00
}
GDScript: Fix issues with typed arrays
2022-11-27 08:56:53 +01:00
dictionary[element_key] = element_value;
Array/Dictinoary no more reduced to array/dictionary variant Fix: #41377 Fix: #20436 Fix: #41953
2020-09-11 16:16:20 +02:00
}
GDScript: Fix issues with typed arrays
2022-11-27 08:56:53 +01:00
dictionary.make_read_only();
is_reduced = true;
return dictionary;
}
Variant GDScriptAnalyzer::make_subscript_reduced_value(GDScriptParser::SubscriptNode *p_subscript, bool &is_reduced) {
GDScript: Fix getting reduced value of incomplete subscript
2023-02-02 01:14:25 +01:00
if (p_subscript->base == nullptr || p_subscript->index == nullptr) {
return Variant();
}
GDScript: Fix issues with typed arrays
2022-11-27 08:56:53 +01:00
bool is_base_value_reduced = false;
Variant base_value = make_expression_reduced_value(p_subscript->base, is_base_value_reduced);
if (!is_base_value_reduced) {
return Variant();
Array/Dictinoary no more reduced to array/dictionary variant Fix: #41377 Fix: #20436 Fix: #41953
2020-09-11 16:16:20 +02:00
}
GDScript: Fix issues with typed arrays
2022-11-27 08:56:53 +01:00
if (p_subscript->is_attribute) {
bool is_valid = false;
Variant value = base_value.get_named(p_subscript->attribute->name, is_valid);
if (is_valid) {
is_reduced = true;
return value;
} else {
return Variant();
}
} else {
bool is_index_value_reduced = false;
Variant index_value = make_expression_reduced_value(p_subscript->index, is_index_value_reduced);
if (!is_index_value_reduced) {
return Variant();
}
bool is_valid = false;
Variant value = base_value.get(index_value, &is_valid);
if (is_valid) {
is_reduced = true;
return value;
} else {
return Variant();
}
GDScript: Begin making constants deep, not shallow or flat
2023-01-08 04:41:06 +01:00
}
GDScript: Fix issues with typed arrays
2022-11-27 08:56:53 +01:00
}
Array GDScriptAnalyzer::make_array_from_element_datatype(const GDScriptParser::DataType &p_element_datatype, const GDScriptParser::Node *p_source_node) {
Array array;
GDScript: Fix error about enum typed arrays
2023-02-08 23:31:40 +01:00
if (p_element_datatype.builtin_type == Variant::OBJECT) {
Ref<Script> script_type = p_element_datatype.script_type;
if (p_element_datatype.kind == GDScriptParser::DataType::CLASS && script_type.is_null()) {
Error err = OK;
Ref<GDScript> scr = GDScriptCache::get_shallow_script(p_element_datatype.script_path, err);
if (err) {
push_error(vformat(R"(Error while getting cache for script "%s".)", p_element_datatype.script_path), p_source_node);
return array;
}
script_type.reference_ptr(scr->find_class(p_element_datatype.class_type->fqcn));
GDScript: Fix issues with typed arrays
2022-11-27 08:56:53 +01:00
}
GDScript: Fix error about enum typed arrays
2023-02-08 23:31:40 +01:00
array.set_typed(p_element_datatype.builtin_type, p_element_datatype.native_type, script_type);
} else {
array.set_typed(p_element_datatype.builtin_type, StringName(), Variant());
}
GDScript: Fix issues with typed arrays
2022-11-27 08:56:53 +01:00
return array;
}
Variant GDScriptAnalyzer::make_variable_default_value(GDScriptParser::VariableNode *p_variable) {
Variant result = Variant();
if (p_variable->initializer) {
bool is_initializer_value_reduced = false;
Variant initializer_value = make_expression_reduced_value(p_variable->initializer, is_initializer_value_reduced);
if (is_initializer_value_reduced) {
result = initializer_value;
}
} else {
GDScriptParser::DataType datatype = p_variable->get_datatype();
GDScript: Fix default value of exported enum variable
2023-02-14 16:07:50 +01:00
if (datatype.is_hard_type()) {
if (datatype.kind == GDScriptParser::DataType::BUILTIN && datatype.builtin_type != Variant::OBJECT) {
if (datatype.builtin_type == Variant::ARRAY && datatype.has_container_element_type()) {
result = make_array_from_element_datatype(datatype.get_container_element_type());
} else {
VariantInternal::initialize(&result, datatype.builtin_type);
}
} else if (datatype.kind == GDScriptParser::DataType::ENUM) {
result = 0;
GDScript: Fix issues with typed arrays
2022-11-27 08:56:53 +01:00
}
}
}
return result;
Array/Dictinoary no more reduced to array/dictionary variant Fix: #41377 Fix: #20436 Fix: #41953
2020-09-11 16:16:20 +02:00
}
Script editor: Show depended script errors
2023-07-24 15:49:39 +02:00
const HashMap<String, Ref<GDScriptParserRef>> &GDScriptAnalyzer::get_depended_parsers() {
return depended_parsers;
}
GDScript: Don't try to parse constant scripts that aren't valid Since it's likely that they won't parse correctly.
2020-08-31 14:53:02 +02:00
GDScriptParser::DataType GDScriptAnalyzer::type_from_variant(const Variant &p_value, const GDScriptParser::Node *p_source) {
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
GDScriptParser::DataType result;
result.is_constant = true;
result.kind = GDScriptParser::DataType::BUILTIN;
result.builtin_type = p_value.get_type();
result.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT; // Constant has explicit type.
Fix: Typed arrays aren't working with +
2023-02-22 22:38:29 +01:00
if (p_value.get_type() == Variant::ARRAY) {
const Array &array = p_value;
if (array.get_typed_script()) {
result.set_container_element_type(type_from_metatype(make_script_meta_type(array.get_typed_script())));
} else if (array.get_typed_class_name()) {
result.set_container_element_type(type_from_metatype(make_native_meta_type(array.get_typed_class_name())));
} else if (array.get_typed_builtin() != Variant::NIL) {
result.set_container_element_type(type_from_metatype(make_builtin_meta_type((Variant::Type)array.get_typed_builtin())));
}
} else if (p_value.get_type() == Variant::OBJECT) {
GDScript: preload should make native type
2022-12-04 11:35:41 +01:00
// Object is treated as a native type, not a builtin type.
result.kind = GDScriptParser::DataType::NATIVE;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
Object *obj = p_value;
if (!obj) {
return GDScriptParser::DataType();
}
result.native_type = obj->get_class_name();
Ref<Script> scr = p_value; // Check if value is a script itself.
if (scr.is_valid()) {
result.is_meta_type = true;
} else {
result.is_meta_type = false;
scr = obj->get_script();
}
if (scr.is_valid()) {
Fix cyclic references in GDScript 2.0
2022-10-09 18:41:28 +02:00
Ref<GDScript> gds = scr;
if (gds.is_valid()) {
// This might be an inner class, so we want to get the parser for the root.
// But still get the inner class from that tree.
GDScript: Fix built-in script and other `find_class` bugs
2022-12-12 13:35:55 +01:00
String script_path = gds->get_script_path();
Ref<GDScriptParserRef> ref = get_parser_for(script_path);
Fix cyclic references in GDScript 2.0
2022-10-09 18:41:28 +02:00
if (ref.is_null()) {
GDScript: Fix built-in script and other `find_class` bugs
2022-12-12 13:35:55 +01:00
push_error(vformat(R"(Could not find script "%s".)", script_path), p_source);
Fix cyclic references in GDScript 2.0
2022-10-09 18:41:28 +02:00
GDScriptParser::DataType error_type;
error_type.kind = GDScriptParser::DataType::VARIANT;
return error_type;
}
GDScript: Fix built-in script and other `find_class` bugs
2022-12-12 13:35:55 +01:00
Error err = ref->raise_status(GDScriptParserRef::INHERITANCE_SOLVED);
GDScriptParser::ClassNode *found = nullptr;
if (err == OK) {
found = ref->get_parser()->find_class(gds->fully_qualified_name);
if (found != nullptr) {
err = resolve_class_inheritance(found, p_source);
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
}
GDScript: Fix built-in script and other `find_class` bugs
2022-12-12 13:35:55 +01:00
}
if (err || found == nullptr) {
push_error(vformat(R"(Could not resolve script "%s".)", script_path), p_source);
GDScriptParser::DataType error_type;
error_type.kind = GDScriptParser::DataType::VARIANT;
return error_type;
Fix cyclic references in GDScript 2.0
2022-10-09 18:41:28 +02:00
}
GDScript: Fix wrong native type for preloaded class
2023-01-03 03:54:51 +01:00
result.kind = GDScriptParser::DataType::CLASS;
result.native_type = found->get_datatype().native_type;
Fix preload type regression
2022-12-15 22:46:15 +01:00
result.class_type = found;
result.script_path = ref->get_parser()->script_path;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
} else {
Fix cyclic references in GDScript 2.0
2022-10-09 18:41:28 +02:00
result.kind = GDScriptParser::DataType::SCRIPT;
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
result.native_type = scr->get_instance_base_type();
GDScript: Fix wrong native type for preloaded class
2023-01-03 03:54:51 +01:00
result.script_path = scr->get_path();
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
result.script_type = scr;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
} else {
result.kind = GDScriptParser::DataType::NATIVE;
if (result.native_type == GDScriptNativeClass::get_class_static()) {
result.is_meta_type = true;
}
}
}
return result;
}
Assorted enum and native type fixes
2022-12-04 04:02:03 +01:00
GDScriptParser::DataType GDScriptAnalyzer::type_from_metatype(const GDScriptParser::DataType &p_meta_type) {
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
GDScriptParser::DataType result = p_meta_type;
result.is_meta_type = false;
Make global scope enums accessible as types in GDScript Add functions to CoreConstant so enums can be properly deduced. Also add the enums in release builds to make consistent with ClassDB enums and avoid differences in script compilation between debug and release.
2023-02-19 16:57:09 +01:00
result.is_pseudo_type = false;
GDScript: Treat enum values as int and enum types as dictionary Since enums resolve to a dictionary at runtime, calling dictionary methods on an enum type is a valid use case. This ensures this is true by adding test cases. This also makes enum values be treated as ints when used in operations.
2022-02-02 17:57:24 +01:00
if (p_meta_type.kind == GDScriptParser::DataType::ENUM) {
result.builtin_type = Variant::INT;
Assorted enum and native type fixes
2022-12-04 04:02:03 +01:00
} else {
result.is_constant = false;
GDScript: Treat enum values as int and enum types as dictionary Since enums resolve to a dictionary at runtime, calling dictionary methods on an enum type is a valid use case. This ensures this is true by adding test cases. This also makes enum values be treated as ints when used in operations.
2022-02-02 17:57:24 +01:00
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
return result;
}
GDScript: Improve usability of setter chains - Consider PackedArrays non-shared since they are copied on C++/script boundaries. - Add error messages in the analyzer when assigning to read-only properties. - Add specific error message at runtime when assignment fails because the property is read-only.
2023-01-30 18:50:08 +01:00
GDScriptParser::DataType GDScriptAnalyzer::type_from_property(const PropertyInfo &p_property, bool p_is_arg, bool p_is_readonly) const {
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
GDScriptParser::DataType result;
GDScript: Improve usability of setter chains - Consider PackedArrays non-shared since they are copied on C++/script boundaries. - Add error messages in the analyzer when assigning to read-only properties. - Add specific error message at runtime when assignment fails because the property is read-only.
2023-01-30 18:50:08 +01:00
result.is_read_only = p_is_readonly;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
result.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
GDScript: Fix getting type from PropertyInfo for Variant arguments
2022-12-27 23:11:51 +01:00
if (p_property.type == Variant::NIL && (p_is_arg || (p_property.usage & PROPERTY_USAGE_NIL_IS_VARIANT))) {
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
// Variant
result.kind = GDScriptParser::DataType::VARIANT;
return result;
}
result.builtin_type = p_property.type;
if (p_property.type == Variant::OBJECT) {
result.kind = GDScriptParser::DataType::NATIVE;
Refactor some object type checking code with `cast_to` Less stringly typed logic, and less String allocations and comparisons.
2022-02-06 14:12:19 +01:00
result.native_type = p_property.class_name == StringName() ? SNAME("Object") : p_property.class_name;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
} else {
result.kind = GDScriptParser::DataType::BUILTIN;
Add typed arrays to GDScript - Use `Array[type]` for type-hints. e.g.: `var array: Array[int] = [1, 2, 3]` - Array literals are typed if their storage is typed (variable asssignment of as argument in function all). Otherwise they are untyped.
2021-03-09 16:32:35 +01:00
result.builtin_type = p_property.type;
if (p_property.type == Variant::ARRAY && p_property.hint == PROPERTY_HINT_ARRAY_TYPE) {
// Check element type.
StringName elem_type_name = p_property.hint_string;
GDScriptParser::DataType elem_type;
elem_type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
Variant::Type elem_builtin_type = GDScriptParser::get_builtin_type(elem_type_name);
if (elem_builtin_type < Variant::VARIANT_MAX) {
// Builtin type.
elem_type.kind = GDScriptParser::DataType::BUILTIN;
elem_type.builtin_type = elem_builtin_type;
} else if (class_exists(elem_type_name)) {
elem_type.kind = GDScriptParser::DataType::NATIVE;
elem_type.builtin_type = Variant::OBJECT;
elem_type.native_type = p_property.hint_string;
} else if (ScriptServer::is_global_class(elem_type_name)) {
// Just load this as it shouldn't be a GDScript.
Ref<Script> script = ResourceLoader::load(ScriptServer::get_global_class_path(elem_type_name));
elem_type.kind = GDScriptParser::DataType::SCRIPT;
elem_type.builtin_type = Variant::OBJECT;
elem_type.native_type = script->get_instance_base_type();
elem_type.script_type = script;
} else {
ERR_FAIL_V_MSG(result, "Could not find element type from property hint of a typed array.");
}
GDScript: Fix inferred typed array marked as constant
2021-10-15 15:40:50 +02:00
elem_type.is_constant = false;
Add typed arrays to GDScript - Use `Array[type]` for type-hints. e.g.: `var array: Array[int] = [1, 2, 3]` - Array literals are typed if their storage is typed (variable asssignment of as argument in function all). Otherwise they are untyped.
2021-03-09 16:32:35 +01:00
result.set_container_element_type(elem_type);
GDScript: Add warnings that are set to error by default - Adds a list of default levels for all warning so they can be set individually. - Add warnings set by default to error for: - Using `get_node()` without `@onready`. - Using `@onready` together with `@export`. - Inferring a static type with a Variant value. - Overriding a native engine method. - Adjust how annotations to ignore warnings are treated so they also apply to method parameters. - Clean up a bit how ignored warnings are set. There were two sets but only one was actually being used. - Set all warnings to the `WARN` level for tests, so they they can be properly tested. - Fix enum types in native methods signatures being set to `int`. - Fix native enums being treated as Dictionary by mistake. - Make name of native enum types use the class they are defined in, not the direct super class of the script. This ensures they are always equal even when coming from different sources. - Fix error for signature mismatch that was only showing the first default argument as having a default. Now it shows for all.
2023-02-02 15:57:22 +01:00
} else if (p_property.type == Variant::INT) {
// Check if it's enum.
GDScript: Misc fixes and improvements for signature generation * Use type hints for `@GlobalScope` enums. * Use plain `int` for `BitMask<T>`. * Fix type hints for typed arrays. * Use `Variant` and `void` type hints. * Discard unnecessary class prefix.
2023-04-05 16:46:22 +02:00
if ((p_property.usage & PROPERTY_USAGE_CLASS_IS_ENUM) && p_property.class_name != StringName()) {
Make global scope enums accessible as types in GDScript Add functions to CoreConstant so enums can be properly deduced. Also add the enums in release builds to make consistent with ClassDB enums and avoid differences in script compilation between debug and release.
2023-02-19 16:57:09 +01:00
if (CoreConstants::is_global_enum(p_property.class_name)) {
result = make_global_enum_type(p_property.class_name, StringName(), false);
GDScript: Add warnings that are set to error by default - Adds a list of default levels for all warning so they can be set individually. - Add warnings set by default to error for: - Using `get_node()` without `@onready`. - Using `@onready` together with `@export`. - Inferring a static type with a Variant value. - Overriding a native engine method. - Adjust how annotations to ignore warnings are treated so they also apply to method parameters. - Clean up a bit how ignored warnings are set. There were two sets but only one was actually being used. - Set all warnings to the `WARN` level for tests, so they they can be properly tested. - Fix enum types in native methods signatures being set to `int`. - Fix native enums being treated as Dictionary by mistake. - Make name of native enum types use the class they are defined in, not the direct super class of the script. This ensures they are always equal even when coming from different sources. - Fix error for signature mismatch that was only showing the first default argument as having a default. Now it shows for all.
2023-02-02 15:57:22 +01:00
result.is_constant = false;
Make global scope enums accessible as types in GDScript Add functions to CoreConstant so enums can be properly deduced. Also add the enums in release builds to make consistent with ClassDB enums and avoid differences in script compilation between debug and release.
2023-02-19 16:57:09 +01:00
} else {
Vector<String> names = String(p_property.class_name).split(ENUM_SEPARATOR);
if (names.size() == 2) {
result = make_native_enum_type(names[1], names[0], false);
result.is_constant = false;
}
GDScript: Add warnings that are set to error by default - Adds a list of default levels for all warning so they can be set individually. - Add warnings set by default to error for: - Using `get_node()` without `@onready`. - Using `@onready` together with `@export`. - Inferring a static type with a Variant value. - Overriding a native engine method. - Adjust how annotations to ignore warnings are treated so they also apply to method parameters. - Clean up a bit how ignored warnings are set. There were two sets but only one was actually being used. - Set all warnings to the `WARN` level for tests, so they they can be properly tested. - Fix enum types in native methods signatures being set to `int`. - Fix native enums being treated as Dictionary by mistake. - Make name of native enum types use the class they are defined in, not the direct super class of the script. This ensures they are always equal even when coming from different sources. - Fix error for signature mismatch that was only showing the first default argument as having a default. Now it shows for all.
2023-02-02 15:57:22 +01:00
}
}
GDScript: Misc fixes and improvements for signature generation * Use type hints for `@GlobalScope` enums. * Use plain `int` for `BitMask<T>`. * Fix type hints for typed arrays. * Use `Variant` and `void` type hints. * Discard unnecessary class prefix.
2023-04-05 16:46:22 +02:00
// PROPERTY_USAGE_CLASS_IS_BITFIELD: BitField[T] isn't supported (yet?), use plain int.
Add typed arrays to GDScript - Use `Array[type]` for type-hints. e.g.: `var array: Array[int] = [1, 2, 3]` - Array literals are typed if their storage is typed (variable asssignment of as argument in function all). Otherwise they are untyped.
2021-03-09 16:32:35 +01:00
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
return result;
}
GDScript: add errors when calling unimplemented virtual functions This PR does a small refactor of how method flags are handled in the GDScript analyzer. This way, it adds support for the analyzer to use any of MethodInfo's flags, where previously it could only use METHOD_FLAG_STATIC and METHOD_FLAG_VARARG. As a side-effect, this also normalizes behavior between editor and release templates, which fixes #76938. The tests added also brought a different issue to light, where using `super()` appears to generate a return variable discarded on calling super's _init(), which doesn't have a return value. This should be tackled in a different PR, which will have to change the output of this PR's tests.
2023-05-22 01:22:00 +02:00
bool GDScriptAnalyzer::get_function_signature(GDScriptParser::Node *p_source, bool p_is_constructor, GDScriptParser::DataType p_base_type, const StringName &p_function, GDScriptParser::DataType &r_return_type, List<GDScriptParser::DataType> &r_par_types, int &r_default_arg_count, BitField<MethodFlags> &r_method_flags, StringName *r_native_class) {
r_method_flags = METHOD_FLAGS_DEFAULT;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
r_default_arg_count = 0;
GDScript: Add warnings that are set to error by default - Adds a list of default levels for all warning so they can be set individually. - Add warnings set by default to error for: - Using `get_node()` without `@onready`. - Using `@onready` together with `@export`. - Inferring a static type with a Variant value. - Overriding a native engine method. - Adjust how annotations to ignore warnings are treated so they also apply to method parameters. - Clean up a bit how ignored warnings are set. There were two sets but only one was actually being used. - Set all warnings to the `WARN` level for tests, so they they can be properly tested. - Fix enum types in native methods signatures being set to `int`. - Fix native enums being treated as Dictionary by mistake. - Make name of native enum types use the class they are defined in, not the direct super class of the script. This ensures they are always equal even when coming from different sources. - Fix error for signature mismatch that was only showing the first default argument as having a default. Now it shows for all.
2023-02-02 15:57:22 +01:00
if (r_native_class) {
*r_native_class = StringName();
}
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
StringName function_name = p_function;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
Assorted enum and native type fixes
2022-12-04 04:02:03 +01:00
bool was_enum = false;
GDScript: Treat enum values as int and enum types as dictionary Since enums resolve to a dictionary at runtime, calling dictionary methods on an enum type is a valid use case. This ensures this is true by adding test cases. This also makes enum values be treated as ints when used in operations.
2022-02-02 17:57:24 +01:00
if (p_base_type.kind == GDScriptParser::DataType::ENUM) {
Assorted enum and native type fixes
2022-12-04 04:02:03 +01:00
was_enum = true;
GDScript: Treat enum values as int and enum types as dictionary Since enums resolve to a dictionary at runtime, calling dictionary methods on an enum type is a valid use case. This ensures this is true by adding test cases. This also makes enum values be treated as ints when used in operations.
2022-02-02 17:57:24 +01:00
if (p_base_type.is_meta_type) {
// Enum type can be treated as a dictionary value.
p_base_type.kind = GDScriptParser::DataType::BUILTIN;
p_base_type.is_meta_type = false;
} else {
push_error("Cannot call function on enum value.", p_source);
return false;
}
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
if (p_base_type.kind == GDScriptParser::DataType::BUILTIN) {
// Construct a base type to get methods.
Callable::CallError err;
Refactored variant constructor logic
2020-11-09 04:19:09 +01:00
Variant dummy;
Variant::construct(p_base_type.builtin_type, dummy, nullptr, 0, err);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
if (err.error != Callable::CallError::CALL_OK) {
ERR_FAIL_V_MSG(false, "Could not construct base Variant type.");
}
List<MethodInfo> methods;
dummy.get_method_list(&methods);
Use C++ iterators for Lists in many situations
2021-07-16 05:45:57 +02:00
for (const MethodInfo &E : methods) {
if (E.name == p_function) {
GDScript: add errors when calling unimplemented virtual functions This PR does a small refactor of how method flags are handled in the GDScript analyzer. This way, it adds support for the analyzer to use any of MethodInfo's flags, where previously it could only use METHOD_FLAG_STATIC and METHOD_FLAG_VARARG. As a side-effect, this also normalizes behavior between editor and release templates, which fixes #76938. The tests added also brought a different issue to light, where using `super()` appears to generate a return variable discarded on calling super's _init(), which doesn't have a return value. This should be tackled in a different PR, which will have to change the output of this PR's tests.
2023-05-22 01:22:00 +02:00
function_signature_from_info(E, r_return_type, r_par_types, r_default_arg_count, r_method_flags);
Assorted enum and native type fixes
2022-12-04 04:02:03 +01:00
// Cannot use non-const methods on enums.
GDScript: add errors when calling unimplemented virtual functions This PR does a small refactor of how method flags are handled in the GDScript analyzer. This way, it adds support for the analyzer to use any of MethodInfo's flags, where previously it could only use METHOD_FLAG_STATIC and METHOD_FLAG_VARARG. As a side-effect, this also normalizes behavior between editor and release templates, which fixes #76938. The tests added also brought a different issue to light, where using `super()` appears to generate a return variable discarded on calling super's _init(), which doesn't have a return value. This should be tackled in a different PR, which will have to change the output of this PR's tests.
2023-05-22 01:22:00 +02:00
if (!r_method_flags.has_flag(METHOD_FLAG_STATIC) && was_enum && !(E.flags & METHOD_FLAG_CONST)) {
Assorted enum and native type fixes
2022-12-04 04:02:03 +01:00
push_error(vformat(R"*(Cannot call non-const Dictionary function "%s()" on enum "%s".)*", p_function, p_base_type.enum_type), p_source);
}
GDScript: Fix calling builtin static functions
2021-06-03 14:51:51 +02:00
return true;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
}
return false;
}
GDScript: Fix extending abstract classes, forbid their construction
2022-12-29 08:34:13 +01:00
StringName base_native = p_base_type.native_type;
if (base_native != StringName()) {
// Empty native class might happen in some Script implementations.
// Just ignore it.
if (!class_exists(base_native)) {
push_error(vformat("Native class %s used in script doesn't exist or isn't exposed.", base_native), p_source);
return false;
} else if (p_is_constructor && !ClassDB::can_instantiate(base_native)) {
if (p_base_type.kind == GDScriptParser::DataType::CLASS) {
push_error(vformat(R"(Class "%s" cannot be constructed as it is based on abstract native class "%s".)", p_base_type.class_type->fqcn.get_file(), base_native), p_source);
} else if (p_base_type.kind == GDScriptParser::DataType::SCRIPT) {
push_error(vformat(R"(Script "%s" cannot be constructed as it is based on abstract native class "%s".)", p_base_type.script_path.get_file(), base_native), p_source);
} else {
push_error(vformat(R"(Native class "%s" cannot be constructed as it is abstract.)", base_native), p_source);
}
return false;
}
}
GDScript: Check if method signature matches the parent To guarantee polymorphism, a method signature must be compatible with the parent. This checks if: 1. Return type is the same. 2. The subclass method takes at least the same amount of parameters. 3. The matching parameters have the same type. 4. If the subclass takes more parameters, all of the extra ones have a default value. 5. If the superclass has default values, so must have the subclass. There's a few test cases to ensure this holds up.
2022-03-06 15:09:12 +01:00
if (p_is_constructor) {
GDScript: do not warn of return value discarded for super() inside _init() DO NOT BATCH MERGE WITH #77324, WILL RESULT IN BROKEN CI Currently, calling super() inside _init() throws a RETURN_VALUE_DISCARDED warning. The analyzer identifies super() as being a constructor, which therefore returns an object of the relevant class. However, super() isn't really a constructor by itself: in this case, it is _part_ of the constructor, and so doesn't "return" a value. A test case for this is already in #77324, which contains the warning. I am duplicating it here, without the warning, and it should conflict with the other PR.
2023-05-22 15:21:25 +02:00
function_name = GDScriptLanguage::get_singleton()->strings._init;
GDScript: add errors when calling unimplemented virtual functions This PR does a small refactor of how method flags are handled in the GDScript analyzer. This way, it adds support for the analyzer to use any of MethodInfo's flags, where previously it could only use METHOD_FLAG_STATIC and METHOD_FLAG_VARARG. As a side-effect, this also normalizes behavior between editor and release templates, which fixes #76938. The tests added also brought a different issue to light, where using `super()` appears to generate a return variable discarded on calling super's _init(), which doesn't have a return value. This should be tackled in a different PR, which will have to change the output of this PR's tests.
2023-05-22 01:22:00 +02:00
r_method_flags.set_flag(METHOD_FLAG_STATIC);
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
GDScriptParser::ClassNode *base_class = p_base_type.class_type;
GDScriptParser::FunctionNode *found_function = nullptr;
while (found_function == nullptr && base_class != nullptr) {
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
if (base_class->has_member(function_name)) {
if (base_class->get_member(function_name).type != GDScriptParser::ClassNode::Member::FUNCTION) {
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
// TODO: If this is Callable it can have a better error message.
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
push_error(vformat(R"(Member "%s" is not a function.)", function_name), p_source);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
return false;
}
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
resolve_class_member(base_class, function_name, p_source);
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
found_function = base_class->get_member(function_name).function;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
resolve_class_inheritance(base_class, p_source);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
base_class = base_class->base_type.class_type;
}
if (found_function != nullptr) {
GDScript: add errors when calling unimplemented virtual functions This PR does a small refactor of how method flags are handled in the GDScript analyzer. This way, it adds support for the analyzer to use any of MethodInfo's flags, where previously it could only use METHOD_FLAG_STATIC and METHOD_FLAG_VARARG. As a side-effect, this also normalizes behavior between editor and release templates, which fixes #76938. The tests added also brought a different issue to light, where using `super()` appears to generate a return variable discarded on calling super's _init(), which doesn't have a return value. This should be tackled in a different PR, which will have to change the output of this PR's tests.
2023-05-22 01:22:00 +02:00
if (p_is_constructor || found_function->is_static) {
r_method_flags.set_flag(METHOD_FLAG_STATIC);
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
for (int i = 0; i < found_function->parameters.size(); i++) {
r_par_types.push_back(found_function->parameters[i]->get_datatype());
Unify typing of variables, constants and parameters in GDScript
2022-12-22 21:43:36 +01:00
if (found_function->parameters[i]->initializer != nullptr) {
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
r_default_arg_count++;
}
}
GDScript: Fix return type of constructor call for extending class
2022-12-27 21:49:26 +01:00
r_return_type = p_is_constructor ? p_base_type : found_function->get_datatype();
GDScript: Fix inner classes and preloaded scripts as types
2021-05-26 14:23:17 +02:00
r_return_type.is_meta_type = false;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
r_return_type.is_coroutine = found_function->is_coroutine;
return true;
}
Ref<Script> base_script = p_base_type.script_type;
Add GDScript resource export.
2022-04-25 06:33:18 +02:00
while (base_script.is_valid() && base_script->has_method(function_name)) {
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
MethodInfo info = base_script->get_method_info(function_name);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
if (!(info == MethodInfo())) {
GDScript: add errors when calling unimplemented virtual functions This PR does a small refactor of how method flags are handled in the GDScript analyzer. This way, it adds support for the analyzer to use any of MethodInfo's flags, where previously it could only use METHOD_FLAG_STATIC and METHOD_FLAG_VARARG. As a side-effect, this also normalizes behavior between editor and release templates, which fixes #76938. The tests added also brought a different issue to light, where using `super()` appears to generate a return variable discarded on calling super's _init(), which doesn't have a return value. This should be tackled in a different PR, which will have to change the output of this PR's tests.
2023-05-22 01:22:00 +02:00
return function_signature_from_info(info, r_return_type, r_par_types, r_default_arg_count, r_method_flags);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
base_script = base_script->get_base_script();
}
// If the base is a script, it might be trying to access members of the Script class itself.
GDScript: Check if method signature matches the parent To guarantee polymorphism, a method signature must be compatible with the parent. This checks if: 1. Return type is the same. 2. The subclass method takes at least the same amount of parameters. 3. The matching parameters have the same type. 4. If the subclass takes more parameters, all of the extra ones have a default value. 5. If the superclass has default values, so must have the subclass. There's a few test cases to ensure this holds up.
2022-03-06 15:09:12 +01:00
if (p_base_type.is_meta_type && !p_is_constructor && (p_base_type.kind == GDScriptParser::DataType::SCRIPT || p_base_type.kind == GDScriptParser::DataType::CLASS)) {
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
MethodInfo info;
StringName script_class = p_base_type.kind == GDScriptParser::DataType::SCRIPT ? p_base_type.script_type->get_class_name() : StringName(GDScript::get_class_static());
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
if (ClassDB::get_method_info(script_class, function_name, &info)) {
GDScript: add errors when calling unimplemented virtual functions This PR does a small refactor of how method flags are handled in the GDScript analyzer. This way, it adds support for the analyzer to use any of MethodInfo's flags, where previously it could only use METHOD_FLAG_STATIC and METHOD_FLAG_VARARG. As a side-effect, this also normalizes behavior between editor and release templates, which fixes #76938. The tests added also brought a different issue to light, where using `super()` appears to generate a return variable discarded on calling super's _init(), which doesn't have a return value. This should be tackled in a different PR, which will have to change the output of this PR's tests.
2023-05-22 01:22:00 +02:00
return function_signature_from_info(info, r_return_type, r_par_types, r_default_arg_count, r_method_flags);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
}
GDScript: Check if method signature matches the parent To guarantee polymorphism, a method signature must be compatible with the parent. This checks if: 1. Return type is the same. 2. The subclass method takes at least the same amount of parameters. 3. The matching parameters have the same type. 4. If the subclass takes more parameters, all of the extra ones have a default value. 5. If the superclass has default values, so must have the subclass. There's a few test cases to ensure this holds up.
2022-03-06 15:09:12 +01:00
if (p_is_constructor) {
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
// Native types always have a default constructor.
r_return_type = p_base_type;
r_return_type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
r_return_type.is_meta_type = false;
return true;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
MethodInfo info;
Remove underscore hacks Way less cruft. :) Co-authored-by: Ignacio Roldán Etcheverry <neikeq@users.noreply.github.com>
2021-08-17 15:06:54 +02:00
if (ClassDB::get_method_info(base_native, function_name, &info)) {
GDScript: add errors when calling unimplemented virtual functions This PR does a small refactor of how method flags are handled in the GDScript analyzer. This way, it adds support for the analyzer to use any of MethodInfo's flags, where previously it could only use METHOD_FLAG_STATIC and METHOD_FLAG_VARARG. As a side-effect, this also normalizes behavior between editor and release templates, which fixes #76938. The tests added also brought a different issue to light, where using `super()` appears to generate a return variable discarded on calling super's _init(), which doesn't have a return value. This should be tackled in a different PR, which will have to change the output of this PR's tests.
2023-05-22 01:22:00 +02:00
bool valid = function_signature_from_info(info, r_return_type, r_par_types, r_default_arg_count, r_method_flags);
GDScript: Make singleton functions be seen as static Since those can be called without an instance.
2021-08-20 15:52:58 +02:00
if (valid && Engine::get_singleton()->has_singleton(base_native)) {
GDScript: add errors when calling unimplemented virtual functions This PR does a small refactor of how method flags are handled in the GDScript analyzer. This way, it adds support for the analyzer to use any of MethodInfo's flags, where previously it could only use METHOD_FLAG_STATIC and METHOD_FLAG_VARARG. As a side-effect, this also normalizes behavior between editor and release templates, which fixes #76938. The tests added also brought a different issue to light, where using `super()` appears to generate a return variable discarded on calling super's _init(), which doesn't have a return value. This should be tackled in a different PR, which will have to change the output of this PR's tests.
2023-05-22 01:22:00 +02:00
r_method_flags.set_flag(METHOD_FLAG_STATIC);
GDScript: Make singleton functions be seen as static Since those can be called without an instance.
2021-08-20 15:52:58 +02:00
}
GDScript: Add warnings that are set to error by default - Adds a list of default levels for all warning so they can be set individually. - Add warnings set by default to error for: - Using `get_node()` without `@onready`. - Using `@onready` together with `@export`. - Inferring a static type with a Variant value. - Overriding a native engine method. - Adjust how annotations to ignore warnings are treated so they also apply to method parameters. - Clean up a bit how ignored warnings are set. There were two sets but only one was actually being used. - Set all warnings to the `WARN` level for tests, so they they can be properly tested. - Fix enum types in native methods signatures being set to `int`. - Fix native enums being treated as Dictionary by mistake. - Make name of native enum types use the class they are defined in, not the direct super class of the script. This ensures they are always equal even when coming from different sources. - Fix error for signature mismatch that was only showing the first default argument as having a default. Now it shows for all.
2023-02-02 15:57:22 +01:00
#ifdef DEBUG_ENABLED
MethodBind *native_method = ClassDB::get_method(base_native, function_name);
if (native_method && r_native_class) {
*r_native_class = native_method->get_instance_class();
}
#endif
GDScript: Make singleton functions be seen as static Since those can be called without an instance.
2021-08-20 15:52:58 +02:00
return valid;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
return false;
}
GDScript: add errors when calling unimplemented virtual functions This PR does a small refactor of how method flags are handled in the GDScript analyzer. This way, it adds support for the analyzer to use any of MethodInfo's flags, where previously it could only use METHOD_FLAG_STATIC and METHOD_FLAG_VARARG. As a side-effect, this also normalizes behavior between editor and release templates, which fixes #76938. The tests added also brought a different issue to light, where using `super()` appears to generate a return variable discarded on calling super's _init(), which doesn't have a return value. This should be tackled in a different PR, which will have to change the output of this PR's tests.
2023-05-22 01:22:00 +02:00
bool GDScriptAnalyzer::function_signature_from_info(const MethodInfo &p_info, GDScriptParser::DataType &r_return_type, List<GDScriptParser::DataType> &r_par_types, int &r_default_arg_count, BitField<MethodFlags> &r_method_flags) {
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
r_return_type = type_from_property(p_info.return_val);
r_default_arg_count = p_info.default_arguments.size();
GDScript: add errors when calling unimplemented virtual functions This PR does a small refactor of how method flags are handled in the GDScript analyzer. This way, it adds support for the analyzer to use any of MethodInfo's flags, where previously it could only use METHOD_FLAG_STATIC and METHOD_FLAG_VARARG. As a side-effect, this also normalizes behavior between editor and release templates, which fixes #76938. The tests added also brought a different issue to light, where using `super()` appears to generate a return variable discarded on calling super's _init(), which doesn't have a return value. This should be tackled in a different PR, which will have to change the output of this PR's tests.
2023-05-22 01:22:00 +02:00
r_method_flags = p_info.flags;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
Use C++ iterators for Lists in many situations
2021-07-16 05:45:57 +02:00
for (const PropertyInfo &E : p_info.arguments) {
GDScript: Fix getting type from PropertyInfo for Variant arguments
2022-12-27 23:11:51 +01:00
r_par_types.push_back(type_from_property(E, true));
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
return true;
}
GDScript: Fix constant conversions
2023-01-22 09:32:05 +01:00
void GDScriptAnalyzer::validate_call_arg(const MethodInfo &p_method, const GDScriptParser::CallNode *p_call) {
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
List<GDScriptParser::DataType> arg_types;
Use C++ iterators for Lists in many situations
2021-07-16 05:45:57 +02:00
for (const PropertyInfo &E : p_method.arguments) {
GDScript: Fix getting type from PropertyInfo for Variant arguments
2022-12-27 23:11:51 +01:00
arg_types.push_back(type_from_property(E, true));
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
GDScript: Fix constant conversions
2023-01-22 09:32:05 +01:00
validate_call_arg(arg_types, p_method.default_arguments.size(), (p_method.flags & METHOD_FLAG_VARARG) != 0, p_call);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
GDScript: Fix constant conversions
2023-01-22 09:32:05 +01:00
void GDScriptAnalyzer::validate_call_arg(const List<GDScriptParser::DataType> &p_par_types, int p_default_args_count, bool p_is_vararg, const GDScriptParser::CallNode *p_call) {
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
if (p_call->arguments.size() < p_par_types.size() - p_default_args_count) {
push_error(vformat(R"*(Too few arguments for "%s()" call. Expected at least %d but received %d.)*", p_call->function_name, p_par_types.size() - p_default_args_count, p_call->arguments.size()), p_call);
}
if (!p_is_vararg && p_call->arguments.size() > p_par_types.size()) {
push_error(vformat(R"*(Too many arguments for "%s()" call. Expected at most %d but received %d.)*", p_call->function_name, p_par_types.size(), p_call->arguments.size()), p_call->arguments[p_par_types.size()]);
}
for (int i = 0; i < p_call->arguments.size(); i++) {
if (i >= p_par_types.size()) {
// Already on vararg place.
break;
}
GDScriptParser::DataType par_type = p_par_types[i];
GDScript: Fix constant conversions
2023-01-22 09:32:05 +01:00
if (par_type.is_hard_type() && p_call->arguments[i]->is_constant) {
update_const_expression_builtin_type(p_call->arguments[i], par_type, "pass");
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
GDScriptParser::DataType arg_type = p_call->arguments[i]->get_datatype();
GDScript: Fix `validate_call_arg()` for unresolved datatype
2023-05-15 10:17:53 +02:00
if (arg_type.is_variant() || !arg_type.is_hard_type()) {
// Argument can be anything, so this is unsafe (unless the parameter is a hard variant).
if (!(par_type.is_hard_type() && par_type.is_variant())) {
mark_node_unsafe(p_call->arguments[i]);
}
GDScript: parameter infer type bug fix Fix: #41772
2020-09-06 09:56:52 +02:00
} else if (par_type.is_hard_type() && !is_type_compatible(par_type, arg_type, true)) {
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
// Supertypes are acceptable for dynamic compliance, but it's unsafe.
mark_node_unsafe(p_call);
if (!is_type_compatible(arg_type, par_type)) {
Assorted enum and native type fixes
2022-12-04 04:02:03 +01:00
push_error(vformat(R"*(Invalid argument for "%s()" function: argument %d should be "%s" but is "%s".)*",
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
p_call->function_name, i + 1, par_type.to_string(), arg_type.to_string()),
p_call->arguments[i]);
}
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
#ifdef DEBUG_ENABLED
GDScript: Fix constant conversions
2023-01-22 09:32:05 +01:00
} else if (par_type.kind == GDScriptParser::DataType::BUILTIN && par_type.builtin_type == Variant::INT && arg_type.kind == GDScriptParser::DataType::BUILTIN && arg_type.builtin_type == Variant::FLOAT) {
parser->push_warning(p_call, GDScriptWarning::NARROWING_CONVERSION, p_call->function_name);
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
#endif
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
}
}
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
#ifdef DEBUG_ENABLED
Fix for not being able to ignore shadowing warnings on class scope
2023-04-03 15:57:41 +02:00
void GDScriptAnalyzer::is_shadowing(GDScriptParser::IdentifierNode *p_identifier, const String &p_context, const bool p_in_local_scope) {
const StringName &name = p_identifier->name;
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
GDScriptParser::DataType base = parser->current_class->get_datatype();
GDScriptParser::ClassNode *base_class = base.class_type;
Fix shadowed global identifier warning duplication
2021-12-13 09:39:16 +01:00
{
List<MethodInfo> gdscript_funcs;
GDScriptLanguage::get_singleton()->get_public_functions(&gdscript_funcs);
for (MethodInfo &info : gdscript_funcs) {
if (info.name == name) {
Fix for not being able to ignore shadowing warnings on class scope
2023-04-03 15:57:41 +02:00
parser->push_warning(p_identifier, GDScriptWarning::SHADOWED_GLOBAL_IDENTIFIER, p_context, name, "built-in function");
GDScript: Fix missing warning for shadowing of built-in types
2023-03-08 21:06:29 +01:00
return;
Fix shadowed global identifier warning duplication
2021-12-13 09:39:16 +01:00
}
}
if (Variant::has_utility_function(name)) {
Fix for not being able to ignore shadowing warnings on class scope
2023-04-03 15:57:41 +02:00
parser->push_warning(p_identifier, GDScriptWarning::SHADOWED_GLOBAL_IDENTIFIER, p_context, name, "built-in function");
GDScript: Fix missing warning for shadowing of built-in types
2023-03-08 21:06:29 +01:00
return;
Fix shadowed global identifier warning duplication
2021-12-13 09:39:16 +01:00
} else if (ClassDB::class_exists(name)) {
Fix for not being able to ignore shadowing warnings on class scope
2023-04-03 15:57:41 +02:00
parser->push_warning(p_identifier, GDScriptWarning::SHADOWED_GLOBAL_IDENTIFIER, p_context, name, "global class");
GDScript: Fix missing warning for shadowing of built-in types
2023-03-08 21:06:29 +01:00
return;
} else if (GDScriptParser::get_builtin_type(name) != Variant::VARIANT_MAX) {
Fix for not being able to ignore shadowing warnings on class scope
2023-04-03 15:57:41 +02:00
parser->push_warning(p_identifier, GDScriptWarning::SHADOWED_GLOBAL_IDENTIFIER, p_context, name, "built-in type");
GDScript: Fix missing warning for shadowing of built-in types
2023-03-08 21:06:29 +01:00
return;
Fix shadowed global identifier warning duplication
2021-12-13 09:39:16 +01:00
}
}
Fix for not being able to ignore shadowing warnings on class scope
2023-04-03 15:57:41 +02:00
if (p_in_local_scope) {
while (base_class != nullptr) {
if (base_class->has_member(name)) {
parser->push_warning(p_identifier, GDScriptWarning::SHADOWED_VARIABLE, p_context, p_identifier->name, base_class->get_member(name).get_type_name(), itos(base_class->get_member(name).get_line()));
return;
}
base_class = base_class->base_type.class_type;
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
}
}
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
StringName parent = base.native_type;
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
while (parent != StringName()) {
GDScript: Fix missing warning for shadowing of built-in types
2023-03-08 21:06:29 +01:00
ERR_FAIL_COND_MSG(!class_exists(parent), "Non-existent native base class.");
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
Remove underscore hacks Way less cruft. :) Co-authored-by: Ignacio Roldán Etcheverry <neikeq@users.noreply.github.com>
2021-08-17 15:06:54 +02:00
if (ClassDB::has_method(parent, name, true)) {
Fix for not being able to ignore shadowing warnings on class scope
2023-04-03 15:57:41 +02:00
parser->push_warning(p_identifier, GDScriptWarning::SHADOWED_VARIABLE_BASE_CLASS, p_context, p_identifier->name, "method", parent);
GDScript: Fix missing warning for shadowing of built-in types
2023-03-08 21:06:29 +01:00
return;
Remove underscore hacks Way less cruft. :) Co-authored-by: Ignacio Roldán Etcheverry <neikeq@users.noreply.github.com>
2021-08-17 15:06:54 +02:00
} else if (ClassDB::has_signal(parent, name, true)) {
Fix for not being able to ignore shadowing warnings on class scope
2023-04-03 15:57:41 +02:00
parser->push_warning(p_identifier, GDScriptWarning::SHADOWED_VARIABLE_BASE_CLASS, p_context, p_identifier->name, "signal", parent);
GDScript: Fix missing warning for shadowing of built-in types
2023-03-08 21:06:29 +01:00
return;
Remove underscore hacks Way less cruft. :) Co-authored-by: Ignacio Roldán Etcheverry <neikeq@users.noreply.github.com>
2021-08-17 15:06:54 +02:00
} else if (ClassDB::has_property(parent, name, true)) {
Fix for not being able to ignore shadowing warnings on class scope
2023-04-03 15:57:41 +02:00
parser->push_warning(p_identifier, GDScriptWarning::SHADOWED_VARIABLE_BASE_CLASS, p_context, p_identifier->name, "property", parent);
GDScript: Fix missing warning for shadowing of built-in types
2023-03-08 21:06:29 +01:00
return;
Remove underscore hacks Way less cruft. :) Co-authored-by: Ignacio Roldán Etcheverry <neikeq@users.noreply.github.com>
2021-08-17 15:06:54 +02:00
} else if (ClassDB::has_integer_constant(parent, name, true)) {
Fix for not being able to ignore shadowing warnings on class scope
2023-04-03 15:57:41 +02:00
parser->push_warning(p_identifier, GDScriptWarning::SHADOWED_VARIABLE_BASE_CLASS, p_context, p_identifier->name, "constant", parent);
GDScript: Fix missing warning for shadowing of built-in types
2023-03-08 21:06:29 +01:00
return;
Remove underscore hacks Way less cruft. :) Co-authored-by: Ignacio Roldán Etcheverry <neikeq@users.noreply.github.com>
2021-08-17 15:06:54 +02:00
} else if (ClassDB::has_enum(parent, name, true)) {
Fix for not being able to ignore shadowing warnings on class scope
2023-04-03 15:57:41 +02:00
parser->push_warning(p_identifier, GDScriptWarning::SHADOWED_VARIABLE_BASE_CLASS, p_context, p_identifier->name, "enum", parent);
GDScript: Fix missing warning for shadowing of built-in types
2023-03-08 21:06:29 +01:00
return;
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
}
Remove underscore hacks Way less cruft. :) Co-authored-by: Ignacio Roldán Etcheverry <neikeq@users.noreply.github.com>
2021-08-17 15:06:54 +02:00
parent = ClassDB::get_parent_class(parent);
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
}
}
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
#endif
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
GDScript: Improve handling of operators - Use the new functions in Variant to determine the validity and resulting type of operators. - Split the operator function in codegen between binary and unary, since the unary ones have now a special requirement of having the second argument to be the NIL type when requesting info.
2020-11-26 18:41:55 +01:00
GDScriptParser::DataType GDScriptAnalyzer::get_operation_type(Variant::Operator p_operation, const GDScriptParser::DataType &p_a, bool &r_valid, const GDScriptParser::Node *p_source) {
// Unary version.
GDScriptParser::DataType nil_type;
nil_type.builtin_type = Variant::NIL;
Fix operation result type inference
2021-12-23 13:45:24 +01:00
nil_type.type_source = GDScriptParser::DataType::ANNOTATED_INFERRED;
GDScript: Improve handling of operators - Use the new functions in Variant to determine the validity and resulting type of operators. - Split the operator function in codegen between binary and unary, since the unary ones have now a special requirement of having the second argument to be the NIL type when requesting info.
2020-11-26 18:41:55 +01:00
return get_operation_type(p_operation, p_a, nil_type, r_valid, p_source);
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
GDScript: Improve handling of operators - Use the new functions in Variant to determine the validity and resulting type of operators. - Split the operator function in codegen between binary and unary, since the unary ones have now a special requirement of having the second argument to be the NIL type when requesting info.
2020-11-26 18:41:55 +01:00
GDScriptParser::DataType GDScriptAnalyzer::get_operation_type(Variant::Operator p_operation, const GDScriptParser::DataType &p_a, const GDScriptParser::DataType &p_b, bool &r_valid, const GDScriptParser::Node *p_source) {
GDScript: Allow boolean operators between any types To make consistent with previous behavior. Mostly to be used in conditions for `if` and `while`.
2023-03-10 20:01:17 +01:00
if (p_operation == Variant::OP_AND || p_operation == Variant::OP_OR) {
// Those work for any type of argument and always return a boolean.
// They don't use the Variant operator since they have short-circuit semantics.
r_valid = true;
GDScriptParser::DataType result;
result.type_source = GDScriptParser::DataType::ANNOTATED_INFERRED;
result.kind = GDScriptParser::DataType::BUILTIN;
result.builtin_type = Variant::BOOL;
return result;
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
Variant::Type a_type = p_a.builtin_type;
Variant::Type b_type = p_b.builtin_type;
GDScript: Treat enum values as int and enum types as dictionary Since enums resolve to a dictionary at runtime, calling dictionary methods on an enum type is a valid use case. This ensures this is true by adding test cases. This also makes enum values be treated as ints when used in operations.
2022-02-02 17:57:24 +01:00
if (p_a.kind == GDScriptParser::DataType::ENUM) {
if (p_a.is_meta_type) {
a_type = Variant::DICTIONARY;
} else {
a_type = Variant::INT;
}
}
if (p_b.kind == GDScriptParser::DataType::ENUM) {
if (p_b.is_meta_type) {
b_type = Variant::DICTIONARY;
} else {
b_type = Variant::INT;
}
}
Fix: Typed arrays aren't working with +
2023-02-22 22:38:29 +01:00
GDScriptParser::DataType result;
Fix operation result type inference
2021-12-23 13:45:24 +01:00
bool hard_operation = p_a.is_hard_type() && p_b.is_hard_type();
Fix: Typed arrays aren't working with +
2023-02-22 22:38:29 +01:00
if (p_operation == Variant::OP_ADD && a_type == Variant::ARRAY && b_type == Variant::ARRAY) {
Make container element type comparison safe
2023-06-20 17:04:57 +02:00
if (p_a.has_container_element_type() && p_b.has_container_element_type() && p_a.get_container_element_type() == p_b.get_container_element_type()) {
Fix: Typed arrays aren't working with +
2023-02-22 22:38:29 +01:00
r_valid = true;
result = p_a;
result.type_source = hard_operation ? GDScriptParser::DataType::ANNOTATED_INFERRED : GDScriptParser::DataType::INFERRED;
return result;
}
}
Variant::ValidatedOperatorEvaluator op_eval = Variant::get_validated_operator_evaluator(p_operation, a_type, b_type);
Fix operation result type inference
2021-12-23 13:45:24 +01:00
bool validated = op_eval != nullptr;
GDScript: Fix some issues with assignments that involve untyped things
2022-12-30 08:58:07 +01:00
if (validated) {
Fix operation result type inference
2021-12-23 13:45:24 +01:00
r_valid = true;
GDScript: Fix some issues with assignments that involve untyped things
2022-12-30 08:58:07 +01:00
result.type_source = hard_operation ? GDScriptParser::DataType::ANNOTATED_INFERRED : GDScriptParser::DataType::INFERRED;
Fix operation result type inference
2021-12-23 13:45:24 +01:00
result.kind = GDScriptParser::DataType::BUILTIN;
result.builtin_type = Variant::get_operator_return_type(p_operation, a_type, b_type);
GDScript: Fix some issues with assignments that involve untyped things
2022-12-30 08:58:07 +01:00
} else {
r_valid = !hard_operation;
Fix operation result type inference
2021-12-23 13:45:24 +01:00
result.kind = GDScriptParser::DataType::VARIANT;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
return result;
}
// TODO: Add safe/unsafe return variable (for variant cases)
GDScript: Consolidate behavior for assigning enum types This makes sure that assigning values to enum-typed variables are consistent. Same enum is always valid, different enum is always invalid (without casting) and assigning `int` creates a warning if there is no casting. There are new test cases to ensure this behavior doesn't break in the future.
2022-01-27 15:34:33 +01:00
bool GDScriptAnalyzer::is_type_compatible(const GDScriptParser::DataType &p_target, const GDScriptParser::DataType &p_source, bool p_allow_implicit_conversion, const GDScriptParser::Node *p_source_node) {
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
// These return "true" so it doesn't affect users negatively.
ERR_FAIL_COND_V_MSG(!p_target.is_set(), true, "Parser bug (please report): Trying to check compatibility of unset target type");
ERR_FAIL_COND_V_MSG(!p_source.is_set(), true, "Parser bug (please report): Trying to check compatibility of unset value type");
if (p_target.kind == GDScriptParser::DataType::VARIANT) {
// Variant can receive anything.
return true;
}
if (p_source.kind == GDScriptParser::DataType::VARIANT) {
// TODO: This is acceptable but unsafe. Make sure unsafe line is set.
return true;
}
if (p_target.kind == GDScriptParser::DataType::BUILTIN) {
bool valid = p_source.kind == GDScriptParser::DataType::BUILTIN && p_target.builtin_type == p_source.builtin_type;
if (!valid && p_allow_implicit_conversion) {
valid = Variant::can_convert_strict(p_source.builtin_type, p_target.builtin_type);
}
GDScript: Consolidate behavior for assigning enum types This makes sure that assigning values to enum-typed variables are consistent. Same enum is always valid, different enum is always invalid (without casting) and assigning `int` creates a warning if there is no casting. There are new test cases to ensure this behavior doesn't break in the future.
2022-01-27 15:34:33 +01:00
if (!valid && p_target.builtin_type == Variant::INT && p_source.kind == GDScriptParser::DataType::ENUM && !p_source.is_meta_type) {
Added support for enums to be used as types in GDScript
2020-06-12 02:49:58 +02:00
// Enum value is also integer.
valid = true;
}
Add typed arrays to GDScript - Use `Array[type]` for type-hints. e.g.: `var array: Array[int] = [1, 2, 3]` - Array literals are typed if their storage is typed (variable asssignment of as argument in function all). Otherwise they are untyped.
2021-03-09 16:32:35 +01:00
if (valid && p_target.builtin_type == Variant::ARRAY && p_source.builtin_type == Variant::ARRAY) {
// Check the element type.
GDScript: Fix issues with typed arrays
2022-11-27 08:56:53 +01:00
if (p_target.has_container_element_type() && p_source.has_container_element_type()) {
valid = p_target.get_container_element_type() == p_source.get_container_element_type();
Add typed arrays to GDScript - Use `Array[type]` for type-hints. e.g.: `var array: Array[int] = [1, 2, 3]` - Array literals are typed if their storage is typed (variable asssignment of as argument in function all). Otherwise they are untyped.
2021-03-09 16:32:35 +01:00
}
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
return valid;
}
Added support for enums to be used as types in GDScript
2020-06-12 02:49:58 +02:00
if (p_target.kind == GDScriptParser::DataType::ENUM) {
if (p_source.kind == GDScriptParser::DataType::BUILTIN && p_source.builtin_type == Variant::INT) {
GDScript: Consolidate behavior for assigning enum types This makes sure that assigning values to enum-typed variables are consistent. Same enum is always valid, different enum is always invalid (without casting) and assigning `int` creates a warning if there is no casting. There are new test cases to ensure this behavior doesn't break in the future.
2022-01-27 15:34:33 +01:00
#ifdef DEBUG_ENABLED
if (p_source_node) {
GDScript: Fix constant conversions
2023-01-22 09:32:05 +01:00
parser->push_warning(p_source_node, GDScriptWarning::INT_AS_ENUM_WITHOUT_CAST);
GDScript: Consolidate behavior for assigning enum types This makes sure that assigning values to enum-typed variables are consistent. Same enum is always valid, different enum is always invalid (without casting) and assigning `int` creates a warning if there is no casting. There are new test cases to ensure this behavior doesn't break in the future.
2022-01-27 15:34:33 +01:00
}
#endif
Added support for enums to be used as types in GDScript
2020-06-12 02:49:58 +02:00
return true;
}
Accept non unnamed enums as valid values for enums. Fixes #49357
2021-08-15 21:25:47 +02:00
if (p_source.kind == GDScriptParser::DataType::ENUM) {
if (p_source.native_type == p_target.native_type) {
return true;
}
}
Added support for enums to be used as types in GDScript
2020-06-12 02:49:58 +02:00
return false;
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
// From here on the target type is an object, so we have to test polymorphism.
if (p_source.kind == GDScriptParser::DataType::BUILTIN && p_source.builtin_type == Variant::NIL) {
// null is acceptable in object.
return true;
}
StringName src_native;
Ref<Script> src_script;
const GDScriptParser::ClassNode *src_class = nullptr;
switch (p_source.kind) {
case GDScriptParser::DataType::NATIVE:
if (p_target.kind != GDScriptParser::DataType::NATIVE) {
// Non-native class cannot be supertype of native.
return false;
}
if (p_source.is_meta_type) {
src_native = GDScriptNativeClass::get_class_static();
} else {
src_native = p_source.native_type;
}
break;
case GDScriptParser::DataType::SCRIPT:
if (p_target.kind == GDScriptParser::DataType::CLASS) {
// A script type cannot be a subtype of a GDScript class.
return false;
}
if (p_source.is_meta_type) {
src_native = p_source.script_type->get_class_name();
} else {
src_script = p_source.script_type;
src_native = src_script->get_instance_base_type();
}
break;
case GDScriptParser::DataType::CLASS:
if (p_source.is_meta_type) {
src_native = GDScript::get_class_static();
} else {
src_class = p_source.class_type;
const GDScriptParser::ClassNode *base = src_class;
while (base->base_type.kind == GDScriptParser::DataType::CLASS) {
base = base->base_type.class_type;
}
src_native = base->base_type.native_type;
src_script = base->base_type.script_type;
}
break;
case GDScriptParser::DataType::VARIANT:
case GDScriptParser::DataType::BUILTIN:
Added support for enums to be used as types in GDScript
2020-06-12 02:49:58 +02:00
case GDScriptParser::DataType::ENUM:
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
case GDScriptParser::DataType::RESOLVING:
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
case GDScriptParser::DataType::UNRESOLVED:
break; // Already solved before.
}
switch (p_target.kind) {
case GDScriptParser::DataType::NATIVE: {
if (p_target.is_meta_type) {
return ClassDB::is_parent_class(src_native, GDScriptNativeClass::get_class_static());
}
Remove underscore hacks Way less cruft. :) Co-authored-by: Ignacio Roldán Etcheverry <neikeq@users.noreply.github.com>
2021-08-17 15:06:54 +02:00
return ClassDB::is_parent_class(src_native, p_target.native_type);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
case GDScriptParser::DataType::SCRIPT:
if (p_target.is_meta_type) {
return ClassDB::is_parent_class(src_native, p_target.script_type->get_class_name());
}
while (src_script.is_valid()) {
if (src_script == p_target.script_type) {
return true;
}
src_script = src_script->get_base_script();
}
return false;
case GDScriptParser::DataType::CLASS:
if (p_target.is_meta_type) {
return ClassDB::is_parent_class(src_native, GDScript::get_class_static());
}
while (src_class != nullptr) {
GDScript: Fix issues with typed arrays
2022-11-27 08:56:53 +01:00
if (src_class == p_target.class_type || src_class->fqcn == p_target.class_type->fqcn) {
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
return true;
}
src_class = src_class->base_type.class_type;
}
return false;
case GDScriptParser::DataType::VARIANT:
case GDScriptParser::DataType::BUILTIN:
Added support for enums to be used as types in GDScript
2020-06-12 02:49:58 +02:00
case GDScriptParser::DataType::ENUM:
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
case GDScriptParser::DataType::RESOLVING:
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
case GDScriptParser::DataType::UNRESOLVED:
break; // Already solved before.
}
return false;
}
void GDScriptAnalyzer::push_error(const String &p_message, const GDScriptParser::Node *p_origin) {
mark_node_unsafe(p_origin);
parser->push_error(p_message, p_origin);
}
void GDScriptAnalyzer::mark_node_unsafe(const GDScriptParser::Node *p_node) {
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
#ifdef DEBUG_ENABLED
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
if (p_node == nullptr) {
return;
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
for (int i = p_node->start_line; i <= p_node->end_line; i++) {
parser->unsafe_lines.insert(i);
}
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
#endif
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
GDScript: Fix some issues with assignments that involve untyped things
2022-12-30 08:58:07 +01:00
void GDScriptAnalyzer::downgrade_node_type_source(GDScriptParser::Node *p_node) {
GDScriptParser::IdentifierNode *identifier = nullptr;
if (p_node->type == GDScriptParser::Node::IDENTIFIER) {
identifier = static_cast<GDScriptParser::IdentifierNode *>(p_node);
} else if (p_node->type == GDScriptParser::Node::SUBSCRIPT) {
GDScriptParser::SubscriptNode *subscript = static_cast<GDScriptParser::SubscriptNode *>(p_node);
if (subscript->is_attribute) {
identifier = subscript->attribute;
}
}
if (identifier == nullptr) {
return;
}
GDScriptParser::Node *source = nullptr;
switch (identifier->source) {
case GDScriptParser::IdentifierNode::MEMBER_VARIABLE: {
source = identifier->variable_source;
} break;
case GDScriptParser::IdentifierNode::FUNCTION_PARAMETER: {
source = identifier->parameter_source;
} break;
case GDScriptParser::IdentifierNode::LOCAL_VARIABLE: {
source = identifier->variable_source;
} break;
case GDScriptParser::IdentifierNode::LOCAL_ITERATOR: {
source = identifier->bind_source;
} break;
default:
break;
}
if (source == nullptr) {
return;
}
GDScriptParser::DataType datatype;
datatype.kind = GDScriptParser::DataType::VARIANT;
source->set_datatype(datatype);
}
GDScript: Allow using self in lambdas
2022-04-20 19:22:22 +02:00
void GDScriptAnalyzer::mark_lambda_use_self() {
GDScript: Fix lambda resolution with cyclic references
2023-08-23 11:37:18 +02:00
GDScriptParser::LambdaNode *lambda = current_lambda;
while (lambda != nullptr) {
GDScript: Allow using self in lambdas
2022-04-20 19:22:22 +02:00
lambda->use_self = true;
GDScript: Fix lambda resolution with cyclic references
2023-08-23 11:37:18 +02:00
lambda = lambda->parent_lambda;
}
}
void GDScriptAnalyzer::resolve_pending_lambda_bodies() {
if (pending_body_resolution_lambdas.is_empty()) {
return;
GDScript: Allow using self in lambdas
2022-04-20 19:22:22 +02:00
}
GDScript: Fix lambda resolution with cyclic references
2023-08-23 11:37:18 +02:00
GDScriptParser::LambdaNode *previous_lambda = current_lambda;
List<GDScriptParser::LambdaNode *> lambdas = pending_body_resolution_lambdas;
pending_body_resolution_lambdas.clear();
for (GDScriptParser::LambdaNode *lambda : lambdas) {
current_lambda = lambda;
resolve_function_body(lambda->function, true);
int captures_amount = lambda->captures.size();
if (captures_amount > 0) {
// Create space for lambda parameters.
// At the beginning to not mess with optional parameters.
int param_count = lambda->function->parameters.size();
lambda->function->parameters.resize(param_count + captures_amount);
for (int i = param_count - 1; i >= 0; i--) {
lambda->function->parameters.write[i + captures_amount] = lambda->function->parameters[i];
lambda->function->parameters_indices[lambda->function->parameters[i]->identifier->name] = i + captures_amount;
}
// Add captures as extra parameters at the beginning.
for (int i = 0; i < lambda->captures.size(); i++) {
GDScriptParser::IdentifierNode *capture = lambda->captures[i];
GDScriptParser::ParameterNode *capture_param = parser->alloc_node<GDScriptParser::ParameterNode>();
capture_param->identifier = capture;
capture_param->usages = capture->usages;
capture_param->set_datatype(capture->get_datatype());
lambda->function->parameters.write[i] = capture_param;
lambda->function->parameters_indices[capture->name] = i;
}
}
}
current_lambda = previous_lambda;
GDScript: Allow using self in lambdas
2022-04-20 19:22:22 +02:00
}
Add typed arrays to GDScript - Use `Array[type]` for type-hints. e.g.: `var array: Array[int] = [1, 2, 3]` - Array literals are typed if their storage is typed (variable asssignment of as argument in function all). Otherwise they are untyped.
2021-03-09 16:32:35 +01:00
bool GDScriptAnalyzer::class_exists(const StringName &p_class) const {
Remove underscore hacks Way less cruft. :) Co-authored-by: Ignacio Roldán Etcheverry <neikeq@users.noreply.github.com>
2021-08-17 15:06:54 +02:00
return ClassDB::class_exists(p_class) && ClassDB::is_class_exposed(p_class);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
Ref<GDScriptParserRef> GDScriptAnalyzer::get_parser_for(const String &p_path) {
Ref<GDScriptParserRef> ref;
if (depended_parsers.has(p_path)) {
ref = depended_parsers[p_path];
} else {
Error err = OK;
Wrap up GDScript 2.0 base implementation
2020-07-16 03:02:44 +02:00
ref = GDScriptCache::get_parser(p_path, GDScriptParserRef::EMPTY, err, parser->script_path);
Avoid a crash in the gdscript analyser
2021-12-14 15:54:25 +01:00
if (ref.is_valid()) {
depended_parsers[p_path] = ref;
}
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
return ref;
}
Error GDScriptAnalyzer::resolve_inheritance() {
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
return resolve_class_inheritance(parser->head, true);
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
Error GDScriptAnalyzer::resolve_interface() {
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
resolve_class_interface(parser->head, true);
Rename empty() to is_empty()
2020-12-15 13:04:21 +01:00
return parser->errors.is_empty() ? OK : ERR_PARSE_ERROR;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
Error GDScriptAnalyzer::resolve_body() {
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
resolve_class_body(parser->head, true);
Rename empty() to is_empty()
2020-12-15 13:04:21 +01:00
return parser->errors.is_empty() ? OK : ERR_PARSE_ERROR;
Add new GDScript type checker
2020-06-11 00:53:25 +02:00
}
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
Error GDScriptAnalyzer::resolve_dependencies() {
Add a new HashMap implementation Adds a new, cleaned up, HashMap implementation. * Uses Robin Hood Hashing (https://en.wikipedia.org/wiki/Hash_table#Robin_Hood_hashing). * Keeps elements in a double linked list for simpler, ordered, iteration. * Allows keeping iterators for later use in removal (Unlike Map<>, it does not do much for performance vs keeping the key, but helps replace old code). * Uses a more modern C++ iterator API, deprecates the old one. * Supports custom allocator (in case there is a wish to use a paged one). This class aims to unify all the associative template usage and replace it by this one: * Map<> (whereas key order does not matter, which is 99% of cases) * HashMap<> * OrderedHashMap<> * OAHashMap<>
2022-05-08 10:09:19 +02:00
for (KeyValue<String, Ref<GDScriptParserRef>> &K : depended_parsers) {
if (K.value.is_null()) {
GDScript: Fix issues when deriving from other scripts
2020-08-26 19:50:27 +02:00
return ERR_PARSE_ERROR;
}
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
K.value->raise_status(GDScriptParserRef::INHERITANCE_SOLVED);
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 00:31:28 +02:00
}
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
Rename empty() to is_empty()
2020-12-15 13:04:21 +01:00
return parser->errors.is_empty() ? OK : ERR_PARSE_ERROR;
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 00:14:56 +02:00
}
Error GDScriptAnalyzer::analyze() {
parser->errors.clear();
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
Error err = OK;
err = resolve_inheritance();
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 00:14:56 +02:00
if (err) {
return err;
}
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
GDScript: Fix `@icon` annotation
2023-01-31 15:43:54 +01:00
// Apply annotations.
for (GDScriptParser::AnnotationNode *&E : parser->head->annotations) {
resolve_annotation(E);
E->apply(parser, parser->head);
}
GDScript: Allow out of order member resolution
2022-12-11 03:57:35 +01:00
resolve_interface();
resolve_body();
if (!parser->errors.is_empty()) {
return ERR_PARSE_ERROR;
}
return resolve_dependencies();
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 00:14:56 +02:00
}
GDScriptAnalyzer::GDScriptAnalyzer(GDScriptParser *p_parser) {
parser = p_parser;
}
Reference in a new issue Copy permalink