godotengine/godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
18d8838051
godot/modules/gdscript/gdscript_analyzer.cpp

5759 lines
228 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 12:25:55 +00: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-01 22:14:56 +00: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 14:56:21 +00:00
#include "gdscript.h"
GDScript: Allow utility functions to be used as `Callable`
2024-01-05 10:56:42 +00:00
#include "gdscript_utility_callable.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 14:56:21 +00:00
#include "gdscript_utility_functions.h"
GDScript: Make singleton functions be seen as static Since those can be called without an instance.
2021-08-20 13:52:58 +00: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 22:33:38 +00: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 15:57:09 +00:00
#include "core/core_constants.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 12:51:48 +00: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-01 22:14:56 +00: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 22:33:38 +00: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 16:41:28 +00: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-01 22:14:56 +00: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 08:07:01 +00: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 03:02:03 +00: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 15:57:09 +00:00
#define ENUM_SEPARATOR "."
Assorted enum and native type fixes
2022-12-04 03:02:03 +00: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 14:56:32 +00: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-10 22:53:25 +00: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-11 23:03:53 +00: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-10 22:53:25 +00:00
type.is_meta_type = true;
return type;
}
Assorted enum and native type fixes
2022-12-04 03:02:03 +00: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 00:49:58 +00: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 03:02:03 +00: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 00:49:58 +00:00
type.is_constant = true;
Assorted enum and native type fixes
2022-12-04 03:02:03 +00: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 15:57:09 +00: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 03:02:03 +00: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 15:57:09 +00: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 14:57:22 +00: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 15:57:09 +00: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 14:57:22 +00:00
}
Added support for enums to be used as types in GDScript
2020-06-12 00:49:58 +00: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 14:57:22 +00: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 00:49:58 +00:00
Use C++ iterators for Lists in many situations
2021-07-16 03:45:57 +00: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 14:57:22 +00: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 00:49:58 +00: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 15:57:09 +00: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-10 22:53:25 +00: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 22:41:50 +00: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 16:49:03 +00: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 22:41:50 +00: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 16:49:03 +00: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;
}
Add shorthand for using singleton string names
2023-09-04 15:01:33 +00:00
if (p_member_name == CoreStringName(script)) {
Fix ability to overload "script" variable
2022-11-08 22:41:50 +00:00
return true;
}
Check for GDScript member and class naming conflicts in a variety of conditions.
2021-08-24 16:49:03 +00: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 13:51:29 +00: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 16:49:03 +00:00
return ERR_PARSE_ERROR;
}
GDScript: Improve call analysis * Add missing `UNSAFE_CALL_ARGUMENT` warning. * Fix `Object` constructor. * Display an error for non-existent static methods.
2023-09-21 09:42:55 +00:00
if (GDScriptParser::get_builtin_type(p_member_name) < Variant::VARIANT_MAX) {
GDScript: Don't allow builtin type names as identifiers
2021-09-29 14:23:16 +00:00
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 16:49:03 +00: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 03:02:03 +00: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 16:49:03 +00: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 22:41:50 +00: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 02:30:19 +00: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 16:49:03 +00:00
return ERR_PARSE_ERROR;
}
current_data_type = &current_class_node->base_type;
}
Fix ability to overload "script" variable
2022-11-08 22:41:50 +00: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 16:49:03 +00: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 13:12:19 +00:00
if (current_data_type->native_type != StringName()) {
Check for GDScript member and class naming conflicts in a variety of conditions.
2021-08-24 16:49:03 +00: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 21:55:40 +00: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 05:38:53 +00:00
ERR_FAIL_NULL(p_node);
ERR_FAIL_NULL(p_list);
Fix constant base typing in extended GDScript class
2022-12-04 21:55:40 +00: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 05:38:53 +00:00
Fix constant base typing in extended GDScript class
2022-12-04 21:55:40 +00:00
p_list->push_back(p_node);
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
// TODO: Try to solve class inheritance if not yet resolving.
Fix constant base typing in extended GDScript class
2022-12-04 21:55:40 +00: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 02:57:35 +00: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;
GDScript: invalidate GDScriptParserRef when reloading
2024-04-12 23:13:25 +00:00
Ref<GDScriptParserRef> parser_ref = parser->get_depended_parser_for(script_path);
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
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-01 22:14:56 +00:00
return OK;
}
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00: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 13:51:29 +00:00
if (p_class->identifier) {
StringName class_name = p_class->identifier->name;
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00: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 13:51:29 +00:00
push_error(vformat(R"(Class "%s" hides a native class.)", class_name), p_class->identifier);
GDScript: Canonicalize script path in FQCN
2024-02-26 07:46:24 +00:00
} else if (ScriptServer::is_global_class(class_name) && (!GDScript::is_canonically_equal_paths(ScriptServer::get_global_class_path(class_name), parser->script_path) || p_class != parser->head)) {
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 13:51:29 +00:00
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 02:57:35 +00:00
GDScriptParser::DataType resolving_datatype;
resolving_datatype.kind = GDScriptParser::DataType::RESOLVING;
p_class->base_type = resolving_datatype;
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 01:02:44 +00:00
class_type.script_path = parser->script_path;
GDScript: Allow subscript on self and object types
2021-10-06 15:01:34 +00:00
class_type.builtin_type = Variant::OBJECT;
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
p_class->set_datatype(class_type);
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00: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-01 22:14:56 +00:00
if (!p_class->extends_used) {
result.type_source = GDScriptParser::DataType::ANNOTATED_INFERRED;
result.kind = GDScriptParser::DataType::NATIVE;
GDScript: Fix `native_type` is empty for autoload without script
2023-10-04 12:03:53 +00:00
result.builtin_type = Variant::OBJECT;
Refactor some object type checking code with `cast_to` Less stringly typed logic, and less String allocations and comparisons.
2022-02-06 13:12:19 +00: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-01 22:14:56 +00:00
} else {
result.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
GDScriptParser::DataType base;
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
int extends_index = 0;
Rename empty() to is_empty()
2020-12-15 12:04:21 +00:00
if (!p_class->extends_path.is_empty()) {
Fix extends with relative path to parent script
2021-07-14 15:23:54 +00:00
if (p_class->extends_path.is_relative_path()) {
Rename String `plus_file` to `path_join`
2022-08-30 00:34:01 +00: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 15:23:54 +00:00
}
GDScript: invalidate GDScriptParserRef when reloading
2024-04-12 23:13:25 +00:00
Ref<GDScriptParserRef> ext_parser = parser->get_depended_parser_for(p_class->extends_path);
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 09:53:28 +00:00
if (ext_parser.is_null()) {
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 02:57:35 +00:00
Error err = ext_parser->raise_status(GDScriptParserRef::INHERITANCE_SOLVED);
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 09:53:28 +00: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-01 22:14:56 +00:00
} else {
Rename empty() to is_empty()
2020-12-15 12:04:21 +00:00
if (p_class->extends.is_empty()) {
Prevent crash due to empty error message on empty extends in GDScript
2022-03-12 06:33:11 +00:00
push_error("Could not resolve an empty super class path.", p_class);
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00:00
return ERR_PARSE_ERROR;
}
GDScript: Change parser representation of class extends
2023-03-08 20:06:29 +00: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-01 22:14:56 +00:00
base.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
if (ScriptServer::is_global_class(name)) {
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
String base_path = ScriptServer::get_global_class_path(name);
GDScript: Canonicalize script path in FQCN
2024-02-26 07:46:24 +00:00
if (GDScript::is_canonically_equal_paths(base_path, parser->script_path)) {
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00:00
base = parser->head->get_datatype();
} else {
GDScript: invalidate GDScriptParserRef when reloading
2024-04-12 23:13:25 +00:00
Ref<GDScriptParserRef> base_parser = parser->get_depended_parser_for(base_path);
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 09:53:28 +00:00
if (base_parser.is_null()) {
GDScript: Change parser representation of class extends
2023-03-08 20:06:29 +00:00
push_error(vformat(R"(Could not resolve super class "%s".)", name), id);
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00:00
return ERR_PARSE_ERROR;
}
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
Error err = base_parser->raise_status(GDScriptParserRef::INHERITANCE_SOLVED);
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00:00
if (err != OK) {
GDScript: Change parser representation of class extends
2023-03-08 20:06:29 +00: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 01:02:44 +00:00
return err;
}
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 09:53:28 +00: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-01 22:14:56 +00:00
}
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 02:57:35 +00:00
if (info.path.get_extension().to_lower() != GDScriptLanguage::get_singleton()->get_extension()) {
GDScript: Change parser representation of class extends
2023-03-08 20:06:29 +00:00
push_error(vformat(R"(Singleton %s is not a GDScript.)", info.name), id);
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
return ERR_PARSE_ERROR;
}
GDScript: invalidate GDScriptParserRef when reloading
2024-04-12 23:13:25 +00:00
Ref<GDScriptParserRef> info_parser = parser->get_depended_parser_for(info.path);
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 09:53:28 +00:00
if (info_parser.is_null()) {
GDScript: Change parser representation of class extends
2023-03-08 20:06:29 +00:00
push_error(vformat(R"(Could not parse singleton from "%s".)", info.path), id);
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
return ERR_PARSE_ERROR;
}
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
Error err = info_parser->raise_status(GDScriptParserRef::INHERITANCE_SOLVED);
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
if (err != OK) {
GDScript: Change parser representation of class extends
2023-03-08 20:06:29 +00:00
push_error(vformat(R"(Could not resolve super class inheritance from "%s".)", name), id);
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
return err;
}
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
base = info_parser->get_parser()->head->get_datatype();
GDScript: Fix extending abstract classes, forbid their construction
2022-12-29 07:34:13 +00:00
} else if (class_exists(name)) {
GDScript: Prevent constructing and inheriting engine singletons
2023-09-22 07:10:22 +00:00
if (Engine::get_singleton()->has_singleton(name)) {
push_error(vformat(R"(Cannot inherit native class "%s" because it is an engine singleton.)", name), id);
return ERR_PARSE_ERROR;
}
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
base.kind = GDScriptParser::DataType::NATIVE;
GDScript: Fix `native_type` is empty for autoload without script
2023-10-04 12:03:53 +00:00
base.builtin_type = Variant::OBJECT;
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
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-01 22:14:56 +00:00
} else {
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
// Look for other classes in script.
bool found = false;
Fix constant base typing in extended GDScript class
2022-12-04 21:55:40 +00: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 01:02:44 +00: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 20:06:29 +00:00
Error err = resolve_class_inheritance(look_class, id);
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00:00
if (err) {
return err;
}
}
base = look_class->get_datatype();
found = true;
break;
}
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
if (look_class->has_member(name)) {
GDScript: Change parser representation of class extends
2023-03-08 20:06:29 +00:00
resolve_class_member(look_class, name, id);
GDScript: Add missing member type check when resolving `extends`
2023-04-10 06:54:53 +00: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-10 22:53:25 +00: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-01 22:14:56 +00:00
}
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
if (!found) {
GDScript: Change parser representation of class extends
2023-03-08 20:06:29 +00:00
push_error(vformat(R"(Could not find base class "%s".)", name), id);
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 20:06:29 +00:00
GDScriptParser::IdentifierNode *id = p_class->extends[index];
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
if (base.kind != GDScriptParser::DataType::CLASS) {
GDScript: Change parser representation of class extends
2023-03-08 20:06:29 +00: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-10 22:53:25 +00: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 20:06:29 +00:00
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
if (!id_type.is_set()) {
GDScript: Change parser representation of class extends
2023-03-08 20:06:29 +00: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 06:54:53 +00: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-01 22:14:56 +00:00
}
Add new GDScript type checker
2020-06-10 22:53:25 +00: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-01 22:14:56 +00:00
}
result = base;
}
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00: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-01 22:14:56 +00:00
// TODO: More specific error messages.
Add new GDScript type checker
2020-06-10 22:53:25 +00: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-01 22:14:56 +00:00
return ERR_PARSE_ERROR;
}
GDScript: Show error when there's an inheritance cycle
2020-08-26 19:01:08 +00: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-10 22:53:25 +00: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-01 22:14:56 +00:00
GDScript: Fix `@warning_ignore` annotation issues
2024-02-28 14:23:11 +00:00
// Apply annotations.
for (GDScriptParser::AnnotationNode *&E : p_class->annotations) {
resolve_annotation(E);
E->apply(parser, p_class, p_class->outer);
}
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00: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-01 22:14:56 +00: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 02:57:35 +00:00
err = resolve_class_inheritance(p_class->members[i].m_class, true);
GDScript: Show error when there's an inheritance cycle
2020-08-26 19:01:08 +00: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-01 22:14:56 +00:00
}
}
}
return OK;
}
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-11 22:31:28 +00:00
GDScriptParser::DataType GDScriptAnalyzer::resolve_datatype(GDScriptParser::TypeNode *p_type) {
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00: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-01 22:14:56 +00:00
if (p_type == nullptr) {
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00: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-01 22:14:56 +00:00
}
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00: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-10 22:53:25 +00:00
Rename empty() to is_empty()
2020-12-15 12:04:21 +00: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-01 22:14:56 +00: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-11 22:31:28 +00: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-01 22:14:56 +00:00
return result;
}
GDScript: Allow use local constants as types
2023-08-24 16:01:31 +00: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()) {
GDScript: invalidate GDScriptParserRef when reloading
2024-04-12 23:13:25 +00:00
Ref<GDScriptParserRef> ref = parser->get_depended_parser_for(gdscript->get_script_path());
GDScript: Allow use local constants as types
2023-08-24 16:01:31 +00:00
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 15:57:09 +00:00
} else {
GDScript: Allow use local constants as types
2023-08-24 16:01:31 +00: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 15:57:09 +00:00
return bad_type;
}
GDScript: Allow use local constants as types
2023-08-24 16:01:31 +00: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 02:57:35 +00: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-01 22:14:56 +00:00
}
GDScript: Allow use local constants as types
2023-08-24 16:01:31 +00: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 15:32:35 +00:00
GDScript: Allow use local constants as types
2023-08-24 16:01:31 +00: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 02:57:35 +00:00
return bad_type;
Add GDScript resource export.
2022-04-25 04:33:18 +00:00
}
GDScript: Allow use local constants as types
2023-08-24 16:01:31 +00: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 (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) {
Change container_element_type to vector container
2023-09-14 18:31:07 +00:00
GDScriptParser::DataType container_type = type_from_metatype(resolve_datatype(p_type->get_container_type_or_null(0)));
GDScript: Allow use local constants as types
2023-08-24 16:01:31 +00:00
if (container_type.kind != GDScriptParser::DataType::VARIANT) {
container_type.is_constant = false;
Change container_element_type to vector container
2023-09-14 18:31:07 +00:00
result.set_container_element_type(0, container_type);
GDScript: Allow use local constants as types
2023-08-24 16:01:31 +00:00
}
}
} 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)) {
GDScript: Canonicalize script path in FQCN
2024-02-26 07:46:24 +00:00
if (GDScript::is_canonically_equal_paths(parser->script_path, ScriptServer::get_global_class_path(first))) {
GDScript: Allow use local constants as types
2023-08-24 16:01:31 +00:00
result = parser->head->get_datatype();
Add GDScript resource export.
2022-04-25 04:33:18 +00:00
} else {
GDScript: Allow use local constants as types
2023-08-24 16:01:31 +00:00
String path = ScriptServer::get_global_class_path(first);
String ext = path.get_extension();
if (ext == GDScriptLanguage::get_singleton()->get_extension()) {
GDScript: invalidate GDScriptParserRef when reloading
2024-04-12 23:13:25 +00:00
Ref<GDScriptParserRef> ref = parser->get_depended_parser_for(path);
GDScript: Allow use local constants as types
2023-08-24 16:01:31 +00:00
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 01:02:44 +00:00
}
GDScript: Allow use local constants as types
2023-08-24 16:01:31 +00: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);
GDScript: Resolve types from autoload scenes When the autoload is a scene, it now extracts the script from it and use it to further infer nested types.
2024-04-10 16:57:27 +00:00
String script_path;
if (ResourceLoader::get_resource_type(autoload.path) == "PackedScene") {
// Try to get script from scene if possible.
if (GDScriptLanguage::get_singleton()->has_any_global_constant(autoload.name)) {
Variant constant = GDScriptLanguage::get_singleton()->get_any_global_constant(autoload.name);
Node *node = Object::cast_to<Node>(constant);
if (node != nullptr) {
Ref<GDScript> scr = node->get_script();
if (scr.is_valid()) {
script_path = scr->get_script_path();
}
}
}
} else if (ResourceLoader::get_resource_type(autoload.path) == "GDScript") {
script_path = autoload.path;
}
if (script_path.is_empty()) {
return bad_type;
}
Ref<GDScriptParserRef> ref = parser->get_depended_parser_for(script_path);
GDScript: Allow use local constants as types
2023-08-24 16:01:31 +00:00
if (ref.is_null()) {
GDScript: Resolve types from autoload scenes When the autoload is a scene, it now extracts the script from it and use it to further infer nested types.
2024-04-10 16:57:27 +00:00
push_error(vformat(R"(The referenced autoload "%s" (from "%s") could not be loaded.)", first, script_path), p_type);
GDScript: Allow use local constants as types
2023-08-24 16:01:31 +00:00
return bad_type;
Assorted enum and native type fixes
2022-12-04 03:02:03 +00:00
}
GDScript: Allow use local constants as types
2023-08-24 16:01:31 +00:00
if (ref->raise_status(GDScriptParserRef::INHERITANCE_SOLVED) != OK) {
GDScript: Resolve types from autoload scenes When the autoload is a scene, it now extracts the script from it and use it to further infer nested types.
2024-04-10 16:57:27 +00:00
push_error(vformat(R"(Could not parse singleton "%s" from "%s".)", first, script_path), p_type);
GDScript: Allow use local constants as types
2023-08-24 16:01:31 +00:00
return bad_type;
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00:00
}
GDScript: Allow use local constants as types
2023-08-24 16:01:31 +00: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 02:57:35 +00:00
GDScript: Allow use local constants as types
2023-08-24 16:01:31 +00: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 02:57:35 +00:00
result = member.get_datatype();
Assorted enum and native type fixes
2022-12-04 03:02:03 +00:00
found = true;
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
break;
GDScript: Allow use local constants as types
2023-08-24 16:01:31 +00:00
case GDScriptParser::ClassNode::Member::ENUM:
result = member.get_datatype();
Assorted enum and native type fixes
2022-12-04 03:02:03 +00:00
found = true;
GDScript: Fix inner classes and preloaded scripts as types
2021-05-26 12:23:17 +00:00
break;
GDScript: Allow use local constants as types
2023-08-24 16:01:31 +00: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()) {
GDScript: invalidate GDScriptParserRef when reloading
2024-04-12 23:13:25 +00:00
Ref<GDScriptParserRef> ref = parser->get_depended_parser_for(gdscript->get_script_path());
GDScript: Allow use local constants as types
2023-08-24 16:01:31 +00:00
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-01 22:14:56 +00:00
}
}
}
Added support for enums to be used as types in GDScript
2020-06-12 00:49:58 +00:00
}
GDScript: Allow use local constants as types
2023-08-24 16:01:31 +00:00
Added support for enums to be used as types in GDScript
2020-06-12 00:49:58 +00:00
if (!result.is_set()) {
GDScript: Fix error message for unfound type
2023-02-21 21:00:29 +00: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 02:57:35 +00: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-01 22:14:56 +00:00
}
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
if (p_type->type_chain.size() > 1) {
Added support for enums to be used as types in GDScript
2020-06-12 00:49:58 +00:00
if (result.kind == GDScriptParser::DataType::CLASS) {
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 02:57:35 +00:00
return bad_type;
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 02:57:35 +00:00
return bad_type;
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
}
}
Added support for enums to be used as types in GDScript
2020-06-12 00:49:58 +00:00
} else if (result.kind == GDScriptParser::DataType::NATIVE) {
// Only enums allowed for native.
Assorted enum and native type fixes
2022-12-04 03:02:03 +00: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 02:57:35 +00:00
return bad_type;
Added support for enums to be used as types in GDScript
2020-06-12 00:49:58 +00: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 02:57:35 +00:00
return bad_type;
Add new GDScript type checker
2020-06-10 22:53:25 +00: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-01 22:14:56 +00:00
}
Change container_element_type to vector container
2023-09-14 18:31:07 +00:00
if (!p_type->container_types.is_empty()) {
if (result.builtin_type == Variant::ARRAY) {
if (p_type->container_types.size() != 1) {
push_error("Arrays require exactly one collection element type.", p_type);
return bad_type;
}
} else {
push_error("Only arrays can specify collection element types.", p_type);
return bad_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 15:32:35 +00:00
}
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-11 22:31:28 +00: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-01 22:14:56 +00:00
return result;
}
Add const lvalue ref to container parameters
2021-08-01 19:47:20 +00:00
void GDScriptAnalyzer::resolve_class_member(GDScriptParser::ClassNode *p_class, const StringName &p_name, const GDScriptParser::Node *p_source) {
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
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;
GDScript: invalidate GDScriptParserRef when reloading
2024-04-12 23:13:25 +00:00
Ref<GDScriptParserRef> parser_ref = parser->get_depended_parser_for(script_path);
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
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-10 22:53:25 +00:00
return;
}
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00: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-10 22:53:25 +00: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-01 22:14:56 +00:00
GDScriptParser::ClassNode *previous_class = parser->current_class;
parser->current_class = p_class;
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00: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-01 22:14:56 +00:00
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00: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 14:57:22 +00:00
#ifdef DEBUG_ENABLED
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);
GDScript: Add error when exporting node in non [Node]-derived classes
2023-10-05 10:50:26 +00:00
E->apply(parser, member.variable, p_class);
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 14:57:22 +00:00
}
}
}
#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-01 22:14:56 +00: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 14:10:35 +00:00
bool previous_static_context = static_context;
static_context = member.variable->is_static;
GDScript: Fix lambda resolution with cyclic references
2023-08-23 09:37:18 +00:00
Check for GDScript member and class naming conflicts in a variety of conditions.
2021-08-24 16:49:03 +00:00
check_class_member_name_conflict(p_class, member.variable->identifier->name, member.variable);
GDScript: Fix lambda resolution with cyclic references
2023-08-23 09:37:18 +00:00
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
member.variable->set_datatype(resolving_datatype);
Unify typing of variables, constants and parameters in GDScript
2022-12-22 20:43:36 +00:00
resolve_variable(member.variable, false);
GDScript: Fix lambda resolution with cyclic references
2023-08-23 09:37:18 +00: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 13:57:30 +00:00
// Apply annotations.
Use C++ iterators for Lists in many situations
2021-07-16 03:45:57 +00: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 14:57:22 +00:00
if (E->name != SNAME("@warning_ignore")) {
resolve_annotation(E);
GDScript: Add error when exporting node in non [Node]-derived classes
2023-10-05 10:50:26 +00:00
E->apply(parser, member.variable, p_class);
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 14:57:22 +00:00
}
}
GDScript: Fix lambda resolution with cyclic references
2023-08-23 09:37:18 +00: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 14:10:35 +00:00
static_context = previous_static_context;
GDScript: Fix lambda resolution with cyclic references
2023-08-23 09:37:18 +00: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 14:57:22 +00: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-01 22:14:56 +00: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 14:57:22 +00: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 14:10:35 +00: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 14:57:22 +00: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-10 22:53:25 +00:00
} break;
case GDScriptParser::ClassNode::Member::CONSTANT: {
Check for GDScript member and class naming conflicts in a variety of conditions.
2021-08-24 16:49:03 +00:00
check_class_member_name_conflict(p_class, member.constant->identifier->name, member.constant);
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
member.constant->set_datatype(resolving_datatype);
Unify typing of variables, constants and parameters in GDScript
2022-12-22 20:43:36 +00: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 13:57:30 +00:00
// Apply annotations.
Use C++ iterators for Lists in many situations
2021-07-16 03:45:57 +00:00
for (GDScriptParser::AnnotationNode *&E : member.constant->annotations) {
GDScript: Allow constant expressions in annotations
2023-01-18 17:12:33 +00:00
resolve_annotation(E);
GDScript: Add error when exporting node in non [Node]-derived classes
2023-10-05 10:50:26 +00:00
E->apply(parser, member.constant, p_class);
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 13:57:30 +00:00
}
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
} break;
case GDScriptParser::ClassNode::Member::SIGNAL: {
Check for GDScript member and class naming conflicts in a variety of conditions.
2021-08-24 16:49:03 +00:00
check_class_member_name_conflict(p_class, member.signal->identifier->name, member.signal);
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
member.signal->set_datatype(resolving_datatype);
Add MethodInfo to signal datatype
2022-12-16 03:45:46 +00: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-10 22:53:25 +00:00
for (int j = 0; j < member.signal->parameters.size(); j++) {
Add MethodInfo to signal datatype
2022-12-16 03:45:46 +00:00
GDScriptParser::ParameterNode *param = member.signal->parameters[j];
GDScript: Fix small inconsistencies with resolve_datatype
2023-01-11 23:03:53 +00:00
GDScriptParser::DataType param_type = type_from_metatype(resolve_datatype(param->datatype_specifier));
Add MethodInfo to signal datatype
2022-12-16 03:45:46 +00:00
param->set_datatype(param_type);
Add "untyped_declaration" warning
2023-09-05 17:56:37 +00:00
#ifdef DEBUG_ENABLED
if (param->datatype_specifier == nullptr) {
parser->push_warning(param, GDScriptWarning::UNTYPED_DECLARATION, "Parameter", param->identifier->name);
}
#endif
GDScript: Fix `get_*_list()` methods return incorrect info
2023-08-28 16:20:10 +00:00
mi.arguments.push_back(param_type.to_property_info(param->identifier->name));
// Signals do not support parameter default values.
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
}
Add MethodInfo to signal datatype
2022-12-16 03:45:46 +00:00
member.signal->set_datatype(make_signal_type(mi));
GDScript: Fix `get_*_list()` methods return incorrect info
2023-08-28 16:20:10 +00:00
member.signal->method_info = 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 13:57:30 +00:00
// Apply annotations.
Use C++ iterators for Lists in many situations
2021-07-16 03:45:57 +00:00
for (GDScriptParser::AnnotationNode *&E : member.signal->annotations) {
GDScript: Allow constant expressions in annotations
2023-01-18 17:12:33 +00:00
resolve_annotation(E);
GDScript: Add error when exporting node in non [Node]-derived classes
2023-10-05 10:50:26 +00:00
E->apply(parser, member.signal, p_class);
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 13:57:30 +00:00
}
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
} break;
case GDScriptParser::ClassNode::Member::ENUM: {
Check for GDScript member and class naming conflicts in a variety of conditions.
2021-08-24 16:49:03 +00: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 02:57:35 +00:00
member.m_enum->set_datatype(resolving_datatype);
Assorted enum and native type fixes
2022-12-04 03:02:03 +00: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 00:49:58 +00:00
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00: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 20:44:20 +00:00
current_enum = member.m_enum;
Fix usage of Enum as constant
2022-12-27 03:06:11 +00:00
Dictionary dictionary;
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00: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 20:44:20 +00: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 03:06:11 +00:00
dictionary[String(element.identifier->name)] = element.value;
GDScript: Fix `@warning_ignore` annotation issues
2024-02-28 14:23:11 +00:00
#ifdef DEBUG_ENABLED
// Named enum identifiers do not shadow anything since you can only access them with `NamedEnum.ENUM_VALUE`.
if (member.m_enum->identifier->name == StringName()) {
is_shadowing(element.identifier, "enum member", false);
}
#endif
Added support for enums to be used as types in GDScript
2020-06-12 00:49:58 +00:00
}
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00: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 20:44:20 +00:00
GDScript: Fix test for read-only state of constants
2023-01-22 09:07:48 +00:00
dictionary.make_read_only();
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
member.m_enum->set_datatype(enum_type);
Fix usage of Enum as constant
2022-12-27 03:06:11 +00: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 13:57:30 +00:00
// Apply annotations.
Use C++ iterators for Lists in many situations
2021-07-16 03:45:57 +00:00
for (GDScriptParser::AnnotationNode *&E : member.m_enum->annotations) {
GDScript: Allow constant expressions in annotations
2023-01-18 17:12:33 +00:00
resolve_annotation(E);
GDScript: Add error when exporting node in non [Node]-derived classes
2023-10-05 10:50:26 +00:00
E->apply(parser, member.m_enum, p_class);
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 13:57:30 +00:00
}
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 14:57:22 +00:00
for (GDScriptParser::AnnotationNode *&E : member.function->annotations) {
resolve_annotation(E);
GDScript: Add error when exporting node in non [Node]-derived classes
2023-10-05 10:50:26 +00:00
E->apply(parser, member.function, p_class);
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 14:57:22 +00:00
}
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00: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-01 22:14:56 +00: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 20:44:20 +00:00
case GDScriptParser::ClassNode::Member::ENUM_VALUE: {
GDScript: Fix infinite recursion in resolution of enum values
2023-01-13 13:17:30 +00: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 20:44:20 +00:00
if (member.enum_value.custom_value) {
Check for GDScript member and class naming conflicts in a variety of conditions.
2021-08-24 16:49:03 +00: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 02:57:35 +00: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 20:44:20 +00: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 02:57:35 +00: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 20:44:20 +00: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 16:49:03 +00: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 20:44:20 +00:00
if (member.enum_value.index > 0) {
Fix enum value regression
2022-12-17 03:46:00 +00: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 20:44:20 +00:00
} else {
member.enum_value.value = 0;
}
member.enum_value.resolved = true;
}
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00: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 20:44:20 +00:00
// Also update the original references.
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
member.enum_value.parent_enum->values.set(member.enum_value.index, member.enum_value);
Assorted enum and native type fixes
2022-12-04 03:02:03 +00: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 20:44:20 +00:00
} break;
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
case GDScriptParser::ClassNode::Member::CLASS:
Check for GDScript member and class naming conflicts in a variety of conditions.
2021-08-24 16:49:03 +00: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 02:57:35 +00: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 16:49:03 +00:00
break;
Add grouping annotations for class properties in GDScript
2022-07-03 19:30:08 +00:00
case GDScriptParser::ClassNode::Member::GROUP:
// No-op, but needed to silence warnings.
break;
Add new GDScript type checker
2020-06-10 22:53:25 +00: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-01 22:14:56 +00:00
break;
}
}
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00: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;
}
GDScript: Fix `@warning_ignore` annotation issues
2024-02-28 14:23:11 +00:00
if (!p_class->resolved_interface) {
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 14:10:35 +00:00
#ifdef DEBUG_ENABLED
GDScript: Fix `@warning_ignore` annotation issues
2024-02-28 14:23:11 +00:00
bool has_static_data = p_class->has_static_data;
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 14:10:35 +00:00
#endif
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
if (!parser->has_class(p_class)) {
String script_path = p_class->get_datatype().script_path;
GDScript: invalidate GDScriptParserRef when reloading
2024-04-12 23:13:25 +00:00
Ref<GDScriptParserRef> parser_ref = parser->get_depended_parser_for(script_path);
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
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;
}
GDScript: Fix `@warning_ignore` annotation issues
2024-02-28 14:23:11 +00:00
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
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-10 22:53:25 +00:00
}
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00: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 14:10:35 +00: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 02:57:35 +00: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 14:10:35 +00:00
#endif
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
}
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
}
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00: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-10 22:53:25 +00:00
}
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00: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-10 22:53:25 +00:00
if (p_class->resolved_body) {
return;
}
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
if (!parser->has_class(p_class)) {
String script_path = p_class->get_datatype().script_path;
GDScript: invalidate GDScriptParserRef when reloading
2024-04-12 23:13:25 +00:00
Ref<GDScriptParserRef> parser_ref = parser->get_depended_parser_for(script_path);
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
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-10 22:53:25 +00: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 02:57:35 +00: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 13:25:15 +00:00
// Do functions, properties, and groups now.
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 05:04:43 +00: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 17:12:33 +00:00
resolve_annotation(E);
GDScript: Add error when exporting node in non [Node]-derived classes
2023-10-05 10:50:26 +00:00
E->apply(parser, member.function, p_class);
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 05:04:43 +00:00
}
GDScript: Add annotation to ignore warnings
2022-01-04 12:32:43 +00: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 05:04:43 +00: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) {
Add "untyped_declaration" warning
2023-09-05 17:56:37 +00:00
member.variable->getter->return_type = member.variable->datatype_specifier;
member.variable->getter->set_datatype(member.get_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 13:57:30 +00: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 05:04:43 +00:00
resolve_function_body(member.variable->getter);
}
if (member.variable->setter != nullptr) {
Add "untyped_declaration" warning
2023-09-05 17:56:37 +00:00
ERR_CONTINUE(member.variable->setter->parameters.is_empty());
member.variable->setter->parameters[0]->datatype_specifier = member.variable->datatype_specifier;
member.variable->setter->parameters[0]->set_datatype(member.get_datatype());
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 05:04:43 +00:00
resolve_function_body(member.variable->setter);
}
}
GDScript: Fix broken export group annotations
2023-01-27 13:25:15 +00:00
} else if (member.type == GDScriptParser::ClassNode::Member::GROUP) {
// Apply annotation (`@export_{category,group,subgroup}`).
resolve_annotation(member.annotation);
GDScript: Add error when exporting node in non [Node]-derived classes
2023-10-05 10:50:26 +00:00
member.annotation->apply(parser, nullptr, p_class);
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 13:57:30 +00:00
}
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 05:04:43 +00: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-11 22:31:28 +00: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 05:04:43 +00:00
if (member.type == GDScriptParser::ClassNode::Member::VARIABLE) {
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00:00
#ifdef 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 05:04:43 +00: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 00:38:26 +00: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 05:04:43 +00:00
[godot#68001] Fix property getter with custom return type
2022-10-30 00:38:26 +00: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 05:04:43 +00:00
#ifdef DEBUG_ENABLED
[godot#68001] Fix property getter with custom return type
2022-10-30 00:38:26 +00: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 05:04:43 +00:00
#endif
[godot#68001] Fix property getter with custom return type
2022-10-30 00:38:26 +00: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 05:04:43 +00: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 07:01:16 +00: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 05:04:43 +00:00
parser->push_warning(member.variable, GDScriptWarning::NARROWING_CONVERSION);
}
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00: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 05:04:43 +00: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 11:08:48 +00:00
}
GDScript: Fix `@warning_ignore` annotation issues
2024-02-28 14:23:11 +00:00
} else if (member.type == GDScriptParser::ClassNode::Member::SIGNAL) {
GDScript: Add annotation to ignore warnings
2022-01-04 12:32:43 +00:00
#ifdef DEBUG_ENABLED
GDScript: Fix `@warning_ignore` annotation issues
2024-02-28 14:23:11 +00:00
if (member.signal->usages == 0) {
parser->push_warning(member.signal->identifier, GDScriptWarning::UNUSED_SIGNAL, member.signal->identifier->name);
}
#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 05:04:43 +00:00
}
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-11 22:31:28 +00:00
}
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
GDScript: Fix lambda resolution with cyclic references
2023-08-23 09:37:18 +00: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 02:57:35 +00: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-10 22:53:25 +00:00
}
Implement RETURN_VALUE_DISCARDED warning in GDscript
2022-10-13 17:31:12 +00:00
void GDScriptAnalyzer::resolve_node(GDScriptParser::Node *p_node, bool p_is_root) {
[Modules] Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-09 15:40:07 +00:00
ERR_FAIL_NULL_MSG(p_node, "Trying to resolve type of a null node.");
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
switch (p_node->type) {
case GDScriptParser::Node::NONE:
break; // Unreachable.
case GDScriptParser::Node::CLASS:
GDScript: Fix `@warning_ignore` annotation issues
2024-02-28 14:23:11 +00:00
// NOTE: Currently this route is never executed, `resolve_class_*()` is called directly.
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00: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-10 22:53:25 +00:00
break;
case GDScriptParser::Node::CONSTANT:
Unify typing of variables, constants and parameters in GDScript
2022-12-22 20:43:36 +00:00
resolve_constant(static_cast<GDScriptParser::ConstantNode *>(p_node), true);
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 20:43:36 +00:00
resolve_variable(static_cast<GDScriptParser::VariableNode *>(p_node), true);
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 07:56:52 +00:00
resolve_parameter(static_cast<GDScriptParser::ParameterNode *>(p_node));
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 12:03:16 +00:00
case GDScriptParser::Node::LAMBDA:
Add new GDScript type checker
2020-06-10 22:53:25 +00: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-16 23:16:24 +00:00
case GDScriptParser::Node::TYPE_TEST:
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
case GDScriptParser::Node::UNARY_OPERATOR:
Implement RETURN_VALUE_DISCARDED warning in GDscript
2022-10-13 17:31:12 +00:00
reduce_expression(static_cast<GDScriptParser::ExpressionNode *>(p_node), p_is_root);
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 05:41:03 +00:00
case GDScriptParser::Node::FUNCTION:
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 17:12:33 +00: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 14:57:22 +00:00
if (p_annotation->is_resolved) {
return;
}
p_annotation->is_resolved = true;
GDScript: Allow constant expressions in annotations
2023-01-18 17:12:33 +00: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-10 22:53:25 +00:00
}
GDScript: Fix typing of lambda functions
2022-12-28 05:41:03 +00: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 02:57:35 +00:00
if (p_source == nullptr) {
p_source = p_function;
}
GDScript: Fix typing of lambda functions
2022-12-28 05:41:03 +00:00
StringName function_name = p_function->identifier != nullptr ? p_function->identifier->name : StringName();
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
if (p_function->get_datatype().is_resolving()) {
GDScript: Fix typing of lambda functions
2022-12-28 05:41:03 +00: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 02:57:35 +00:00
return;
}
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
if (p_function->resolved_signature) {
return;
}
p_function->resolved_signature = true;
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 14:10:35 +00:00
bool previous_static_context = static_context;
GDScript: Fix non-static call is allowed in static var lambda body
2023-10-17 09:46:41 +00:00
if (p_is_lambda) {
// For lambdas this is determined from the context, the `static` keyword is not allowed.
p_function->is_static = static_context;
} else {
// For normal functions, this is determined in the parser by the `static` keyword.
static_context = p_function->is_static;
}
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00: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 14:55:37 +00:00
#ifdef TOOLS_ENABLED
int default_value_count = 0;
#endif // TOOLS_ENABLED
Add "untyped_declaration" warning
2023-09-05 17:56:37 +00:00
#ifdef DEBUG_ENABLED
String function_visible_name = function_name;
if (function_name == StringName()) {
function_visible_name = p_is_lambda ? "<anonymous lambda>" : "<unknown function>";
}
#endif
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
for (int i = 0; i < p_function->parameters.size(); i++) {
GDScript: parameter infer type bug fix Fix: #41772
2020-09-06 07:56:52 +00:00
resolve_parameter(p_function->parameters[i]);
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00:00
#ifdef DEBUG_ENABLED
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-11 22:31:28 +00:00
if (p_function->parameters[i]->usages == 0 && !String(p_function->parameters[i]->identifier->name).begins_with("_")) {
Add "untyped_declaration" warning
2023-09-05 17:56:37 +00:00
parser->push_warning(p_function->parameters[i]->identifier, GDScriptWarning::UNUSED_PARAMETER, function_visible_name, p_function->parameters[i]->identifier->name);
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-11 22:31:28 +00:00
}
Fix for not being able to ignore shadowing warnings on class scope
2023-04-03 13:57:41 +00: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 02:37:57 +00:00
#endif // DEBUG_ENABLED
GDScript: Fix `get_*_list()` methods return incorrect info
2023-08-28 16:20:10 +00:00
Unify typing of variables, constants and parameters in GDScript
2022-12-22 20:43:36 +00:00
if (p_function->parameters[i]->initializer) {
GDScript: Fix `get_*_list()` methods return incorrect info
2023-08-28 16:20:10 +00:00
#ifdef TOOLS_ENABLED
Fix default value count checking for inherited function
2022-03-14 14:55:37 +00:00
default_value_count++;
GDScript: Fix `get_*_list()` methods return incorrect info
2023-08-28 16:20:10 +00:00
#endif // TOOLS_ENABLED
Fix default value count checking for inherited function
2022-03-14 14:55:37 +00:00
Unify typing of variables, constants and parameters in GDScript
2022-12-22 20:43:36 +00: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 16:22:52 +00:00
} else {
p_function->default_arg_values.push_back(Variant()); // Prevent shift.
Fix default value count checking for inherited function
2022-03-14 14:55:37 +00: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 02:37:57 +00:00
}
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
}
GDScript: Fix typing of lambda functions
2022-12-28 05:41:03 +00:00
if (!p_is_lambda && function_name == GDScriptLanguage::get_singleton()->strings._init) {
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00: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 18:55:54 +00: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 01:02:44 +00: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 14:10:35 +00: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 01:02:44 +00: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 16:40:36 +00:00
if (p_function->return_type != nullptr) {
Assorted enum and native type fixes
2022-12-04 03:02:03 +00: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 16:40:36 +00: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 14:09:12 +00:00
Restore building web platform by enclosing resolve_function_signature.
2022-03-07 07:01:52 +00: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 14:09:12 +00: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 17:37:08 +00: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 14:09:12 +00: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-21 23:22:00 +00: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 14:57:22 +00: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-21 23:22:00 +00: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: Add return type covariance and parameter type contravariance
2023-09-28 08:28:28 +00:00
if (p_function->return_type != nullptr) {
// Check return type covariance.
GDScriptParser::DataType return_type = p_function->get_datatype();
if (return_type.is_variant()) {
// `is_type_compatible()` returns `true` if one of the types is `Variant`.
// Don't allow an explicitly specified `Variant` if the parent return type is narrower.
valid = valid && parent_return_type.is_variant();
} else if (return_type.kind == GDScriptParser::DataType::BUILTIN && return_type.builtin_type == Variant::NIL) {
// `is_type_compatible()` returns `true` if target is an `Object` and source is `null`.
// Don't allow `void` if the parent return type is a hard non-`void` type.
if (parent_return_type.is_hard_type() && !(parent_return_type.kind == GDScriptParser::DataType::BUILTIN && parent_return_type.builtin_type == Variant::NIL)) {
valid = false;
}
} else {
valid = valid && is_type_compatible(parent_return_type, 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 14:09:12 +00:00
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 14:55:37 +00: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 14:09:12 +00:00
GDScript: Add return type covariance and parameter type contravariance
2023-09-28 08:28:28 +00:00
if (valid) {
int i = 0;
for (const GDScriptParser::DataType &parent_par_type : parameters_types) {
// Check parameter type contravariance.
GDScriptParser::DataType current_par_type = p_function->parameters[i++]->get_datatype();
if (parent_par_type.is_variant() && parent_par_type.is_hard_type()) {
// `is_type_compatible()` returns `true` if one of the types is `Variant`.
// Don't allow narrowing a hard `Variant`.
valid = valid && current_par_type.is_variant();
} else {
valid = valid && is_type_compatible(current_par_type, parent_par_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 14:09:12 +00:00
}
if (!valid) {
// Compute parent signature as a string to show in the error message.
Assorted enum and native type fixes
2022-12-04 03:02:03 +00: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 14:09:12 +00: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 14:57:22 +00: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 14:09:12 +00:00
}
j++;
}
Improve parent signature error
2022-12-01 00:46:01 +00:00
parent_signature += ") -> ";
GDScript: Improve call analysis * Add missing `UNSAFE_CALL_ARGUMENT` warning. * Fix `Object` constructor. * Display an error for non-existent static methods.
2023-09-21 09:42:55 +00:00
const String return_type = parent_return_type.to_string_strict();
Improve parent signature error
2022-12-01 00:46:01 +00:00
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 14:09:12 +00: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 14:57:22 +00: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 14:09:12 +00:00
}
Fix default value count checking for inherited function
2022-03-14 14:55:37 +00:00
#endif // TOOLS_ENABLED
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00:00
}
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
Add "untyped_declaration" warning
2023-09-05 17:56:37 +00:00
#ifdef DEBUG_ENABLED
if (p_function->return_type == nullptr) {
parser->push_warning(p_function, GDScriptWarning::UNTYPED_DECLARATION, "Function", function_visible_name);
}
#endif
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
if (p_function->get_datatype().is_resolving()) {
p_function->set_datatype(prev_datatype);
}
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 14:10:35 +00:00
static_context = previous_static_context;
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
}
GDScript: Fix typing of lambda functions
2022-12-28 05:41:03 +00:00
void GDScriptAnalyzer::resolve_function_body(GDScriptParser::FunctionNode *p_function, bool p_is_lambda) {
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
if (p_function->resolved_body) {
return;
}
p_function->resolved_body = true;
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 07:25:03 +00:00
bool previous_static_context = static_context;
static_context = p_function->is_static;
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 22:09:30 +00:00
if (!p_function->get_datatype().is_hard_type() && p_function->body->get_datatype().is_set()) {
Add new GDScript type checker
2020-06-10 22:53:25 +00: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-11 22:31:28 +00: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 05:41:03 +00: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-11 22:31:28 +00:00
push_error(R"(Not all code paths return a value.)", p_function);
}
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
}
parser->current_function = previous_function;
GDScript: Fix calling static func from non-static is allowed
2023-05-17 07:25:03 +00:00
static_context = previous_static_context;
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
}
void GDScriptAnalyzer::decide_suite_type(GDScriptParser::Node *p_suite, GDScriptParser::Node *p_statement) {
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00:00
if (p_statement == nullptr) {
return;
}
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 17:51:56 +00:00
p_suite->datatype.type_source = GDScriptParser::DataType::INFERRED;
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 17:12:33 +00:00
// Apply annotations.
for (GDScriptParser::AnnotationNode *&E : stmt->annotations) {
resolve_annotation(E);
GDScript: Fix `@warning_ignore` annotation issues
2024-02-28 14:23:11 +00:00
E->apply(parser, stmt, nullptr); // TODO: Provide `p_class`.
GDScript: Add annotation to ignore warnings
2022-01-04 12:32:43 +00:00
}
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
resolve_node(stmt);
GDScript: Fix lambda resolution with cyclic references
2023-08-23 09:37:18 +00:00
resolve_pending_lambda_bodies();
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
decide_suite_type(p_suite, stmt);
}
}
Unify typing of variables, constants and parameters in GDScript
2022-12-22 20:43:36 +00: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 11:21:49 +00: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 20:43:36 +00: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-11 23:03:53 +00:00
specified_type = type_from_metatype(resolve_datatype(p_assignable->datatype_specifier));
Unify typing of variables, constants and parameters in GDScript
2022-12-22 20:43:36 +00: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);
Change container_element_type to vector container
2023-09-14 18:31:07 +00:00
if (has_specified_type && specified_type.has_container_element_type(0)) {
update_array_literal_element_type(array, specified_type.get_container_element_type(0));
Unify typing of variables, constants and parameters in GDScript
2022-12-22 20:43:36 +00:00
}
}
GDScript: Fix issues with typed arrays
2022-11-27 07:56:53 +00: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 20:43:36 +00: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 08:32:05 +00: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 20:43:36 +00: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 18:51:29 +00: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 20:43:36 +00: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 14:57:22 +00: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 20:43:36 +00: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 09:49:06 +00:00
p_assignable->use_conversion_assign = true;
GDScript: Fix some issues with assignments that involve untyped things
2022-12-30 07:58:07 +00: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 20:43:36 +00:00
} else if (!is_type_compatible(specified_type, initializer_type, true, p_assignable->initializer)) {
GDScript: Fix constant conversions
2023-01-22 08:32:05 +00:00
if (!is_constant && is_type_compatible(initializer_type, specified_type)) {
Unify typing of variables, constants and parameters in GDScript
2022-12-22 20:43:36 +00:00
mark_node_unsafe(p_assignable->initializer);
GDScript: Fix missing conversion for default argument values
2023-01-06 09:49:06 +00:00
p_assignable->use_conversion_assign = true;
Unify typing of variables, constants and parameters in GDScript
2022-12-22 20:43:36 +00: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);
}
Change container_element_type to vector container
2023-09-14 18:31:07 +00:00
} else if (specified_type.has_container_element_type(0) && !initializer_type.has_container_element_type(0)) {
GDScript: Fix issues with typed arrays
2022-11-27 07:56:53 +00:00
mark_node_unsafe(p_assignable->initializer);
Unify typing of variables, constants and parameters in GDScript
2022-12-22 20:43:36 +00: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
}
}
}
Add "untyped_declaration" warning
2023-09-05 17:56:37 +00:00
#ifdef DEBUG_ENABLED
GDScript: Add `INFERRED_DECLARATION` warning
2023-09-22 17:57:24 +00:00
if (!has_specified_type) {
Add "untyped_declaration" warning
2023-09-05 17:56:37 +00:00
const bool is_parameter = p_assignable->type == GDScriptParser::Node::PARAMETER;
GDScript: Add `INFERRED_DECLARATION` warning
2023-09-22 17:57:24 +00:00
const String declaration_type = is_constant ? "Constant" : (is_parameter ? "Parameter" : "Variable");
if (p_assignable->infer_datatype || is_constant) {
parser->push_warning(p_assignable, GDScriptWarning::INFERRED_DECLARATION, declaration_type, p_assignable->identifier->name);
} else {
parser->push_warning(p_assignable, GDScriptWarning::UNTYPED_DECLARATION, declaration_type, p_assignable->identifier->name);
}
GDScript: Warn when enum variable has no default The default will always be set to `0`, so if it's not a valid value in the enum, the warning is shown.
2024-04-16 14:16:36 +00:00
} else if (specified_type.kind == GDScriptParser::DataType::ENUM && p_assignable->initializer == nullptr) {
// Warn about enum variables without default value. Unless the enum defines the "0" value, then it's fine.
bool has_zero_value = false;
for (const KeyValue<StringName, int64_t> &kv : specified_type.enum_values) {
if (kv.value == 0) {
has_zero_value = true;
break;
}
}
if (!has_zero_value) {
parser->push_warning(p_assignable, GDScriptWarning::ENUM_VARIABLE_WITHOUT_DEFAULT, p_assignable->identifier->name);
}
Add "untyped_declaration" warning
2023-09-05 17:56:37 +00:00
}
#endif
Unify typing of variables, constants and parameters in GDScript
2022-12-22 20:43:36 +00:00
type.is_constant = is_constant;
GDScript: Fix infer on read-only property
2023-02-13 18:25:41 +00:00
type.is_read_only = false;
Unify typing of variables, constants and parameters in GDScript
2022-12-22 20:43:36 +00: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);
}
}
Fix for not being able to ignore shadowing warnings on class scope
2023-04-03 13:57:41 +00:00
is_shadowing(p_variable->identifier, kind, p_is_local);
Unify typing of variables, constants and parameters in GDScript
2022-12-22 20:43:36 +00: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) {
GDScript: Suppress unused constant warning with underscore The warning message mentions that local constants prefixed with `_` does not generate the warning. This commit actually implements this warning suppression.
2024-04-17 12:40:58 +00:00
if (p_constant->usages == 0 && !String(p_constant->identifier->name).begins_with("_")) {
Unify typing of variables, constants and parameters in GDScript
2022-12-22 20:43:36 +00:00
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 13:57:41 +00:00
is_shadowing(p_constant->identifier, kind, p_is_local);
Unify typing of variables, constants and parameters in GDScript
2022-12-22 20:43:36 +00: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-10 22:53:25 +00: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-17 23:48:33 +00:00
// Use int, Vector2i, Vector3i instead, which also can be used as range iterators.
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00:00
if (p_for->list && p_for->list->type == GDScriptParser::Node::CALL) {
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
GDScriptParser::CallNode *call = static_cast<GDScriptParser::CallNode *>(p_for->list);
Fixing null callee crash.
2020-08-05 19:41:46 +00:00
GDScriptParser::Node::Type callee_type = call->get_callee_type();
if (callee_type == GDScriptParser::Node::IDENTIFIER) {
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 22:01:27 +00:00
bool can_reduce = true;
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 01:25:26 +00:00
GDScriptParser::ExpressionNode *argument = call->arguments[i];
reduce_expression(argument);
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
GDScript: Fix range regression
2023-02-23 22:01:27 +00: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-10 22:53:25 +00:00
}
}
Variant reduced;
GDScript: Fix range regression
2023-02-23 22:01:27 +00:00
if (can_reduce) {
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
switch (args.size()) {
case 1:
GDScript Fix type mismatch in optimized single arg `range`
2022-11-01 16:07:40 +00:00
reduced = (int32_t)args[0];
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 14:35:07 +00: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-10 22:53:25 +00:00
}
}
}
Implement iterator variable typing in GDScript
2021-08-14 03:44:22 +00:00
GDScriptParser::DataType variable_type;
GDScript: Add static typing for `for` loop variable
2023-08-04 09:19:11 +00:00
String list_visible_type = "<unresolved type>";
Implement iterator variable typing in GDScript
2021-08-14 03:44:22 +00: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 18:18:23 +00:00
variable_type.builtin_type = Variant::INT;
GDScript: Add static typing for `for` loop variable
2023-08-04 09:19:11 +00:00
list_visible_type = "Array[int]"; // NOTE: `range()` has `Array` return type.
GDScript Check for null list in `for` loop
2021-10-02 17:53:56 +00:00
} else if (p_for->list) {
Implement RETURN_VALUE_DISCARDED warning in GDscript
2022-10-13 17:31:12 +00:00
resolve_node(p_for->list, false);
GDScript: Fix typing of iterator in for loop
2023-01-12 18:18:23 +00:00
GDScriptParser::DataType list_type = p_for->list->get_datatype();
GDScript: Add static typing for `for` loop variable
2023-08-04 09:19:11 +00:00
list_visible_type = list_type.to_string();
GDScript: Fix typing of iterator in for loop
2023-01-12 18:18:23 +00: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);
Change container_element_type to vector container
2023-09-14 18:31:07 +00:00
} else if (list_type.has_container_element_type(0)) {
variable_type = list_type.get_container_element_type(0);
GDScript: Fix typing of iterator in for loop
2023-01-12 18:18:23 +00:00
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-21 23:22:00 +00:00
BitField<MethodFlags> method_flags;
Add shorthand for using singleton string names
2023-09-04 15:01:33 +00:00
if (get_function_signature(p_for->list, false, list_type, CoreStringName(_iter_get), return_type, par_types, default_arg_count, method_flags)) {
GDScript: Fix typing of iterator in for loop
2023-01-12 18:18:23 +00: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 03:44:22 +00:00
variable_type.kind = GDScriptParser::DataType::VARIANT;
GDScript: Fix typing of iterator in for loop
2023-01-12 18:18:23 +00: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 03:44:22 +00:00
}
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
}
GDScript: Add static typing for `for` loop variable
2023-08-04 09:19:11 +00:00
GDScript Check for null list in `for` loop
2021-10-02 17:53:56 +00:00
if (p_for->variable) {
GDScript: Add static typing for `for` loop variable
2023-08-04 09:19:11 +00: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;
}
GDScript: Make array literal typed if `for` loop variable type is specified
2023-09-21 08:14:28 +00:00
if (p_for->list && p_for->list->type == GDScriptParser::Node::ARRAY) {
update_array_literal_element_type(static_cast<GDScriptParser::ArrayNode *>(p_for->list), specified_type);
}
GDScript: Add static typing for `for` loop variable
2023-08-04 09:19:11 +00:00
}
p_for->variable->set_datatype(specified_type);
} else {
p_for->variable->set_datatype(variable_type);
Add "untyped_declaration" warning
2023-09-05 17:56:37 +00:00
#ifdef DEBUG_ENABLED
GDScript: Add `INFERRED_DECLARATION` warning
2023-09-22 17:57:24 +00:00
if (variable_type.is_hard_type()) {
parser->push_warning(p_for->variable, GDScriptWarning::INFERRED_DECLARATION, R"("for" iterator variable)", p_for->variable->name);
} else {
Add "untyped_declaration" warning
2023-09-05 17:56:37 +00:00
parser->push_warning(p_for->variable, GDScriptWarning::UNTYPED_DECLARATION, R"("for" iterator variable)", p_for->variable->name);
}
#endif
GDScript: Add static typing for `for` loop variable
2023-08-04 09:19:11 +00:00
}
GDScript Check for null list in `for` loop
2021-10-02 17:53:56 +00:00
}
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 01:02:44 +00:00
#ifdef DEBUG_ENABLED
if (p_for->variable) {
Fix for not being able to ignore shadowing warnings on class scope
2023-04-03 13:57:41 +00:00
is_shadowing(p_for->variable, R"("for" iterator variable)", true);
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00:00
}
#endif
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
}
void GDScriptAnalyzer::resolve_while(GDScriptParser::WhileNode *p_while) {
Implement RETURN_VALUE_DISCARDED warning in GDscript
2022-10-13 17:31:12 +00:00
resolve_node(p_while->condition, false);
Add new GDScript type checker
2020-06-10 22:53:25 +00: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-11 22:31:28 +00:00
if (p_assert->message != nullptr) {
GDScript assert message parsing bug fixed Fix: #43540
2020-12-27 05:57:50 +00:00
reduce_expression(p_assert->message);
Allow non-constant string message for assert
2022-07-04 03:53:31 +00: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 05:57:50 +00:00
}
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-11 22:31:28 +00:00
}
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
p_assert->set_datatype(p_assert->condition->get_datatype());
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00:00
#ifdef DEBUG_ENABLED
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-11 22:31:28 +00: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 03:36:50 +00: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-11 22:31:28 +00:00
parser->push_warning(p_assert->condition, GDScriptWarning::ASSERT_ALWAYS_FALSE);
}
}
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00:00
#endif
Add new GDScript type checker
2020-06-10 22:53:25 +00: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) {
GDScript: Fix `@warning_ignore` annotation issues
2024-02-28 14:23:11 +00:00
// Apply annotations.
for (GDScriptParser::AnnotationNode *&E : p_match_branch->annotations) {
resolve_annotation(E);
E->apply(parser, p_match_branch, nullptr); // TODO: Provide `p_class`.
}
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
for (int i = 0; i < p_match_branch->patterns.size(); i++) {
resolve_match_pattern(p_match_branch->patterns[i], p_match_test);
}
GDScript: Implement pattern guards for match statement Within a match statement, it is now possible to add guards in each branch: var a = 0 match a: 0 when false: print("does not run") 0 when true: print("but this does") This allows more complex logic for deciding which branch to take.
2023-07-31 10:47:26 +00:00
if (p_match_branch->guard_body) {
resolve_suite(p_match_branch->guard_body);
}
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
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 01:02:44 +00:00
if (p_match_pattern == nullptr) {
return;
}
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 01:02:44 +00: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-10 22:53:25 +00:00
break;
case GDScriptParser::PatternNode::PT_EXPRESSION:
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00: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 22:49:14 +00: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 01:02:44 +00:00
}
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 01:02:44 +00:00
#ifdef DEBUG_ENABLED
Fix for not being able to ignore shadowing warnings on class scope
2023-04-03 13:57:41 +00:00
is_shadowing(p_match_pattern->bind, "pattern bind", true);
use correct error for unused bind match, suppress with underscore
2022-06-03 17:42:03 +00: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-11 22:31:28 +00:00
}
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00:00
#endif
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 01:02:44 +00: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 20:10:07 +00: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 01:02:44 +00:00
}
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
}
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00: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-10 22:53:25 +00: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 05:04:43 +00:00
GDScriptParser::DataType expected_type;
GDScript: Fix implicit conversions for function returns
2023-01-24 21:21:54 +00: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 05:04:43 +00:00
expected_type = parser->current_function->get_datatype();
}
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
if (p_return->return_value != nullptr) {
GDScript: Allow void functions to return calls to other void functions
2023-01-27 20:54:07 +00: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 05:12:16 +00:00
}
GDScript: Allow void functions to return calls to other void functions
2023-01-27 20:54:07 +00: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 {
Change container_element_type to vector container
2023-09-14 18:31:07 +00:00
if (p_return->return_value->type == GDScriptParser::Node::ARRAY && has_expected_type && expected_type.has_container_element_type(0)) {
update_array_literal_element_type(static_cast<GDScriptParser::ArrayNode *>(p_return->return_value), expected_type.get_container_element_type(0));
GDScript: Allow void functions to return calls to other void functions
2023-01-27 20:54:07 +00:00
}
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 08:32:05 +00:00
}
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 21:21:54 +00: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 01:02:44 +00:00
#ifdef DEBUG_ENABLED
GDScript: Fix implicit conversions for function returns
2023-01-24 21:21:54 +00: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 01:02:44 +00:00
#endif
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-11 22:31:28 +00:00
}
}
Add new GDScript type checker
2020-06-10 22:53:25 +00: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-14 23:12:01 +00:00
void GDScriptAnalyzer::reduce_expression(GDScriptParser::ExpressionNode *p_expression, bool p_is_root) {
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
// This one makes some magic happen.
Reintroduce code completion
2020-07-06 15:24:24 +00:00
if (p_expression == nullptr) {
return;
}
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 17:31:12 +00:00
reduce_call(static_cast<GDScriptParser::CallNode *>(p_expression), false, p_is_root);
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 12:03:16 +00:00
case GDScriptParser::Node::LAMBDA:
reduce_lambda(static_cast<GDScriptParser::LambdaNode *>(p_expression));
break;
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 14:02:37 +00:00
reduce_ternary_op(static_cast<GDScriptParser::TernaryOpNode *>(p_expression), p_is_root);
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
break;
GDScript: Rework type check
2023-02-16 23:16:24 +00:00
case GDScriptParser::Node::TYPE_TEST:
reduce_type_test(static_cast<GDScriptParser::TypeTestNode *>(p_expression));
break;
Add new GDScript type checker
2020-06-10 22:53:25 +00: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");
}
GDScript: Fix unresolved datatype for incomplete expressions
2023-10-13 09:52:14 +00:00
if (p_expression->get_datatype().kind == GDScriptParser::DataType::UNRESOLVED) {
// Prevent `is_type_compatible()` errors for incomplete expressions.
// The error can still occur if `reduce_*()` is called directly.
GDScriptParser::DataType dummy;
dummy.kind = GDScriptParser::DataType::VARIANT;
p_expression->set_datatype(dummy);
}
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
}
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 08:32:05 +00: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 15:32:35 +00: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 07:56:53 +00:00
void GDScriptAnalyzer::update_array_literal_element_type(GDScriptParser::ArrayNode *p_array, const GDScriptParser::DataType &p_element_type) {
GDScript: Make array literal typed if `for` loop variable type is specified
2023-09-21 08:14:28 +00:00
GDScriptParser::DataType expected_type = p_element_type;
Change container_element_type to vector container
2023-09-14 18:31:07 +00:00
expected_type.container_element_types.clear(); // Nested types (like `Array[Array[int]]`) are not currently supported.
GDScript: Make array literal typed if `for` loop variable type is specified
2023-09-21 08:14:28 +00:00
GDScript: Fix issues with typed arrays
2022-11-27 07:56:53 +00:00
for (int i = 0; i < p_array->elements.size(); i++) {
GDScriptParser::ExpressionNode *element_node = p_array->elements[i];
if (element_node->is_constant) {
GDScript: Make array literal typed if `for` loop variable type is specified
2023-09-21 08:14:28 +00:00
update_const_expression_builtin_type(element_node, expected_type, "include");
GDScript: Fix issues with typed arrays
2022-11-27 07:56:53 +00:00
}
GDScript: Make array literal typed if `for` loop variable type is specified
2023-09-21 08:14:28 +00:00
const GDScriptParser::DataType &actual_type = element_node->get_datatype();
if (actual_type.has_no_type() || actual_type.is_variant() || !actual_type.is_hard_type()) {
GDScript: Fix issues with typed arrays
2022-11-27 07:56:53 +00:00
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 15:32:35 +00:00
}
GDScript: Make array literal typed if `for` loop variable type is specified
2023-09-21 08:14:28 +00:00
if (!is_type_compatible(expected_type, actual_type, true, p_array)) {
if (is_type_compatible(actual_type, expected_type)) {
GDScript: Allow elements of a parent class in a typed array literal
2023-03-28 10:47:24 +00:00
mark_node_unsafe(element_node);
continue;
}
GDScript: Make array literal typed if `for` loop variable type is specified
2023-09-21 08:14:28 +00:00
push_error(vformat(R"(Cannot have an element of type "%s" in an array of type "Array[%s]".)", actual_type.to_string(), expected_type.to_string()), element_node);
GDScript: Fix issues with typed arrays
2022-11-27 07:56:53 +00:00
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 15:32:35 +00:00
}
}
GDScript: Fix issues with typed arrays
2022-11-27 07:56:53 +00:00
GDScriptParser::DataType array_type = p_array->get_datatype();
Change container_element_type to vector container
2023-09-14 18:31:07 +00:00
array_type.set_container_element_type(0, expected_type);
GDScript: Fix issues with typed arrays
2022-11-27 07:56:53 +00:00
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 15:32:35 +00:00
}
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
void GDScriptAnalyzer::reduce_assignment(GDScriptParser::AssignmentNode *p_assignment) {
reduce_expression(p_assignment->assigned_value);
GDScript: Don't warn on unassigned for builtin-typed variables If the type of a variable is a built-in Variant type, then it will automatically be assigned a default value based on the type. This means that the explicit initialization may be unnecessary. Thus this commit removes the warning in such case. This also changes the meaning of the unassigned warning to happen when the variable is used before being assigned, not when it has zero assignments.
2024-04-09 17:15:51 +00:00
#ifdef DEBUG_ENABLED
// Increment assignment count for local variables.
// Before we reduce the assignee because we don't want to warn about not being assigned when performing the assignment.
if (p_assignment->assignee->type == GDScriptParser::Node::IDENTIFIER) {
GDScriptParser::IdentifierNode *id = static_cast<GDScriptParser::IdentifierNode *>(p_assignment->assignee);
if (id->source == GDScriptParser::IdentifierNode::LOCAL_VARIABLE && id->variable_source) {
id->variable_source->assignments++;
}
}
#endif
reduce_expression(p_assignment->assignee);
Reintroduce code completion
2020-07-06 15:24:24 +00: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 15:32:35 +00:00
GDScriptParser::DataType assignee_type = p_assignment->assignee->get_datatype();
GDScript: Fix some bugs with static variables and functions
2023-05-16 10:03:53 +00:00
if (assignee_type.is_constant) {
GDScript: Begin making constants deep, not shallow or flat
2023-01-08 03:41:06 +00: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 17:50:08 +00:00
return;
GDScript: Fix some bugs with static variables and functions
2023-05-16 10:03:53 +00: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 17:50:08 +00: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 03:41:06 +00: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 15:32:35 +00:00
// Check if assigned value is an array literal, so we can make it a typed array too if appropriate.
Change container_element_type to vector container
2023-09-14 18:31:07 +00:00
if (p_assignment->assigned_value->type == GDScriptParser::Node::ARRAY && assignee_type.is_hard_type() && assignee_type.has_container_element_type(0)) {
update_array_literal_element_type(static_cast<GDScriptParser::ArrayNode *>(p_assignment->assigned_value), assignee_type.get_container_element_type(0));
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 15:32:35 +00:00
}
GDScript: Fix constant conversions
2023-01-22 08:32:05 +00: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 15:32:35 +00: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 07:58:07 +00: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 19:32:22 +00:00
bool compatible = true;
GDScript: Fix some issues with assignments that involve untyped things
2022-12-30 07:58:07 +00:00
bool downgrades_assignee = false;
bool downgrades_assigned = false;
Fix type mutation upon compound assignment
2021-12-26 19:32:22 +00:00
GDScriptParser::DataType op_type = assigned_value_type;
GDScript: Fix use of conversion assign for variant values
2023-01-10 23:01:11 +00:00
if (p_assignment->operation != GDScriptParser::AssignmentNode::OP_NONE && !op_type.is_variant()) {
Fix type mutation upon compound assignment
2021-12-26 19:32:22 +00: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 07:58:07 +00: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 19:32:22 +00:00
}
p_assignment->set_datatype(op_type);
GDScript arithmetic assignment type check bug fixed Fix: #40686
2020-07-25 02:27:58 +00:00
GDScript: Fix some issues with assignments that involve untyped things
2022-12-30 07:58:07 +00:00
if (assignee_is_variant) {
if (!assignee_is_hard) {
// weak variant assignee
mark_node_unsafe(p_assignment);
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
}
Fix type adjustment skipped when value is considered both not hard and not variant
2022-07-03 22:10:16 +00:00
} else {
GDScript: Fix some issues with assignments that involve untyped things
2022-12-30 07:58:07 +00: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 17:05:31 +00:00
p_assignment->use_conversion_assign = true;
GDScript: Fix some issues with assignments that involve untyped things
2022-12-30 07:58:07 +00: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-10 22:53:25 +00:00
}
GDScript: Fix some issues with assignments that involve untyped things
2022-12-30 07:58:07 +00: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 08:32:05 +00:00
if (is_type_compatible(op_type, assignee_type)) {
GDScript: Fix some issues with assignments that involve untyped things
2022-12-30 07:58:07 +00: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-10 22:53:25 +00:00
}
Change container_element_type to vector container
2023-09-14 18:31:07 +00:00
} else if (assignee_type.has_container_element_type(0) && !op_type.has_container_element_type(0)) {
GDScript: Fix issues with typed arrays
2022-11-27 07:56:53 +00:00
// 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 07:58:07 +00:00
}
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
}
}
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-11 22:31:28 +00:00
GDScript: Fix some issues with assignments that involve untyped things
2022-12-30 07:58:07 +00: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 01:02:44 +00: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 14:57:25 +00: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-11 22:31:28 +00:00
parser->push_warning(p_assignment->assigned_value, GDScriptWarning::NARROWING_CONVERSION);
}
GDScript: Don't warn on unassigned for builtin-typed variables If the type of a variable is a built-in Variant type, then it will automatically be assigned a default value based on the type. This means that the explicit initialization may be unnecessary. Thus this commit removes the warning in such case. This also changes the meaning of the unassigned warning to happen when the variable is used before being assigned, not when it has zero assignments.
2024-04-09 17:15:51 +00:00
// Check for assignment with operation before assignment.
if (p_assignment->operation != GDScriptParser::AssignmentNode::OP_NONE && p_assignment->assignee->type == GDScriptParser::Node::IDENTIFIER) {
GDScriptParser::IdentifierNode *id = static_cast<GDScriptParser::IdentifierNode *>(p_assignment->assignee);
// Use == 1 here because this assignment was already counted in the beginning of the function.
if (id->source == GDScriptParser::IdentifierNode::LOCAL_VARIABLE && id->variable_source && id->variable_source->assignments == 1) {
parser->push_warning(p_assignment, GDScriptWarning::UNASSIGNED_VARIABLE_OP_ASSIGN, id->name);
}
}
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00:00
#endif
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
}
void GDScriptAnalyzer::reduce_await(GDScriptParser::AwaitNode *p_await) {
GDScript: Fix crash on 'await' completion
2020-07-27 12:50:36 +00: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-14 23:30:06 +00:00
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-11 22:31:28 +00: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-10 22:53:25 +00:00
GDScript: Fix `await` type inference
2023-02-03 17:51:00 +00: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-14 23:30:06 +00: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 17:51:00 +00:00
await_type.is_coroutine = false;
p_await->set_datatype(await_type);
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00:00
#ifdef DEBUG_ENABLED
GDScript: Fix `await` type inference
2023-02-03 17:51:00 +00:00
GDScriptParser::DataType to_await_type = p_await->to_await->get_datatype();
GDScript: Fix false positive `REDUNDANT_AWAIT` warning
2023-03-15 19:11:02 +00: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-11 22:31:28 +00:00
parser->push_warning(p_await, GDScriptWarning::REDUNDANT_AWAIT);
}
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00:00
#endif
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
}
void GDScriptAnalyzer::reduce_binary_op(GDScriptParser::BinaryOpNode *p_binary_op) {
reduce_expression(p_binary_op->left_operand);
GDScript: Rework type check
2023-02-16 23:16:24 +00:00
reduce_expression(p_binary_op->right_operand);
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00: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 16:56:33 +00:00
left_type = p_binary_op->left_operand->get_datatype();
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00: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 16:56:33 +00:00
right_type = p_binary_op->right_operand->get_datatype();
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00: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-11 22:31:28 +00:00
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00:00
#ifdef DEBUG_ENABLED
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-11 22:31:28 +00: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 01:02:44 +00:00
#endif
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-11 22:31:28 +00:00
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 18:02:29 +00: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 14:16:31 +00:00
push_error(vformat(R"(Invalid operands to operator %s, %s and %s.)",
GDScript operator evaluation validation bug fix Fix: #40665
2020-07-24 18:02:29 +00: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-10 22:53:25 +00:00
} else {
GDScript: Rework type check
2023-02-16 23:16:24 +00:00
ERR_PRINT("Parser bug: unknown binary operation.");
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 12:53:02 +00: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-11 22:31:28 +00:00
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
return;
}
GDScriptParser::DataType result;
GDScript: Rework type check
2023-02-16 23:16:24 +00: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 09:01:18 +00: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;
GDScript: Infer type with string format operator If the left value type is known to be String, assume the format operator (`%`) will return a string, since it works with any type in the right hand side. This is also used by type inference even if the right hand type is unknown at compile time.
2024-04-09 18:49:44 +00:00
} else if (p_binary_op->variant_op == Variant::OP_MODULE && left_type.builtin_type == Variant::STRING) {
// The modulo operator (%) on string acts as formatting and will always return a string.
result.type_source = left_type.type_source;
result.kind = GDScriptParser::DataType::BUILTIN;
result.builtin_type = Variant::STRING;
GDScript: Fix wrong marking of some lines related to Variant as unsafe
2022-11-25 09:01:18 +00:00
} 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-25 23:35:53 +00:00
} else if (!result.is_hard_type()) {
GDScript: Fix missing unsafety mark for binary op with weak variables
2023-02-14 14:57:21 +00:00
mark_node_unsafe(p_binary_op);
GDScript: Fix wrong marking of some lines related to Variant as unsafe
2022-11-25 09:01:18 +00:00
}
} else {
ERR_PRINT("Parser bug: unknown binary operation.");
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 08:07:01 +00: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 17:54:41 +00: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 08:07:01 +00:00
const char *check_for_renamed_identifier(String identifier, GDScriptParser::Node::Type type) {
Add hint for identifiers renamed since Godot 3
2022-03-23 17:54:41 +00: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 08:07:01 +00:00
const char *result = get_rename_from_map(RenamesMap3To4::gdscript_properties_renames, identifier);
Add hint for identifiers renamed since Godot 3
2022-03-23 17:54:41 +00: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 08:07:01 +00:00
result = get_rename_from_map(RenamesMap3To4::enum_renames, identifier);
Add hint for identifiers renamed since Godot 3
2022-03-23 17:54:41 +00: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 08:07:01 +00:00
result = get_rename_from_map(RenamesMap3To4::color_renames, identifier);
Add hint for identifiers renamed since Godot 3
2022-03-23 17:54:41 +00: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 08:07:01 +00:00
result = get_rename_from_map(RenamesMap3To4::class_renames, identifier);
Add hint for identifiers renamed since Godot 3
2022-03-23 17:54:41 +00: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 08:07:01 +00:00
return get_rename_from_map(RenamesMap3To4::builtin_types_renames, identifier);
Add hint for identifiers renamed since Godot 3
2022-03-23 17:54:41 +00: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 08:07:01 +00:00
const char *result = get_rename_from_map(RenamesMap3To4::gdscript_function_renames, identifier);
Add hint for identifiers renamed since Godot 3
2022-03-23 17:54:41 +00: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 08:07:01 +00:00
return get_rename_from_map(RenamesMap3To4::builtin_types_renames, identifier);
Add hint for identifiers renamed since Godot 3
2022-03-23 17:54:41 +00: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 08:07:01 +00:00
#endif // SUGGEST_GODOT4_RENAMES
Add hint for identifiers renamed since Godot 3
2022-03-23 17:54:41 +00: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-14 23:12:01 +00:00
void GDScriptAnalyzer::reduce_call(GDScriptParser::CallNode *p_call, bool p_is_await, bool p_is_root) {
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 13:04:37 +00:00
HashMap<int, GDScriptParser::ArrayNode *> arrays; // For array literal to potentially type when passing.
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 15:32:35 +00: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-10 22:53:25 +00:00
all_is_constant = all_is_constant && p_call->arguments[i]->is_constant;
}
Fixing null callee crash.
2020-08-05 19:41:46 +00:00
GDScriptParser::Node::Type callee_type = p_call->get_callee_type();
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
GDScriptParser::DataType call_type;
Fixing null callee crash.
2020-08-05 19:41:46 +00:00
if (!p_call->is_super && callee_type == GDScriptParser::Node::IDENTIFIER) {
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
// Call to name directly.
StringName function_name = p_call->function_name;
GDScript: Improve call analysis * Add missing `UNSAFE_CALL_ARGUMENT` warning. * Fix `Object` constructor. * Display an error for non-existent static methods.
2023-09-21 09:42:55 +00:00
if (function_name == SNAME("Object")) {
push_error(R"*(Invalid constructor "Object()", use "Object.new()" instead.)*", p_call);
p_call->set_datatype(call_type);
return;
}
Variant::Type builtin_type = GDScriptParser::get_builtin_type(function_name);
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
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;
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 12:42:22 +00: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 07:03:55 +00: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 12:42:22 +00: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:
Add PackedVector4Array Variant type Co-authored-by: A Thousand Ships <96648715+AThousandShips@users.noreply.github.com> Co-authored-by: Rémi Verschelde <rverschelde@gmail.com>
2024-04-08 14:51:34 +00:00
case Variant::PACKED_VECTOR4_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 12:42:22 +00:00
safe_to_fold = false;
break;
default:
break;
}
if (all_is_constant && safe_to_fold) {
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 03:19:09 +00:00
Variant value;
Variant::construct(builtin_type, value, (const Variant **)args.ptr(), args.size(), err);
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
switch (err.error) {
case Callable::CallError::CALL_ERROR_INVALID_ARGUMENT:
GDScript: Improve call analysis * Add missing `UNSAFE_CALL_ARGUMENT` warning. * Fix `Object` constructor. * Display an error for non-existent static methods.
2023-09-21 09:42:55 +00: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-10 22:53:25 +00: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 16:12:18 +00:00
signature += ")";
Add new GDScript type checker
2020-06-10 22:53:25 +00: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:
GDScript: Improve call analysis * Add missing `UNSAFE_CALL_ARGUMENT` warning. * Fix `Object` constructor. * Display an error for non-existent static methods.
2023-09-21 09:42:55 +00:00
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);
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
break;
case Callable::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS:
GDScript: Improve call analysis * Add missing `UNSAFE_CALL_ARGUMENT` warning. * Fix `Object` constructor. * Display an error for non-existent static methods.
2023-09-21 09:42:55 +00:00
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);
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
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 20:10:04 +00:00
case Callable::CallError::CALL_ERROR_METHOD_NOT_CONST:
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 {
// 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();
GDScript: Improve call analysis * Add missing `UNSAFE_CALL_ARGUMENT` warning. * Fix `Object` constructor. * Display an error for non-existent static methods.
2023-09-21 09:42:55 +00:00
if (arg_type.is_hard_type() && !arg_type.is_variant()) {
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
if (arg_type.kind == GDScriptParser::DataType::BUILTIN && arg_type.builtin_type == builtin_type) {
// Okay.
p_call->set_datatype(call_type);
return;
}
GDScript: Improve call analysis * Add missing `UNSAFE_CALL_ARGUMENT` warning. * Fix `Object` constructor. * Display an error for non-existent static methods.
2023-09-21 09:42:55 +00:00
} else {
#ifdef DEBUG_ENABLED
mark_node_unsafe(p_call);
GDScript: Fix `UNSAFE_CALL_ARGUMENT` warning for `Variant` constructors
2023-09-29 19:43:56 +00:00
// Constructors support overloads.
Vector<String> types;
for (int i = 0; i < Variant::VARIANT_MAX; i++) {
if (i != builtin_type && Variant::can_convert_strict((Variant::Type)i, builtin_type)) {
types.push_back(Variant::get_type_name((Variant::Type)i));
}
}
String expected_types = function_name;
if (types.size() == 1) {
expected_types += "\" or \"" + types[0];
} else if (types.size() >= 2) {
for (int i = 0; i < types.size() - 1; i++) {
expected_types += "\", \"" + types[i];
}
expected_types += "\", or \"" + types[types.size() - 1];
}
parser->push_warning(p_call->arguments[0], GDScriptWarning::UNSAFE_CALL_ARGUMENT, "1", "constructor", function_name, expected_types, "Variant");
GDScript: Improve call analysis * Add missing `UNSAFE_CALL_ARGUMENT` warning. * Fix `Object` constructor. * Display an error for non-existent static methods.
2023-09-21 09:42:55 +00:00
#endif
p_call->set_datatype(call_type);
return;
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
}
}
GDScript: Improve call analysis * Add missing `UNSAFE_CALL_ARGUMENT` warning. * Fix `Object` constructor. * Display an error for non-existent static methods.
2023-09-21 09:42:55 +00:00
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
List<MethodInfo> constructors;
Variant::get_constructor_list(builtin_type, &constructors);
bool match = false;
Use C++ iterators for Lists in many situations
2021-07-16 03:45:57 +00:00
for (const MethodInfo &info : constructors) {
Add new GDScript type checker
2020-06-10 22:53:25 +00: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;
Reduce and prevent unnecessary random-access to `List` Random-access access to `List` when iterating is `O(n^2)` (`O(n)` when accessing a single element) * Removed subscript operator, in favor of a more explicit `get` * Added conversion from `Iterator` to `ConstIterator` * Remade existing operations into other solutions when applicable
2024-04-15 13:18:34 +00:00
{
List<PropertyInfo>::ConstIterator arg_itr = info.arguments.begin();
for (int i = 0; i < p_call->arguments.size(); ++arg_itr, ++i) {
GDScriptParser::DataType par_type = type_from_property(*arg_itr, true);
GDScriptParser::DataType arg_type = p_call->arguments[i]->get_datatype();
if (!is_type_compatible(par_type, arg_type, true)) {
types_match = false;
break;
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00:00
#ifdef DEBUG_ENABLED
Reduce and prevent unnecessary random-access to `List` Random-access access to `List` when iterating is `O(n^2)` (`O(n)` when accessing a single element) * Removed subscript operator, in favor of a more explicit `get` * Added conversion from `Iterator` to `ConstIterator` * Remade existing operations into other solutions when applicable
2024-04-15 13:18:34 +00:00
} else {
if (par_type.builtin_type == Variant::INT && arg_type.builtin_type == Variant::FLOAT && builtin_type != Variant::INT) {
parser->push_warning(p_call, GDScriptWarning::NARROWING_CONVERSION, function_name);
}
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00:00
#endif
Reduce and prevent unnecessary random-access to `List` Random-access access to `List` when iterating is `O(n^2)` (`O(n)` when accessing a single element) * Removed subscript operator, in favor of a more explicit `get` * Added conversion from `Iterator` to `ConstIterator` * Remade existing operations into other solutions when applicable
2024-04-15 13:18:34 +00:00
}
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
}
}
if (types_match) {
Reduce and prevent unnecessary random-access to `List` Random-access access to `List` when iterating is `O(n^2)` (`O(n)` when accessing a single element) * Removed subscript operator, in favor of a more explicit `get` * Added conversion from `Iterator` to `ConstIterator` * Remade existing operations into other solutions when applicable
2024-04-15 13:18:34 +00:00
List<PropertyInfo>::ConstIterator arg_itr = info.arguments.begin();
for (int i = 0; i < p_call->arguments.size(); ++arg_itr, ++i) {
GDScriptParser::DataType par_type = type_from_property(*arg_itr, true);
GDScript: Fix constant conversions
2023-01-22 08:32:05 +00:00
if (p_call->arguments[i]->is_constant) {
GDScript: Improve call analysis * Add missing `UNSAFE_CALL_ARGUMENT` warning. * Fix `Object` constructor. * Display an error for non-existent static methods.
2023-09-21 09:42:55 +00:00
update_const_expression_builtin_type(p_call->arguments[i], par_type, "pass");
}
#ifdef DEBUG_ENABLED
if (!(par_type.is_variant() && par_type.is_hard_type())) {
GDScriptParser::DataType arg_type = p_call->arguments[i]->get_datatype();
GDScript: Fix `UNSAFE_CALL_ARGUMENT` warning for `Variant` constructors
2023-09-29 19:43:56 +00:00
if (arg_type.is_variant() || !arg_type.is_hard_type()) {
GDScript: Improve call analysis * Add missing `UNSAFE_CALL_ARGUMENT` warning. * Fix `Object` constructor. * Display an error for non-existent static methods.
2023-09-21 09:42:55 +00:00
mark_node_unsafe(p_call);
GDScript: Fix `UNSAFE_CALL_ARGUMENT` warning for `Variant` constructors
2023-09-29 19:43:56 +00:00
parser->push_warning(p_call->arguments[i], GDScriptWarning::UNSAFE_CALL_ARGUMENT, itos(i + 1), "constructor", function_name, par_type.to_string(), arg_type.to_string_strict());
GDScript: Improve call analysis * Add missing `UNSAFE_CALL_ARGUMENT` warning. * Fix `Object` constructor. * Display an error for non-existent static methods.
2023-09-21 09:42:55 +00:00
}
GDScript: Fix constant conversions
2023-01-22 08:32:05 +00:00
}
GDScript: Improve call analysis * Add missing `UNSAFE_CALL_ARGUMENT` warning. * Fix `Object` constructor. * Display an error for non-existent static methods.
2023-09-21 09:42:55 +00:00
#endif
GDScript: Fix constant conversions
2023-01-22 08:32:05 +00:00
}
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 16:12:18 +00:00
signature += ")";
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 14:56:32 +00: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 12:55:05 +00: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 14:57:25 +00: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 14:56:32 +00: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) {
GDScript: Fix incorrect error message for utility functions
2023-06-30 17:40:02 +00:00
case Callable::CallError::CALL_ERROR_INVALID_ARGUMENT:
if (value.get_type() == Variant::STRING && !value.operator String().is_empty()) {
push_error(vformat(R"*(Invalid argument for "%s()" function: %s)*", function_name, value), p_call->arguments[err.argument]);
} else {
// Do not use `type_from_property()` for expected type, since utility functions use their own checks.
push_error(vformat(R"*(Invalid argument for "%s()" function: argument %d should be "%s" but is "%s".)*", function_name, err.argument + 1,
Variant::get_type_name((Variant::Type)err.expected), p_call->arguments[err.argument]->get_datatype().to_string()),
p_call->arguments[err.argument]);
}
break;
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 14:56:32 +00:00
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 20:10:04 +00: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 14:56:32 +00: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-10 22:53:25 +00:00
GDScript: Allow using await on calls to void functions
2023-01-09 12:55:05 +00: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 14:57:25 +00: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 14:56:32 +00:00
if (all_is_constant && Variant::get_utility_function_type(function_name) == Variant::UTILITY_FUNC_TYPE_MATH) {
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 14:56:32 +00:00
Variant::call_utility_function(function_name, &value, (const Variant **)args.ptr(), args.size(), err);
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
switch (err.error) {
GDScript: Fix incorrect error message for utility functions
2023-06-30 17:40:02 +00:00
case Callable::CallError::CALL_ERROR_INVALID_ARGUMENT:
if (value.get_type() == Variant::STRING && !value.operator String().is_empty()) {
push_error(vformat(R"*(Invalid argument for "%s()" function: %s)*", function_name, value), p_call->arguments[err.argument]);
Fix math utility functions crashing when invalid args passed
2022-10-30 21:24:39 +00:00
} else {
GDScript: Fix incorrect error message for utility functions
2023-06-30 17:40:02 +00:00
// Do not use `type_from_property()` for expected type, since utility functions use their own checks.
push_error(vformat(R"*(Invalid argument for "%s()" function: argument %d should be "%s" but is "%s".)*", function_name, err.argument + 1,
Variant::get_type_name((Variant::Type)err.expected), p_call->arguments[err.argument]->get_datatype().to_string()),
p_call->arguments[err.argument]);
Fix math utility functions crashing when invalid args passed
2022-10-30 21:24:39 +00:00
}
GDScript: Fix incorrect error message for utility functions
2023-06-30 17:40:02 +00:00
break;
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
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 14:56:32 +00:00
push_error(vformat(R"(Invalid call for function "%s".)", function_name), p_call);
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 14:56:32 +00: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-10 22:53:25 +00: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 14:56:32 +00: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-10 22:53:25 +00: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 20:10:04 +00:00
case Callable::CallError::CALL_ERROR_METHOD_NOT_CONST:
Add new GDScript type checker
2020-06-10 22:53:25 +00: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-11 22:31:28 +00:00
p_call->set_datatype(type_from_property(function_info.return_val));
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
return;
}
}
GDScriptParser::DataType base_type;
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-11 22:31:28 +00:00
call_type.kind = GDScriptParser::DataType::VARIANT;
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 18:33:18 +00:00
base_type.is_meta_type = false;
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 14:53:49 +00:00
GDScript: Fix lambda resolution with cyclic references
2023-08-23 09:37:18 +00: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 14:53:49 +00:00
push_error("Cannot use `super()` inside a lambda.", p_call);
}
Fixing null callee crash.
2020-08-05 19:41:46 +00:00
} else if (callee_type == GDScriptParser::Node::IDENTIFIER) {
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
base_type = parser->current_class->get_datatype();
GDScript: Fix function signature check for self calls
2021-05-26 18:33:18 +00:00
base_type.is_meta_type = false;
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
is_self = true;
Fixing null callee crash.
2020-08-05 19:41:46 +00:00
} else if (callee_type == GDScriptParser::Node::SUBSCRIPT) {
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 14:17:59 +00: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-10 22:53:25 +00:00
if (!subscript->is_attribute) {
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-11 22:31:28 +00:00
// Invalid call. Error already sent in parser.
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
// TODO: Could check if Callable here.
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-11 22:31:28 +00:00
p_call->set_datatype(call_type);
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
mark_node_unsafe(p_call);
return;
}
GDScript: Add support for builtin static method calls
2021-05-16 14:48:53 +00: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-10 22:53:25 +00:00
GDScript: Add support for builtin static method calls
2021-05-16 14:48:53 +00: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 07:58:07 +00:00
is_self = subscript->base->type == GDScriptParser::Node::SELF;
GDScript: Add support for builtin static method calls
2021-05-16 14:48:53 +00:00
}
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
} else {
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-11 22:31:28 +00:00
// Invalid call. Error already sent in parser.
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
// TODO: Could check if Callable here too.
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-11 22:31:28 +00:00
p_call->set_datatype(call_type);
Add new GDScript type checker
2020-06-10 22:53:25 +00: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-21 23:22:00 +00:00
BitField<MethodFlags> method_flags;
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 14:09:12 +00: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: Prevent constructing and inheriting engine singletons
2023-09-22 07:10:22 +00:00
if (is_constructor && Engine::get_singleton()->has_singleton(base_type.native_type)) {
push_error(vformat(R"(Cannot construct native class "%s" because it is an engine singleton.)", base_type.native_type), p_call);
p_call->set_datatype(call_type);
return;
}
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-21 23:22:00 +00:00
if (get_function_signature(p_call, is_constructor, base_type, p_call->function_name, return_type, par_types, default_arg_count, method_flags)) {
GDScript: Add check for `super()` methods not being implemented
2023-09-17 15:34:18 +00:00
// If the method is implemented in the class hierarchy, the virtual flag will not be set for that MethodInfo and the search stops there.
// Virtual check only possible for super() calls because class hierarchy is known. Node/Objects may have scripts attached we don't know of at compile-time.
Don't pass `self` when calling a static function from a non-static context
2024-04-04 21:15:17 +00:00
p_call->is_static = method_flags.has_flag(METHOD_FLAG_STATIC);
GDScript: Add check for `super()` methods not being implemented
2023-09-17 15:34:18 +00:00
if (p_call->is_super && method_flags.has_flag(METHOD_FLAG_VIRTUAL)) {
push_error(vformat(R"*(Cannot call the parent class' virtual function "%s()" because it hasn't been defined.)*", p_call->function_name), p_call);
}
// If the function requires typed arrays we must make literals be typed.
Use range iterators for `Map`
2021-08-09 20:13:42 +00:00
for (const KeyValue<int, GDScriptParser::ArrayNode *> &E : arrays) {
int index = E.key;
Reduce and prevent unnecessary random-access to `List` Random-access access to `List` when iterating is `O(n^2)` (`O(n)` when accessing a single element) * Removed subscript operator, in favor of a more explicit `get` * Added conversion from `Iterator` to `ConstIterator` * Remade existing operations into other solutions when applicable
2024-04-15 13:18:34 +00:00
if (index < par_types.size() && par_types.get(index).is_hard_type() && par_types.get(index).has_container_element_type(0)) {
update_array_literal_element_type(E.value, par_types.get(index).get_container_element_type(0));
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 15:32:35 +00: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-21 23:22:00 +00: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-10 22:53:25 +00: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 16:57:24 +00: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;
}
Don't pass `self` when calling a static function from a non-static context
2024-04-04 21:15:17 +00:00
if (is_self && static_context && !p_call->is_static) {
GDScript: Fix non-static call is allowed in static var lambda body
2023-10-17 09:46:41 +00:00
// Get the parent function above any lambda.
GDScriptParser::FunctionNode *parent_function = parser->current_function;
while (parent_function && parent_function->source_lambda) {
parent_function = parent_function->source_lambda->parent_function;
}
if (parent_function) {
GDScript: Fix access non-static members in static context
2024-05-01 13:49:12 +00:00
push_error(vformat(R"*(Cannot call non-static function "%s()" from the static function "%s()".)*", p_call->function_name, parent_function->identifier->name), p_call);
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 14:10:35 +00:00
} else {
GDScript: Fix non-static call is allowed in static var lambda body
2023-10-17 09:46:41 +00:00
push_error(vformat(R"*(Cannot call non-static function "%s()" from a static variable initializer.)*", p_call->function_name), p_call);
GDScript: Allow using self in lambdas
2022-04-20 17:22:22 +00:00
}
Don't pass `self` when calling a static function from a non-static context
2024-04-04 21:15:17 +00:00
} else if (!is_self && base_type.is_meta_type && !p_call->is_static) {
GDScript: Fix inner classes and preloaded scripts as types
2021-05-26 12:23:17 +00: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 14:53:49 +00: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);
Don't pass `self` when calling a static function from a non-static context
2024-04-04 21:15:17 +00:00
} else if (is_self && !p_call->is_static) {
GDScript: Allow using self in lambdas
2022-04-20 17:22:22 +00:00
mark_lambda_use_self();
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
}
GDScript: Allow using await on calls to void functions
2023-01-09 12:55:05 +00: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 14:57:25 +00: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 17:31:12 +00:00
#ifdef DEBUG_ENABLED
GDScript: Fix `STANDALONE_EXPRESSION` warning for `preload()`
2024-05-16 19:11:56 +00:00
// FIXME: No warning for built-in constructors and utilities due to early return.
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 13:21:25 +00: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 17:31:12 +00: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 19:42:11 +00:00
GDScript: Adjust STATIC_CALLED_ON_INSTANCE warning to not default to the native type, and to not trigger on self-calls Not defaulting to the native type rationale: Defaulting to the native type is less than useful, as: * There are very few native types that are extensible and have static methods. * Defaulting to the native type does not account for a method being script-defined. While the "real fix" would be to carefully track the source of the method, the get_function_signature method is already complicated enough. This will at least ensure the resulting code should always be valid. Not triggering on self-calls rationale: Found in PR comment https://github.com/godotengine/godot/pull/85918#issuecomment-1935864459 ``` static func example(): pass func example2(): example() # self-call on static function ``` Disabling this warning on self-calls is: * Consistent with other languages * Important for anonymous classes (where the output code is unusable)
2023-12-08 12:26:44 +00:00
if (method_flags.has_flag(METHOD_FLAG_STATIC) && !is_constructor && !base_type.is_meta_type && !is_self) {
String caller_type = base_type.to_string();
Ensure class name is printed in STATIC_CALLED_ON_INSTANCE warning
2022-11-24 20:06:11 +00:00
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 19:42:11 +00:00
}
Implement RETURN_VALUE_DISCARDED warning in GDscript
2022-10-13 17:31:12 +00:00
#endif // DEBUG_ENABLED
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-11 22:31:28 +00:00
call_type = return_type;
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
} else {
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-11 22:31:28 +00:00
bool found = false;
GDScript: Add support for static method calls in native types
2022-04-06 17:14:38 +00:00
Assorted enum and native type fixes
2022-12-04 03:02:03 +00: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 14:57:22 +00: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 03:02:03 +00: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-11 22:31:28 +00:00
GDScriptParser::IdentifierNode *callee_id;
Fixing null callee crash.
2020-08-05 19:41:46 +00:00
if (callee_type == GDScriptParser::Node::IDENTIFIER) {
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-11 22:31:28 +00: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 01:02:44 +00:00
if (callee_id) {
reduce_identifier_from_base(callee_id, &base_type);
Fixing null callee crash.
2020-08-05 19:41:46 +00: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 01:02:44 +00:00
found = true;
Fixing null callee crash.
2020-08-05 19:41:46 +00:00
if (callee_datatype.builtin_type == Variant::CALLABLE) {
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00: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 19:41:46 +00: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 01:02:44 +00:00
}
#ifdef DEBUG_ENABLED
GDScript builtin invalid function call crash fix Fix: #44852
2021-01-03 13:14:01 +00: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 01:02:44 +00: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-11 22:31:28 +00:00
}
}
}
GDScript builtin invalid function call crash fix Fix: #44852
2021-01-03 13:14:01 +00: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-11 22:31:28 +00: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 08:07:01 +00:00
#ifdef SUGGEST_GODOT4_RENAMES
GDScript: Allow utility functions to be used as `Callable`
2024-01-05 10:56:42 +00:00
String rename_hint;
if (GLOBAL_GET(GDScriptWarning::get_settings_path_from_code(GDScriptWarning::RENAMED_IN_GODOT_4_HINT)).booleanize()) {
Add hint for identifiers renamed since Godot 3
2022-03-23 17:54:41 +00: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 08:07:01 +00:00
#endif // SUGGEST_GODOT4_RENAMES
GDScript: Improve call analysis * Add missing `UNSAFE_CALL_ARGUMENT` warning. * Fix `Object` constructor. * Display an error for non-existent static methods.
2023-09-21 09:42:55 +00:00
} else if (!found && (!p_call->is_super && base_type.is_hard_type() && base_type.is_meta_type)) {
push_error(vformat(R"*(Static function "%s()" not found in base "%s".)*", p_call->function_name, base_type.to_string()), p_call);
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-11 22:31:28 +00: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-14 23:12:01 +00: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 14:53:49 +00: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-10 22:53:25 +00:00
}
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-11 22:31:28 +00:00
p_call->set_datatype(call_type);
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
}
void GDScriptAnalyzer::reduce_cast(GDScriptParser::CastNode *p_cast) {
reduce_expression(p_cast->operand);
GDScript: Fix small inconsistencies with resolve_datatype
2023-01-11 23:03:53 +00:00
GDScriptParser::DataType cast_type = type_from_metatype(resolve_datatype(p_cast->cast_type));
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 14:34:33 +00:00
mark_node_unsafe(p_cast);
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
return;
}
p_cast->set_datatype(cast_type);
GDScript: Fix constant conversions
2023-01-22 08:32:05 +00: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-10 22:53:25 +00:00
Change container_element_type to vector container
2023-09-14 18:31:07 +00:00
if (p_cast->operand->type == GDScriptParser::Node::ARRAY && cast_type.has_container_element_type(0)) {
update_array_literal_element_type(static_cast<GDScriptParser::ArrayNode *>(p_cast->operand), cast_type.get_container_element_type(0));
GDScript: Fix issues with typed arrays
2022-11-27 07:56:53 +00:00
}
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
if (!cast_type.is_variant()) {
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00:00
GDScriptParser::DataType op_type = p_cast->operand->get_datatype();
GDScript: Fix constant conversions
2023-01-22 08:32:05 +00:00
if (op_type.is_variant() || !op_type.is_hard_type()) {
mark_node_unsafe(p_cast);
#ifdef DEBUG_ENABLED
GDScript: Fix `UNSAFE_CAST` warning
2023-10-27 08:08:54 +00:00
parser->push_warning(p_cast, GDScriptWarning::UNSAFE_CAST, cast_type.to_string());
GDScript: Fix constant conversions
2023-01-22 08:32:05 +00:00
#endif
} else {
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00:00
bool valid = false;
GDScript: Fix constant conversions
2023-01-22 08:32:05 +00:00
if (op_type.builtin_type == Variant::INT && cast_type.kind == GDScriptParser::DataType::ENUM) {
mark_node_unsafe(p_cast);
valid = true;
GDScript: Allow casting enum to int An enum value is always an integer so the cast is valid. The code here now consider this case to avoid giving an error message.
2024-04-12 14:49:21 +00:00
} else if (op_type.kind == GDScriptParser::DataType::ENUM && cast_type.builtin_type == Variant::INT) {
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 14:34:33 +00: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 01:02:44 +00: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-10 22:53:25 +00:00
GDScript: Fix constant conversions
2023-01-22 08:32:05 +00:00
if (!valid) {
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00: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-10 22:53:25 +00:00
}
}
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-11 22:31:28 +00:00
}
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
}
void GDScriptAnalyzer::reduce_dictionary(GDScriptParser::DictionaryNode *p_dictionary) {
Unify String and StringName
2022-12-06 02:46:47 +00:00
HashMap<Variant, GDScriptParser::ExpressionNode *, VariantHasher, StringLikeVariantComparator> elements;
GDScript: Check duplicate keys in dictionaries and enums
2020-08-19 14:14:16 +00:00
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 01:02:44 +00:00
if (p_dictionary->style == GDScriptParser::DictionaryNode::PYTHON_DICT) {
reduce_expression(element.key);
}
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
reduce_expression(element.value);
GDScript: Check duplicate keys in dictionaries and enums
2020-08-19 14:14:16 +00: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-10 22:53:25 +00: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 09:19:14 +00: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-10 22:53:25 +00:00
GDScript: Check `get_node()` shorthand in static functions
2023-06-22 09:19:14 +00: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-10 22:53:25 +00:00
}
GDScript: Allow using self in lambdas
2022-04-20 17:22:22 +00:00
mark_lambda_use_self();
GDScript: Check `get_node()` shorthand in static functions
2023-06-22 09:19:14 +00: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-10 22:53:25 +00: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 15:27:48 +00: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 11:20:00 +00:00
GDScriptParser::DataType type;
Add GDScript resource export.
2022-04-25 04:33:18 +00:00
String path = ScriptServer::get_global_class_path(p_class_name);
String ext = path.get_extension();
if (ext == GDScriptLanguage::get_singleton()->get_extension()) {
GDScript: invalidate GDScriptParserRef when reloading
2024-04-12 23:13:25 +00:00
Ref<GDScriptParserRef> ref = parser->get_depended_parser_for(path);
Add GDScript resource export.
2022-04-25 04:33:18 +00:00
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 02:57:35 +00:00
Error err = ref->raise_status(GDScriptParserRef::INHERITANCE_SOLVED);
Add GDScript resource export.
2022-04-25 04:33:18 +00: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 10:21:15 +00:00
return ref->get_parser()->head->get_datatype();
Add GDScript resource export.
2022-04-25 04:33:18 +00:00
} else {
GDScript: Fix small inconsistencies with resolve_datatype
2023-01-11 23:03:53 +00: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 15:27:48 +00:00
}
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 05:38:53 +00: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 compilation of expressions compiling other classes This PR is part of ongoing work on fixing cyclic dependencies in the GDScript compiler.
2023-09-12 15:11:09 +00:00
Ref<GDScript> scr = GDScriptCache::get_shallow_script(p_identifier_datatype.script_path, err, parser->script_path);
GDScript: Fix issues with typed arrays
2022-11-27 07:56:53 +00:00
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 05:38:53 +00:00
p_identifier->is_constant = true;
}
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 02:57:35 +00:00
if (!p_identifier->get_datatype().has_no_type()) {
return;
}
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 02:55:35 +00:00
StringName name = p_identifier->name;
Added support for enums to be used as types in GDScript
2020-06-12 00:49:58 +00: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 16:57:24 +00: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 03:02:03 +00: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 16:57:24 +00:00
p_identifier->is_constant = true;
p_identifier->reduced_value = base.enum_values[name];
return;
}
Assorted enum and native type fixes
2022-12-04 03:02:03 +00: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 16:57:24 +00: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 00:49:58 +00: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 12:53:02 +00:00
p_identifier->set_datatype(type_from_variant(result, p_identifier));
GDScript: Avoid inferred types from giving hard errors
2021-09-17 14:52:30 +00: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 08:07:01 +00:00
#ifdef SUGGEST_GODOT4_RENAMES
GDScript: Allow utility functions to be used as `Callable`
2024-01-05 10:56:42 +00:00
String rename_hint;
if (GLOBAL_GET(GDScriptWarning::get_settings_path_from_code(GDScriptWarning::RENAMED_IN_GODOT_4_HINT)).booleanize()) {
Add hint for identifiers renamed since Godot 3
2022-03-23 17:54:41 +00: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 08:07:01 +00:00
#endif // SUGGEST_GODOT4_RENAMES
Added support for enums to be used as types in GDScript
2020-06-12 00:49:58 +00:00
}
} else {
fixed parser error when indexing a dictionary. Fix: #41707
2020-09-02 15:08:49 +00:00
switch (base.builtin_type) {
case Variant::NIL: {
GDScript: Avoid inferred types from giving hard errors
2021-09-17 14:52:30 +00:00
if (base.is_hard_type()) {
GDScript: Improve error messages for invalid indexing These errors are very common when using an invalid property name or calling on an object of the wrong type, and the previous message was a bit cryptic for users. Co-authored-by: Rémi Verschelde <rverschelde@gmail.com> Co-authored-by: golfinq <golfinqz@gmail.com>
2022-10-05 18:49:35 +00:00
push_error(vformat(R"(Cannot get property "%s" on a null object.)", name), p_identifier);
GDScript: Avoid inferred types from giving hard errors
2021-09-17 14:52:30 +00:00
}
Added support for enums to be used as types in GDScript
2020-06-12 00:49:58 +00:00
return;
}
fixed parser error when indexing a dictionary. Fix: #41707
2020-09-02 15:08:49 +00: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 03:19:09 +00:00
Variant dummy;
Variant::construct(base.builtin_type, dummy, nullptr, 0, temp);
fixed parser error when indexing a dictionary. Fix: #41707
2020-09-02 15:08:49 +00:00
List<PropertyInfo> properties;
dummy.get_property_list(&properties);
Use C++ iterators for Lists in many situations
2021-07-16 03:45:57 +00:00
for (const PropertyInfo &prop : properties) {
fixed parser error when indexing a dictionary. Fix: #41707
2020-09-02 15:08:49 +00:00
if (prop.name == name) {
p_identifier->set_datatype(type_from_property(prop));
return;
}
}
Core: Allow methods of built-in `Variant` types to be used as Callables
2023-09-24 20:33:28 +00:00
if (Variant::has_builtin_method(base.builtin_type, name)) {
p_identifier->set_datatype(make_callable_type(Variant::get_builtin_method_info(base.builtin_type, name)));
return;
}
GDScript: Avoid inferred types from giving hard errors
2021-09-17 14:52:30 +00: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 08:07:01 +00:00
#ifdef SUGGEST_GODOT4_RENAMES
GDScript: Allow utility functions to be used as `Callable`
2024-01-05 10:56:42 +00:00
String rename_hint;
if (GLOBAL_GET(GDScriptWarning::get_settings_path_from_code(GDScriptWarning::RENAMED_IN_GODOT_4_HINT)).booleanize()) {
Add hint for identifiers renamed since Godot 3
2022-03-23 17:54:41 +00: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 14:52:30 +00: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 08:07:01 +00:00
#endif // SUGGEST_GODOT4_RENAMES
GDScript: Avoid inferred types from giving hard errors
2021-09-17 14:52:30 +00:00
}
fixed parser error when indexing a dictionary. Fix: #41707
2020-09-02 15:08:49 +00:00
}
Added support for enums to be used as types in GDScript
2020-06-12 00:49:58 +00:00
}
}
return;
}
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 05:38:53 +00:00
List<GDScriptParser::ClassNode *> script_classes;
bool is_base = true;
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 05:38:53 +00:00
if (base_class != nullptr) {
get_class_node_current_scope_classes(base_class, &script_classes);
}
Fix: Get constructor as Callable
2023-02-21 02:55:35 +00: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 05:38:53 +00: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 08:22:01 +00:00
if (script_class->outer != nullptr) {
p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_CLASS;
}
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00:00
return;
}
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
Fix: Get constructor as Callable
2023-02-21 02:55:35 +00: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 05:38:53 +00: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 02:57:35 +00: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 05:38:53 +00:00
GDScriptParser::ClassNode::Member member = script_class->get_member(name);
Added support for enums to be used as types in GDScript
2020-06-12 00:49:58 +00: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 05:38:53 +00: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 00:49:58 +00: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 05:38:53 +00: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 00:49:58 +00: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 12:03:16 +00: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 05:38:53 +00:00
return;
}
case GDScriptParser::ClassNode::Member::ENUM: {
p_identifier->set_datatype(member.get_datatype());
Fix usage of Enum as constant
2022-12-27 03:06:11 +00: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 03:02:03 +00: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 05:38:53 +00: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 14:10:35 +00: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 05:38:53 +00: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 14:10:35 +00: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 05:38:53 +00:00
p_identifier->variable_source = member.variable;
member.variable->usages += 1;
return;
}
} break;
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00: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 05:38:53 +00: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;
GDScript: Fix `@warning_ignore` annotation issues
2024-02-28 14:23:11 +00:00
p_identifier->signal_source = member.signal;
member.signal->usages += 1;
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 05:38:53 +00:00
return;
Fix constant base typing in extended GDScript class
2022-12-04 21:55:40 +00: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 05:38:53 +00:00
} break;
case GDScriptParser::ClassNode::Member::FUNCTION: {
GDScript: Assume constructor to be accessible from class Since the constructor is accessed directly from the class, even if not marked `static`, it can be retrieved as a Callable without an instance.
2024-04-11 23:28:46 +00:00
if (is_base && (!base.is_meta_type || member.function->is_static || is_constructor)) {
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 05:38:53 +00:00
p_identifier->set_datatype(make_callable_type(member.function->info));
GDScript: Fix bug with identifier shadowed below in current scope
2023-07-25 11:21:49 +00:00
p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_FUNCTION;
GDScript: Fix access non-static members in static context
2024-05-01 13:49:12 +00:00
p_identifier->function_source = member.function;
p_identifier->function_source_is_static = 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 05:38:53 +00: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 11:21:49 +00: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 05:38:53 +00:00
return;
}
default: {
// Do nothing
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 05:38:53 +00: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-10 22:53:25 +00:00
}
GDScriptAnalyzer is unaware of properties from other Languages Co-authored-by: K. S. Ernest (iFire) Lee <fire@users.noreply.github.com> Co-authored-by: A Thousand Ships <96648715+AThousandShips@users.noreply.github.com>
2023-12-03 11:48:51 +00:00
// Check non-GDScript scripts.
Ref<Script> script_type = base.script_type;
if (base_class == nullptr && script_type.is_valid()) {
List<PropertyInfo> property_list;
script_type->get_script_property_list(&property_list);
for (const PropertyInfo &property_info : property_list) {
if (property_info.name != p_identifier->name) {
continue;
}
const GDScriptParser::DataType property_type = GDScriptAnalyzer::type_from_property(property_info, false, false);
p_identifier->set_datatype(property_type);
p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_VARIABLE;
return;
}
MethodInfo method_info = script_type->get_method_info(p_identifier->name);
if (method_info.name == p_identifier->name) {
p_identifier->set_datatype(make_callable_type(method_info));
p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_FUNCTION;
GDScript: Fix access non-static members in static context
2024-05-01 13:49:12 +00:00
p_identifier->function_source_is_static = method_info.flags & METHOD_FLAG_STATIC;
GDScriptAnalyzer is unaware of properties from other Languages Co-authored-by: K. S. Ernest (iFire) Lee <fire@users.noreply.github.com> Co-authored-by: A Thousand Ships <96648715+AThousandShips@users.noreply.github.com>
2023-12-03 11:48:51 +00:00
return;
}
List<MethodInfo> signal_list;
script_type->get_script_signal_list(&signal_list);
for (const MethodInfo &signal_info : signal_list) {
if (signal_info.name != p_identifier->name) {
continue;
}
const GDScriptParser::DataType signal_type = make_signal_type(signal_info);
p_identifier->set_datatype(signal_type);
p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_SIGNAL;
return;
}
HashMap<StringName, Variant> constant_map;
script_type->get_constants(&constant_map);
if (constant_map.has(p_identifier->name)) {
Variant constant = constant_map.get(p_identifier->name);
p_identifier->set_datatype(make_builtin_meta_type(constant.get_type()));
p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_CONSTANT;
return;
}
}
Fix ability to overload "script" variable
2022-11-08 22:41:50 +00: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 13:06:54 +00:00
const StringName &native = base.native_type;
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
if (class_exists(native)) {
Fix: Get constructor as Callable
2023-02-21 02:55:35 +00:00
if (is_constructor) {
name = "_init";
}
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 18:29:06 +00: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 17:50:08 +00: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 17:22:22 +00: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 18:29:06 +00:00
}
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 17:22:22 +00:00
p_identifier->source = GDScriptParser::IdentifierNode::INHERITED_VARIABLE;
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 17:22:22 +00:00
p_identifier->source = GDScriptParser::IdentifierNode::INHERITED_VARIABLE;
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
return;
}
Added support for enums to be used as types in GDScript
2020-06-12 00:49:58 +00:00
if (ClassDB::has_enum(native, name)) {
Assorted enum and native type fixes
2022-12-04 03:02:03 +00:00
p_identifier->set_datatype(make_native_enum_type(name, native));
GDScript: Allow using self in lambdas
2022-04-20 17:22:22 +00:00
p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_CONSTANT;
Added support for enums to be used as types in GDScript
2020-06-12 00:49:58 +00:00
return;
}
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
bool valid = false;
Assorted enum and native type fixes
2022-12-04 03:02:03 +00:00
Make enum/constant binds 64-bit.
2022-05-09 09:47:10 +00:00
int64_t int_constant = ClassDB::get_integer_constant(native, name, &valid);
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
if (valid) {
p_identifier->is_constant = true;
p_identifier->reduced_value = int_constant;
GDScript: Allow using self in lambdas
2022-04-20 17:22:22 +00:00
p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_CONSTANT;
Assorted enum and native type fixes
2022-12-04 03:02:03 +00: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-10 22:53:25 +00:00
}
}
}
Added support for enums to be used as types in GDScript
2020-06-12 00:49:58 +00:00
void GDScriptAnalyzer::reduce_identifier(GDScriptParser::IdentifierNode *p_identifier, bool can_be_builtin) {
Assorted enum and native type fixes
2022-12-04 03:02:03 +00: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 20:44:20 +00:00
Assorted enum and native type fixes
2022-12-04 03:02:03 +00: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 20:44:20 +00: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 14:12:27 +00:00
StringName enum_name = current_enum->identifier ? current_enum->identifier->name : UNNAMED_ENUM;
Assorted enum and native type fixes
2022-12-04 03:02:03 +00: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 20:44:20 +00: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 12:03:16 +00:00
bool found_source = false;
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 12:03:16 +00:00
found_source = true;
break;
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 12:03:16 +00:00
found_source = true;
break;
Fix using signals in lambda functions
2022-11-21 19:38:02 +00:00
case GDScriptParser::IdentifierNode::MEMBER_SIGNAL:
GDScript: Fix `@warning_ignore` annotation issues
2024-02-28 14:23:11 +00:00
p_identifier->signal_source->usages++;
[[fallthrough]];
GDScript: Allow using self in lambdas
2022-04-20 17:22:22 +00:00
case GDScriptParser::IdentifierNode::INHERITED_VARIABLE:
mark_lambda_use_self();
break;
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
case GDScriptParser::IdentifierNode::MEMBER_VARIABLE:
GDScript: Allow using self in lambdas
2022-04-20 17:22:22 +00:00
mark_lambda_use_self();
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-11 22:31:28 +00: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 14:10:35 +00:00
case GDScriptParser::IdentifierNode::STATIC_VARIABLE:
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-11 22:31:28 +00:00
case GDScriptParser::IdentifierNode::LOCAL_VARIABLE:
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 12:03:16 +00:00
found_source = true;
GDScript: Don't warn on unassigned for builtin-typed variables If the type of a variable is a built-in Variant type, then it will automatically be assigned a default value based on the type. This means that the explicit initialization may be unnecessary. Thus this commit removes the warning in such case. This also changes the meaning of the unassigned warning to happen when the variable is used before being assigned, not when it has zero assignments.
2024-04-09 17:15:51 +00:00
#ifdef DEBUG_ENABLED
if (p_identifier->variable_source && p_identifier->variable_source->assignments == 0 && !(p_identifier->get_datatype().is_hard_type() && p_identifier->get_datatype().kind == GDScriptParser::DataType::BUILTIN)) {
parser->push_warning(p_identifier, GDScriptWarning::UNASSIGNED_VARIABLE, p_identifier->name);
}
#endif
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 12:03:16 +00:00
break;
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 12:03:16 +00:00
found_source = true;
break;
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 12:03:16 +00:00
found_source = true;
} break;
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
case GDScriptParser::IdentifierNode::UNDEFINED_SOURCE:
GDScript: Fix bug with identifier shadowed below in current scope
2023-07-25 11:21:49 +00:00
case GDScriptParser::IdentifierNode::MEMBER_FUNCTION:
case GDScriptParser::IdentifierNode::MEMBER_CLASS:
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
break;
}
GDScript: Fix bug with identifier shadowed below in current scope
2023-07-25 11:21:49 +00: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-10 22:53:25 +00:00
// Not a local, so check members.
GDScript: Improve call analysis * Add missing `UNSAFE_CALL_ARGUMENT` warning. * Fix `Object` constructor. * Display an error for non-existent static methods.
2023-09-21 09:42:55 +00: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 12:03:16 +00: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) {
GDScript: Fix access non-static members in static context
2024-05-01 13:49:12 +00:00
const bool source_is_instance_variable = p_identifier->source == GDScriptParser::IdentifierNode::MEMBER_VARIABLE || p_identifier->source == GDScriptParser::IdentifierNode::INHERITED_VARIABLE;
const bool source_is_instance_function = p_identifier->source == GDScriptParser::IdentifierNode::MEMBER_FUNCTION && !p_identifier->function_source_is_static;
const bool source_is_signal = p_identifier->source == GDScriptParser::IdentifierNode::MEMBER_SIGNAL;
if (static_context && (source_is_instance_variable || source_is_instance_function || source_is_signal)) {
GDScript: Fix non-static call is allowed in static var lambda body
2023-10-17 09:46:41 +00:00
// Get the parent function above any lambda.
GDScriptParser::FunctionNode *parent_function = parser->current_function;
while (parent_function && parent_function->source_lambda) {
parent_function = parent_function->source_lambda->parent_function;
}
GDScript: Fix access non-static members in static context
2024-05-01 13:49:12 +00:00
String source_type;
if (source_is_instance_variable) {
source_type = "non-static variable";
} else if (source_is_instance_function) {
source_type = "non-static function";
} else { // source_is_signal
source_type = "signal";
}
GDScript: Fix non-static call is allowed in static var lambda body
2023-10-17 09:46:41 +00:00
if (parent_function) {
GDScript: Fix access non-static members in static context
2024-05-01 13:49:12 +00:00
push_error(vformat(R"*(Cannot access %s "%s" from the static function "%s()".)*", source_type, p_identifier->name, parent_function->identifier->name), p_identifier);
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 14:10:35 +00:00
} else {
GDScript: Fix access non-static members in static context
2024-05-01 13:49:12 +00:00
push_error(vformat(R"*(Cannot access %s "%s" from a static variable initializer.)*", source_type, p_identifier->name), p_identifier);
GDScript: Allow using self in lambdas
2022-04-20 17:22:22 +00: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 12:03:16 +00:00
}
GDScript: Fix lambda resolution with cyclic references
2023-08-23 09:37:18 +00:00
if (current_lambda != nullptr) {
GDScript: Fix access non-static members in static context
2024-05-01 13:49:12 +00:00
// If the identifier is a member variable (including the native class properties), member function, or a signal,
// we consider the lambda to be using `self`, so we keep a reference to the current instance.
if (source_is_instance_variable || source_is_instance_function || source_is_signal) {
GDScript: Allow using self in lambdas
2022-04-20 17:22:22 +00:00
mark_lambda_use_self();
return; // No need to capture.
}
GDScript: Fix lambdas capturing non-local variables
2024-05-22 07:07:31 +00:00
switch (p_identifier->source) {
case GDScriptParser::IdentifierNode::FUNCTION_PARAMETER:
case GDScriptParser::IdentifierNode::LOCAL_VARIABLE:
case GDScriptParser::IdentifierNode::LOCAL_ITERATOR:
case GDScriptParser::IdentifierNode::LOCAL_BIND:
break; // Need to capture.
case GDScriptParser::IdentifierNode::UNDEFINED_SOURCE: // A global.
case GDScriptParser::IdentifierNode::LOCAL_CONSTANT:
case GDScriptParser::IdentifierNode::MEMBER_VARIABLE:
case GDScriptParser::IdentifierNode::MEMBER_CONSTANT:
case GDScriptParser::IdentifierNode::MEMBER_FUNCTION:
case GDScriptParser::IdentifierNode::MEMBER_SIGNAL:
case GDScriptParser::IdentifierNode::MEMBER_CLASS:
case GDScriptParser::IdentifierNode::INHERITED_VARIABLE:
case GDScriptParser::IdentifierNode::STATIC_VARIABLE:
return; // No need to capture.
GDScript: Allow using self in lambdas
2022-04-20 17:22:22 +00:00
}
GDScript: Fix lambda resolution with cyclic references
2023-08-23 09:37:18 +00:00
GDScriptParser::FunctionNode *function_test = current_lambda->function;
GDScript: Allow using self in lambdas
2022-04-20 17:22:22 +00: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 12:03:16 +00:00
}
GDScript: Allow using self in lambdas
2022-04-20 17:22:22 +00:00
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
return;
}
StringName name = p_identifier->name;
p_identifier->source = GDScriptParser::IdentifierNode::UNDEFINED_SOURCE;
GDScript: Improve call analysis * Add missing `UNSAFE_CALL_ARGUMENT` warning. * Fix `Object` constructor. * Display an error for non-existent static methods.
2023-09-21 09:42:55 +00:00
// Not a local or a member, so check globals.
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 19:00:56 +00:00
Variant::Type builtin_type = GDScriptParser::get_builtin_type(name);
GDScript: Improve call analysis * Add missing `UNSAFE_CALL_ARGUMENT` warning. * Fix `Object` constructor. * Display an error for non-existent static methods.
2023-09-21 09:42:55 +00:00
if (builtin_type < Variant::VARIANT_MAX) {
Added support for enums to be used as types in GDScript
2020-06-12 00:49:58 +00: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 19:00:56 +00: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 00:49:58 +00: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-10 22:53:25 +00: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 15:27:48 +00:00
p_identifier->set_datatype(make_global_class_meta_type(name, p_identifier));
Add new GDScript type checker
2020-06-10 22:53:25 +00: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-08-31 23:08:46 +00: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.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
GDScript: Fix `native_type` is empty for autoload without script
2023-10-04 12:03:53 +00:00
result.kind = GDScriptParser::DataType::NATIVE;
result.builtin_type = Variant::OBJECT;
result.native_type = SNAME("Node");
Fix cyclic references in GDScript 2.0
2022-10-09 16:41:28 +00:00
if (ResourceLoader::get_resource_type(autoload.path) == "GDScript") {
GDScript: invalidate GDScriptParserRef when reloading
2024-04-12 23:13:25 +00:00
Ref<GDScriptParserRef> singl_parser = parser->get_depended_parser_for(autoload.path);
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 09:53:28 +00:00
if (singl_parser.is_valid()) {
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00: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-08-31 23:08:46 +00:00
if (err == OK) {
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 09:53:28 +00: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-08-31 23:08:46 +00:00
}
}
[godot#61386] Fix autoload scenes implicit types
2022-11-22 04:24:10 +00:00
} else if (ResourceLoader::get_resource_type(autoload.path) == "PackedScene") {
Unify GDScriptAnalyzer in-editor and runtime autoload checks
2022-12-20 04:09:32 +00: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-23 23:13:13 +00:00
Node *node = Object::cast_to<Node>(constant);
if (node != nullptr) {
GDScript: Fix subclass script path issues
2022-12-01 10:20:42 +00:00
Ref<GDScript> scr = node->get_script();
Fix singleton scene cyclic loading
2022-11-23 23:13:13 +00:00
if (scr.is_valid()) {
GDScript: invalidate GDScriptParserRef when reloading
2024-04-12 23:13:25 +00:00
Ref<GDScriptParserRef> singl_parser = parser->get_depended_parser_for(scr->get_script_path());
Fix singleton scene cyclic loading
2022-11-23 23:13:13 +00:00
if (singl_parser.is_valid()) {
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
Error err = singl_parser->raise_status(GDScriptParserRef::INHERITANCE_SOLVED);
Fix singleton scene cyclic loading
2022-11-23 23:13:13 +00: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 04:24:10 +00: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-08-31 23:08:46 +00: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 15:57:09 +00: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 04:09:32 +00: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 12:53:02 +00:00
p_identifier->set_datatype(type_from_variant(constant, p_identifier));
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 15:57:09 +00: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;
}
GDScript: Allow utility functions to be used as `Callable`
2024-01-05 10:56:42 +00:00
if (Variant::has_utility_function(name) || GDScriptUtilityFunctions::function_exists(name)) {
p_identifier->is_constant = true;
p_identifier->reduced_value = Callable(memnew(GDScriptUtilityCallable(name)));
MethodInfo method_info;
if (GDScriptUtilityFunctions::function_exists(name)) {
method_info = GDScriptUtilityFunctions::get_function_info(name);
} else {
method_info = Variant::get_utility_function_info(name);
}
p_identifier->set_datatype(make_callable_type(method_info));
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 15:57:09 +00:00
// 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-10 22:53:25 +00:00
// 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 08:07:01 +00:00
#ifdef SUGGEST_GODOT4_RENAMES
GDScript: Allow utility functions to be used as `Callable`
2024-01-05 10:56:42 +00:00
String rename_hint;
if (GLOBAL_GET(GDScriptWarning::get_settings_path_from_code(GDScriptWarning::RENAMED_IN_GODOT_4_HINT)).booleanize()) {
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);
Add hint for identifiers renamed since Godot 3
2022-03-23 17:54:41 +00:00
}
GDScript: Allow utility functions to be used as `Callable`
2024-01-05 10:56:42 +00:00
}
push_error(vformat(R"(Identifier "%s" not declared in the current scope.%s)", name, rename_hint), p_identifier);
Add hint for identifiers renamed since Godot 3
2022-03-23 17:54:41 +00:00
#else
GDScript: Allow utility functions to be used as `Callable`
2024-01-05 10:56:42 +00: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 08:07:01 +00:00
#endif // SUGGEST_GODOT4_RENAMES
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 12:03:16 +00: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 09:37:18 +00:00
GDScriptParser::LambdaNode *previous_lambda = current_lambda;
current_lambda = p_lambda;
GDScript: Fix typing of lambda functions
2022-12-28 05:41:03 +00:00
resolve_function_signature(p_lambda->function, p_lambda, true);
GDScript: Fix lambda resolution with cyclic references
2023-08-23 09:37:18 +00: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 12:03:16 +00:00
GDScript: Fix lambda resolution with cyclic references
2023-08-23 09:37:18 +00: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 12:03:16 +00:00
}
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 12:53:02 +00:00
p_literal->set_datatype(type_from_variant(p_literal->reduced_value, p_literal));
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
}
void GDScriptAnalyzer::reduce_preload(GDScriptParser::PreloadNode *p_preload) {
GDScript: Allow preload() to be used with constant expressions
2020-08-19 13:45:00 +00: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;
Revert "GDScript: Implement get_dependencies()" This reverts commit dc73440f899e6f32de748787e946ad762771fda0. This commit in some form is needed to fix handling of dependencies on export, but as it's also used for import, it's exposing some pre-existing issues which we need to solve first. So reverting for now to give ourselves time to iron this out for a future Godot release. Fixes #91726.
2024-05-13 14:59:43 +00:00
// TODO: Save this as script dependency.
Rename String::is_rel_path to String::is_relative_path
2021-08-29 23:43:47 +00:00
if (p_preload->resolved_path.is_relative_path()) {
Rename String `plus_file` to `path_join`
2022-08-30 00:34:01 +00: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 13:45:00 +00: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 15:52:37 +00:00
if (!ResourceLoader::exists(p_preload->resolved_path)) {
Clarified reason why a resource cannot be loaded.
2022-10-16 03:20:57 +00: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 13:45:00 +00:00
} else {
// TODO: Don't load if validating: use completion cache.
Fix cyclic references in GDScript 2.0
2022-10-09 16:41:28 +00:00
Stop caching packed scenes in GDScript cache
2023-11-29 10:35:54 +00:00
// Must load GDScript separately to permit cyclic references
// as ResourceLoader::load() detects and rejects those.
Fix cyclic references in GDScript 2.0
2022-10-09 16:41:28 +00:00
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 {
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 13:45:00 +00:00
}
}
}
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 12:53:02 +00:00
p_preload->set_datatype(type_from_variant(p_preload->reduced_value, p_preload));
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 17:22:22 +00:00
mark_lambda_use_self();
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 15:57:09 +00: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 20:03:40 +00:00
if (p_subscript->base == nullptr) {
return;
}
Added support for enums to be used as types in GDScript
2020-06-12 00:49:58 +00: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 15:57:09 +00: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 00:49:58 +00:00
} else {
reduce_expression(p_subscript->base);
}
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
GDScriptParser::DataType result_type;
if (p_subscript->is_attribute) {
Reintroduce code completion
2020-07-06 15:24:24 +00:00
if (p_subscript->attribute == nullptr) {
return;
}
Fix subscript of preloaded script
2022-12-11 12:59:43 +00:00
GDScriptParser::DataType base_type = p_subscript->base->get_datatype();
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
bool valid = false;
GDScript: Fix subscript resolution on constant non-metatype GDScript base
2024-05-30 12:52:42 +00:00
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
// If the base is a metatype, use the analyzer instead.
GDScript: Fix subscript resolution on constant non-metatype GDScript base
2024-05-30 12:52:42 +00:00
if (p_subscript->base->is_constant && !base_type.is_meta_type) {
// GH-92534. If the base is a GDScript, use the analyzer instead.
bool base_is_gdscript = false;
if (p_subscript->base->reduced_value.get_type() == Variant::OBJECT) {
Ref<GDScript> gdscript = Object::cast_to<GDScript>(p_subscript->base->reduced_value.get_validated_object());
if (gdscript.is_valid()) {
base_is_gdscript = true;
// Makes a metatype from a constant GDScript, since `base_type` is not a metatype.
GDScriptParser::DataType base_type_meta = type_from_variant(gdscript, p_subscript);
// First try to reduce the attribute from the metatype.
reduce_identifier_from_base(p_subscript->attribute, &base_type_meta);
GDScriptParser::DataType attr_type = p_subscript->attribute->get_datatype();
if (attr_type.is_set()) {
valid = !attr_type.is_pseudo_type || p_can_be_pseudo_type;
result_type = attr_type;
p_subscript->is_constant = p_subscript->attribute->is_constant;
p_subscript->reduced_value = p_subscript->attribute->reduced_value;
}
if (!valid) {
// If unsuccessful, reset and return to the normal route.
p_subscript->attribute->set_datatype(GDScriptParser::DataType());
}
}
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
}
GDScript: Fix subscript resolution on constant non-metatype GDScript base
2024-05-30 12:52:42 +00:00
if (!base_is_gdscript) {
// Just try to get it.
Variant value = p_subscript->base->reduced_value.get_named(p_subscript->attribute->name, valid);
if (valid) {
p_subscript->is_constant = true;
p_subscript->reduced_value = value;
result_type = type_from_variant(value, p_subscript);
}
}
}
if (valid) {
// Do nothing.
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00: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 15:57:09 +00:00
valid = !base_type.is_pseudo_type || p_can_be_pseudo_type;
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00: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 15:57:09 +00: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-10 22:53:25 +00:00
} else {
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00: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 15:57:09 +00:00
valid = !attr_type.is_pseudo_type || p_can_be_pseudo_type;
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00: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-18 23:36:41 +00:00
} else if (!base_type.is_meta_type || !base_type.is_constant) {
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
valid = base_type.kind != GDScriptParser::DataType::BUILTIN;
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00:00
#ifdef DEBUG_ENABLED
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00: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-10 22:53:25 +00:00
}
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
#endif
result_type.kind = GDScriptParser::DataType::VARIANT;
GDScript: Fix marking of line with unsafe property access as unsafe
2023-01-24 23:45:40 +00:00
mark_node_unsafe(p_subscript);
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
}
}
GDScript: Fix subscript resolution on constant non-metatype GDScript base
2024-05-30 12:52:42 +00:00
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00: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 15:57:09 +00: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 02:57:35 +00:00
result_type.kind = GDScriptParser::DataType::VARIANT;
}
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 18:42:33 +00:00
if (p_subscript->index == nullptr) {
return;
}
reduce_expression(p_subscript->index);
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
if (p_subscript->base->is_constant && p_subscript->index->is_constant) {
// Just try to get it.
bool valid = false;
GDScript: Fix subscript resolution on constant non-metatype GDScript base
2024-05-30 12:52:42 +00:00
// TODO: Check if `p_subscript->base->reduced_value` is GDScript.
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
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 03:41:06 +00:00
result_type.kind = GDScriptParser::DataType::VARIANT;
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 12:53:02 +00:00
result_type = type_from_variant(value, p_subscript);
Add new GDScript type checker
2020-06-10 22:53:25 +00: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_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:
Add PackedVector4Array Variant type Co-authored-by: A Thousand Ships <96648715+AThousandShips@users.noreply.github.com> Co-authored-by: Rémi Verschelde <rverschelde@gmail.com>
2024-04-08 14:51:34 +00:00
case Variant::PACKED_COLOR_ARRAY:
case Variant::PACKED_VECTOR4_ARRAY:
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
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 07:02:02 +00:00
case Variant::QUATERNION:
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
case Variant::AABB:
case Variant::OBJECT:
Unify String and StringName
2022-12-06 02:46:47 +00:00
error = index_type.builtin_type != Variant::STRING && index_type.builtin_type != Variant::STRING_NAME;
Add new GDScript type checker
2020-06-10 22:53:25 +00: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-19 23:11:13 +00:00
case Variant::VECTOR4:
case Variant::VECTOR4I:
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
case Variant::TRANSFORM2D:
Rename Variant TRANSFORM to TRANSFORM3D Also _transform to _transform3d
2021-04-28 07:36:08 +00: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-19 23:11:13 +00:00
case Variant::PROJECTION:
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
error = index_type.builtin_type != Variant::INT && index_type.builtin_type != Variant::FLOAT &&
Unify String and StringName
2022-12-06 02:46:47 +00:00
index_type.builtin_type != Variant::STRING && index_type.builtin_type != Variant::STRING_NAME;
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
break;
// Expect String or int.
case Variant::COLOR:
Unify String and StringName
2022-12-06 02:46:47 +00: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-10 22:53:25 +00: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 13:53:05 +00:00
case Variant::RID:
Add new GDScript type checker
2020-06-10 22:53:25 +00: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) {
Fix grammar typo in GDScript error message
2023-10-16 18:29:26 +00:00
push_error(vformat(R"(Only "String" or "StringName" can be used as index for type "%s", but received "%s".)", base_type.to_string(), index_type.to_string()), p_subscript->index);
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
}
}
// 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 17:35:26 +00:00
result_type.type_source = base_type.is_hard_type() ? GDScriptParser::DataType::ANNOTATED_INFERRED : GDScriptParser::DataType::INFERRED;
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
GDScript: Allow subscript on self and object types
2021-10-06 15:01:34 +00:00
if (base_type.kind != GDScriptParser::DataType::BUILTIN) {
base_type.builtin_type = Variant::OBJECT;
}
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 13:53:05 +00:00
case Variant::RID:
Add new GDScript type checker
2020-06-10 22:53:25 +00: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-19 23:11:13 +00:00
case Variant::VECTOR4I:
Add new GDScript type checker
2020-06-10 22:53:25 +00: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-19 23:11:13 +00:00
case Variant::VECTOR4:
Rename Quat to Quaternion
2021-01-20 07:02:02 +00:00
case Variant::QUATERNION:
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
result_type.builtin_type = Variant::FLOAT;
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;
Add PackedVector4Array Variant type Co-authored-by: A Thousand Ships <96648715+AThousandShips@users.noreply.github.com> Co-authored-by: Rémi Verschelde <rverschelde@gmail.com>
2024-04-08 14:51:34 +00:00
// Return Color.
case Variant::PACKED_COLOR_ARRAY:
result_type.builtin_type = Variant::COLOR;
break;
// Return Vector4.
case Variant::PACKED_VECTOR4_ARRAY:
result_type.builtin_type = Variant::VECTOR4;
break;
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
// Depends on the index.
Rename Variant TRANSFORM to TRANSFORM3D Also _transform to _transform3d
2021-04-28 07:36:08 +00: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-19 23:11:13 +00:00
case Variant::PROJECTION:
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
case Variant::PLANE:
case Variant::COLOR:
case Variant::DICTIONARY:
GDScript: Allow subscript on self and object types
2021-10-06 15:01:34 +00:00
case Variant::OBJECT:
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 15:32:35 +00:00
// Can have an element type.
case Variant::ARRAY:
Change container_element_type to vector container
2023-09-14 18:31:07 +00:00
if (base_type.has_container_element_type(0)) {
result_type = base_type.get_container_element_type(0);
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 15:32:35 +00:00
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-10 22:53:25 +00:00
// Here for completeness.
case Variant::VARIANT_MAX:
break;
}
}
}
}
p_subscript->set_datatype(result_type);
}
Allow standalone ternary expressions
2023-01-09 14:02:37 +00:00
void GDScriptAnalyzer::reduce_ternary_op(GDScriptParser::TernaryOpNode *p_ternary_op, bool p_is_root) {
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
reduce_expression(p_ternary_op->condition);
Allow standalone ternary expressions
2023-01-09 14:02:37 +00: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-10 22:53:25 +00:00
GDScriptParser::DataType result;
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00: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-10 22:53:25 +00: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 01:02:44 +00: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-10 22:53:25 +00: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 01:02:44 +00:00
#ifdef DEBUG_ENABLED
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-11 22:31:28 +00:00
parser->push_warning(p_ternary_op, GDScriptWarning::INCOMPATIBLE_TERNARY);
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00:00
#endif
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
}
}
}
GDScript: Fix type certainty for result of ternary operator
2023-02-01 12:52:18 +00: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-10 22:53:25 +00:00
p_ternary_op->set_datatype(result);
}
GDScript: Rework type check
2023-02-16 23:16:24 +00: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-10 22:53:25 +00: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-17 23:49:04 +00: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 22:15:53 +00:00
GDScriptParser::DataType operand_type = p_unary_op->operand->get_datatype();
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 12:53:02 +00:00
result = type_from_variant(p_unary_op->reduced_value, p_unary_op);
Fix unary op warnings never showing
2022-10-02 00:13:06 +00:00
}
if (operand_type.is_variant()) {
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 00:13:06 +00:00
result = get_operation_type(p_unary_op->variant_op, operand_type, valid, p_unary_op);
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
if (!valid) {
Fix unary op warnings never showing
2022-10-02 00:13:06 +00: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-10 22:53:25 +00:00
}
}
p_unary_op->set_datatype(result);
}
GDScript: Fix issues with typed arrays
2022-11-27 07:56:53 +00: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 00:14:25 +00:00
if (p_expression == nullptr) {
return value;
}
GDScript: Fix issues with typed arrays
2022-11-27 07:56:53 +00: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) {
Change container_element_type to vector container
2023-09-14 18:31:07 +00:00
Array array = p_array->get_datatype().has_container_element_type(0) ? make_array_from_element_datatype(p_array->get_datatype().get_container_element_type(0)) : Array();
GDScript: Fix issues with typed arrays
2022-11-27 07:56:53 +00:00
array.resize(p_array->elements.size());
Array/Dictinoary no more reduced to array/dictionary variant Fix: #41377 Fix: #20436 Fix: #41953
2020-09-11 14:16:20 +00: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 18:03:13 +00:00
GDScript: Fix issues with typed arrays
2022-11-27 07:56:53 +00: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 18:03:13 +00:00
}
GDScript: Fix issues with typed arrays
2022-11-27 07:56:53 +00:00
array[i] = element_value;
Array/Dictinoary no more reduced to array/dictionary variant Fix: #41377 Fix: #20436 Fix: #41953
2020-09-11 14:16:20 +00:00
}
GDScript: Fix issues with typed arrays
2022-11-27 07:56:53 +00: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 14:16:20 +00:00
}
GDScript: Fix issues with typed arrays
2022-11-27 07:56:53 +00: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 14:16:20 +00: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 18:03:13 +00:00
GDScript: Fix issues with typed arrays
2022-11-27 07:56:53 +00: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 18:03:13 +00:00
}
GDScript: Fix issues with typed arrays
2022-11-27 07:56:53 +00: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 14:16:20 +00:00
}
GDScript: Fix issues with typed arrays
2022-11-27 07:56:53 +00:00
dictionary[element_key] = element_value;
Array/Dictinoary no more reduced to array/dictionary variant Fix: #41377 Fix: #20436 Fix: #41953
2020-09-11 14:16:20 +00:00
}
GDScript: Fix issues with typed arrays
2022-11-27 07:56:53 +00: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 00:14:25 +00:00
if (p_subscript->base == nullptr || p_subscript->index == nullptr) {
return Variant();
}
GDScript: Fix issues with typed arrays
2022-11-27 07:56:53 +00: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 14:16:20 +00:00
}
GDScript: Fix issues with typed arrays
2022-11-27 07:56:53 +00: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 03:41:06 +00:00
}
GDScript: Fix issues with typed arrays
2022-11-27 07:56:53 +00: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 22:31:40 +00: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;
GDScript: Fix compilation of expressions compiling other classes This PR is part of ongoing work on fixing cyclic dependencies in the GDScript compiler.
2023-09-12 15:11:09 +00:00
Ref<GDScript> scr = GDScriptCache::get_shallow_script(p_element_datatype.script_path, err, parser->script_path);
GDScript: Fix error about enum typed arrays
2023-02-08 22:31:40 +00:00
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 07:56:53 +00:00
}
GDScript: Fix error about enum typed arrays
2023-02-08 22:31:40 +00: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 07:56:53 +00: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 15:07:50 +00:00
if (datatype.is_hard_type()) {
if (datatype.kind == GDScriptParser::DataType::BUILTIN && datatype.builtin_type != Variant::OBJECT) {
Change container_element_type to vector container
2023-09-14 18:31:07 +00:00
if (datatype.builtin_type == Variant::ARRAY && datatype.has_container_element_type(0)) {
result = make_array_from_element_datatype(datatype.get_container_element_type(0));
GDScript: Fix default value of exported enum variable
2023-02-14 15:07:50 +00:00
} 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 07:56:53 +00:00
}
}
}
return result;
Array/Dictinoary no more reduced to array/dictionary variant Fix: #41377 Fix: #20436 Fix: #41953
2020-09-11 14:16:20 +00: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 12:53:02 +00:00
GDScriptParser::DataType GDScriptAnalyzer::type_from_variant(const Variant &p_value, const GDScriptParser::Node *p_source) {
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 21:38:29 +00:00
if (p_value.get_type() == Variant::ARRAY) {
const Array &array = p_value;
if (array.get_typed_script()) {
Change container_element_type to vector container
2023-09-14 18:31:07 +00:00
result.set_container_element_type(0, type_from_metatype(make_script_meta_type(array.get_typed_script())));
Fix: Typed arrays aren't working with +
2023-02-22 21:38:29 +00:00
} else if (array.get_typed_class_name()) {
Change container_element_type to vector container
2023-09-14 18:31:07 +00:00
result.set_container_element_type(0, type_from_metatype(make_native_meta_type(array.get_typed_class_name())));
Fix: Typed arrays aren't working with +
2023-02-22 21:38:29 +00:00
} else if (array.get_typed_builtin() != Variant::NIL) {
Change container_element_type to vector container
2023-09-14 18:31:07 +00:00
result.set_container_element_type(0, type_from_metatype(make_builtin_meta_type((Variant::Type)array.get_typed_builtin())));
Fix: Typed arrays aren't working with +
2023-02-22 21:38:29 +00:00
}
} else if (p_value.get_type() == Variant::OBJECT) {
GDScript: preload should make native type
2022-12-04 10:35:41 +00:00
// Object is treated as a native type, not a builtin type.
result.kind = GDScriptParser::DataType::NATIVE;
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 16:41:28 +00: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 12:35:55 +00:00
String script_path = gds->get_script_path();
GDScript: invalidate GDScriptParserRef when reloading
2024-04-12 23:13:25 +00:00
Ref<GDScriptParserRef> ref = parser->get_depended_parser_for(script_path);
Fix cyclic references in GDScript 2.0
2022-10-09 16:41:28 +00:00
if (ref.is_null()) {
GDScript: Fix built-in script and other `find_class` bugs
2022-12-12 12:35:55 +00:00
push_error(vformat(R"(Could not find script "%s".)", script_path), p_source);
Fix cyclic references in GDScript 2.0
2022-10-09 16:41:28 +00: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 12:35:55 +00: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 02:57:35 +00:00
}
GDScript: Fix built-in script and other `find_class` bugs
2022-12-12 12:35:55 +00: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 16:41:28 +00:00
}
GDScript: Fix wrong native type for preloaded class
2023-01-03 02:54:51 +00:00
result.kind = GDScriptParser::DataType::CLASS;
result.native_type = found->get_datatype().native_type;
Fix preload type regression
2022-12-15 21:46:15 +00:00
result.class_type = found;
result.script_path = ref->get_parser()->script_path;
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
} else {
Fix cyclic references in GDScript 2.0
2022-10-09 16:41:28 +00:00
result.kind = GDScriptParser::DataType::SCRIPT;
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
result.native_type = scr->get_instance_base_type();
GDScript: Fix wrong native type for preloaded class
2023-01-03 02:54:51 +00:00
result.script_path = scr->get_path();
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
}
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
result.script_type = scr;
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 03:02:03 +00:00
GDScriptParser::DataType GDScriptAnalyzer::type_from_metatype(const GDScriptParser::DataType &p_meta_type) {
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 15:57:09 +00: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 16:57:24 +00:00
if (p_meta_type.kind == GDScriptParser::DataType::ENUM) {
result.builtin_type = Variant::INT;
Assorted enum and native type fixes
2022-12-04 03:02:03 +00: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 16:57:24 +00:00
}
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 17:50:08 +00: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-10 22:53:25 +00: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 17:50:08 +00:00
result.is_read_only = p_is_readonly;
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
result.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
GDScript: Fix getting type from PropertyInfo for Variant arguments
2022-12-27 22:11:51 +00: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-10 22:53:25 +00:00
// Variant
result.kind = GDScriptParser::DataType::VARIANT;
return result;
}
result.builtin_type = p_property.type;
if (p_property.type == Variant::OBJECT) {
Handle global classes when resolving type from `PropertyInfo`
2023-11-22 13:12:50 +00:00
if (ScriptServer::is_global_class(p_property.class_name)) {
result.kind = GDScriptParser::DataType::SCRIPT;
result.script_path = ScriptServer::get_global_class_path(p_property.class_name);
result.native_type = ScriptServer::get_global_class_native_base(p_property.class_name);
Ref<Script> scr = ResourceLoader::load(ScriptServer::get_global_class_path(p_property.class_name));
if (scr.is_valid()) {
result.script_type = scr;
}
} else {
result.kind = GDScriptParser::DataType::NATIVE;
result.native_type = p_property.class_name == StringName() ? "Object" : p_property.class_name;
}
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 15:32:35 +00: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;
GDScript: Fix `native_type` is empty for autoload without script
2023-10-04 12:03:53 +00:00
elem_type.native_type = elem_type_name;
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 15:32:35 +00:00
} 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 13:40:50 +00:00
elem_type.is_constant = false;
Change container_element_type to vector container
2023-09-14 18:31:07 +00:00
result.set_container_element_type(0, 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 14:57:22 +00: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 14:46:22 +00: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 15:57:09 +00: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 14:57:22 +00: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 15:57:09 +00: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 14:57:22 +00: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 14:46:22 +00: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 15:32:35 +00:00
}
Add new GDScript type checker
2020-06-10 22:53:25 +00: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-21 23:22:00 +00: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-10 22:53:25 +00: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 14:57:22 +00:00
if (r_native_class) {
*r_native_class = StringName();
}
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00:00
StringName function_name = p_function;
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
Assorted enum and native type fixes
2022-12-04 03:02:03 +00: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 16:57:24 +00:00
if (p_base_type.kind == GDScriptParser::DataType::ENUM) {
Assorted enum and native type fixes
2022-12-04 03:02:03 +00: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 16:57:24 +00: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-10 22:53:25 +00: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 03:19:09 +00:00
Variant dummy;
Variant::construct(p_base_type.builtin_type, dummy, nullptr, 0, err);
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 03:45:57 +00: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-21 23:22:00 +00: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 03:02:03 +00: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-21 23:22:00 +00: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 03:02:03 +00: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 12:51:51 +00:00
return true;
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
}
}
return false;
}
GDScript: Fix extending abstract classes, forbid their construction
2022-12-29 07:34:13 +00: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 14:09:12 +00: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 13:21:25 +00: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-21 23:22:00 +00:00
r_method_flags.set_flag(METHOD_FLAG_STATIC);
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00:00
}
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 01:02:44 +00: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-10 22:53:25 +00:00
// TODO: If this is Callable it can have a better error message.
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00:00
push_error(vformat(R"(Member "%s" is not a function.)", function_name), p_source);
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
return false;
}
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
resolve_class_member(base_class, function_name, p_source);
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00:00
found_function = base_class->get_member(function_name).function;
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
}
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
resolve_class_inheritance(base_class, p_source);
Add new GDScript type checker
2020-06-10 22:53:25 +00: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-21 23:22:00 +00:00
if (p_is_constructor || found_function->is_static) {
r_method_flags.set_flag(METHOD_FLAG_STATIC);
}
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 20:43:36 +00:00
if (found_function->parameters[i]->initializer != nullptr) {
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
r_default_arg_count++;
}
}
GDScript: Fix return type of constructor call for extending class
2022-12-27 20:49:26 +00: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 12:23:17 +00:00
r_return_type.is_meta_type = false;
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 04:33:18 +00:00
while (base_script.is_valid() && base_script->has_method(function_name)) {
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00:00
MethodInfo info = base_script->get_method_info(function_name);
Add new GDScript type checker
2020-06-10 22:53:25 +00: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-21 23:22:00 +00: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-10 22:53:25 +00: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 14:09:12 +00: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-10 22:53:25 +00: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 01:02:44 +00: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-21 23:22:00 +00: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-10 22:53:25 +00: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 14:09:12 +00:00
if (p_is_constructor) {
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00: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-10 22:53:25 +00:00
}
MethodInfo info;
Remove underscore hacks Way less cruft. :) Co-authored-by: Ignacio Roldán Etcheverry <neikeq@users.noreply.github.com>
2021-08-17 13:06:54 +00: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-21 23:22:00 +00: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 13:52:58 +00: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-21 23:22:00 +00: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 13:52:58 +00: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 14:57:22 +00: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 13:52:58 +00:00
return valid;
Add new GDScript type checker
2020-06-10 22:53:25 +00: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-21 23:22:00 +00: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-10 22:53:25 +00: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-21 23:22:00 +00:00
r_method_flags = p_info.flags;
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
Use C++ iterators for Lists in many situations
2021-07-16 03:45:57 +00:00
for (const PropertyInfo &E : p_info.arguments) {
GDScript: Fix getting type from PropertyInfo for Variant arguments
2022-12-27 22:11:51 +00:00
r_par_types.push_back(type_from_property(E, true));
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
}
return true;
}
GDScript: Fix constant conversions
2023-01-22 08:32:05 +00:00
void GDScriptAnalyzer::validate_call_arg(const MethodInfo &p_method, const GDScriptParser::CallNode *p_call) {
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
List<GDScriptParser::DataType> arg_types;
Use C++ iterators for Lists in many situations
2021-07-16 03:45:57 +00:00
for (const PropertyInfo &E : p_method.arguments) {
GDScript: Fix getting type from PropertyInfo for Variant arguments
2022-12-27 22:11:51 +00:00
arg_types.push_back(type_from_property(E, true));
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
}
GDScript: Fix constant conversions
2023-01-22 08:32:05 +00: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-10 22:53:25 +00:00
}
GDScript: Fix constant conversions
2023-01-22 08:32:05 +00: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-10 22:53:25 +00: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()]);
}
Reduce and prevent unnecessary random-access to `List` Random-access access to `List` when iterating is `O(n^2)` (`O(n)` when accessing a single element) * Removed subscript operator, in favor of a more explicit `get` * Added conversion from `Iterator` to `ConstIterator` * Remade existing operations into other solutions when applicable
2024-04-15 13:18:34 +00:00
List<GDScriptParser::DataType>::ConstIterator par_itr = p_par_types.begin();
for (int i = 0; i < p_call->arguments.size(); ++par_itr, ++i) {
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
if (i >= p_par_types.size()) {
// Already on vararg place.
break;
}
Reduce and prevent unnecessary random-access to `List` Random-access access to `List` when iterating is `O(n^2)` (`O(n)` when accessing a single element) * Removed subscript operator, in favor of a more explicit `get` * Added conversion from `Iterator` to `ConstIterator` * Remade existing operations into other solutions when applicable
2024-04-15 13:18:34 +00:00
GDScriptParser::DataType par_type = *par_itr;
GDScript: Fix constant conversions
2023-01-22 08:32:05 +00: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-10 22:53:25 +00:00
GDScriptParser::DataType arg_type = p_call->arguments[i]->get_datatype();
GDScript: Fix `validate_call_arg()` for unresolved datatype
2023-05-15 08:17:53 +00:00
if (arg_type.is_variant() || !arg_type.is_hard_type()) {
GDScript: Improve call analysis * Add missing `UNSAFE_CALL_ARGUMENT` warning. * Fix `Object` constructor. * Display an error for non-existent static methods.
2023-09-21 09:42:55 +00:00
#ifdef DEBUG_ENABLED
GDScript: Fix `validate_call_arg()` for unresolved datatype
2023-05-15 08:17:53 +00:00
// 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: Fix `UNSAFE_CALL_ARGUMENT` warning for `Variant` constructors
2023-09-29 19:43:56 +00:00
parser->push_warning(p_call->arguments[i], GDScriptWarning::UNSAFE_CALL_ARGUMENT, itos(i + 1), "function", p_call->function_name, par_type.to_string(), arg_type.to_string_strict());
GDScript: Fix `validate_call_arg()` for unresolved datatype
2023-05-15 08:17:53 +00:00
}
GDScript: Improve call analysis * Add missing `UNSAFE_CALL_ARGUMENT` warning. * Fix `Object` constructor. * Display an error for non-existent static methods.
2023-09-21 09:42:55 +00:00
#endif
GDScript: parameter infer type bug fix Fix: #41772
2020-09-06 07:56:52 +00:00
} else if (par_type.is_hard_type() && !is_type_compatible(par_type, arg_type, true)) {
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
if (!is_type_compatible(arg_type, par_type)) {
Assorted enum and native type fixes
2022-12-04 03:02:03 +00: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-10 22:53:25 +00:00
p_call->function_name, i + 1, par_type.to_string(), arg_type.to_string()),
p_call->arguments[i]);
GDScript: Improve call analysis * Add missing `UNSAFE_CALL_ARGUMENT` warning. * Fix `Object` constructor. * Display an error for non-existent static methods.
2023-09-21 09:42:55 +00:00
#ifdef DEBUG_ENABLED
} else {
// Supertypes are acceptable for dynamic compliance, but it's unsafe.
mark_node_unsafe(p_call);
GDScript: Fix `UNSAFE_CALL_ARGUMENT` warning for `Variant` constructors
2023-09-29 19:43:56 +00:00
parser->push_warning(p_call->arguments[i], GDScriptWarning::UNSAFE_CALL_ARGUMENT, itos(i + 1), "function", p_call->function_name, par_type.to_string(), arg_type.to_string_strict());
GDScript: Improve call analysis * Add missing `UNSAFE_CALL_ARGUMENT` warning. * Fix `Object` constructor. * Display an error for non-existent static methods.
2023-09-21 09:42:55 +00:00
#endif
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
}
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00:00
#ifdef DEBUG_ENABLED
GDScript: Fix constant conversions
2023-01-22 08:32:05 +00: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) {
GDScript: Improve call analysis * Add missing `UNSAFE_CALL_ARGUMENT` warning. * Fix `Object` constructor. * Display an error for non-existent static methods.
2023-09-21 09:42:55 +00:00
parser->push_warning(p_call->arguments[i], GDScriptWarning::NARROWING_CONVERSION, p_call->function_name);
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00:00
#endif
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
}
}
}
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00:00
#ifdef DEBUG_ENABLED
Fix for not being able to ignore shadowing warnings on class scope
2023-04-03 13:57:41 +00: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-11 22:31:28 +00: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 08:39:16 +00: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 13:57:41 +00: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 20:06:29 +00:00
return;
Fix shadowed global identifier warning duplication
2021-12-13 08:39:16 +00:00
}
}
if (Variant::has_utility_function(name)) {
Fix for not being able to ignore shadowing warnings on class scope
2023-04-03 13:57:41 +00: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 20:06:29 +00:00
return;
Fix shadowed global identifier warning duplication
2021-12-13 08:39:16 +00:00
} else if (ClassDB::class_exists(name)) {
Check if any global script class is shadowed by a variable
2023-08-13 09:27:37 +00:00
parser->push_warning(p_identifier, GDScriptWarning::SHADOWED_GLOBAL_IDENTIFIER, p_context, name, "native class");
return;
} else if (ScriptServer::is_global_class(name)) {
String class_path = ScriptServer::get_global_class_path(name).get_file();
parser->push_warning(p_identifier, GDScriptWarning::SHADOWED_GLOBAL_IDENTIFIER, p_context, name, vformat(R"(global class defined in "%s")", class_path));
GDScript: Fix missing warning for shadowing of built-in types
2023-03-08 20:06:29 +00:00
return;
GDScript: Improve call analysis * Add missing `UNSAFE_CALL_ARGUMENT` warning. * Fix `Object` constructor. * Display an error for non-existent static methods.
2023-09-21 09:42:55 +00:00
} 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 13:57:41 +00: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 20:06:29 +00:00
return;
Fix shadowed global identifier warning duplication
2021-12-13 08:39:16 +00:00
}
}
Fix for not being able to ignore shadowing warnings on class scope
2023-04-03 13:57:41 +00: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-11 22:31:28 +00:00
}
}
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
StringName parent = base.native_type;
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-11 22:31:28 +00:00
while (parent != StringName()) {
GDScript: Fix missing warning for shadowing of built-in types
2023-03-08 20:06:29 +00:00
ERR_FAIL_COND_MSG(!class_exists(parent), "Non-existent native base class.");
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
Remove underscore hacks Way less cruft. :) Co-authored-by: Ignacio Roldán Etcheverry <neikeq@users.noreply.github.com>
2021-08-17 13:06:54 +00:00
if (ClassDB::has_method(parent, name, true)) {
Fix for not being able to ignore shadowing warnings on class scope
2023-04-03 13:57:41 +00: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 20:06:29 +00:00
return;
Remove underscore hacks Way less cruft. :) Co-authored-by: Ignacio Roldán Etcheverry <neikeq@users.noreply.github.com>
2021-08-17 13:06:54 +00:00
} else if (ClassDB::has_signal(parent, name, true)) {
Fix for not being able to ignore shadowing warnings on class scope
2023-04-03 13:57:41 +00: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 20:06:29 +00:00
return;
Remove underscore hacks Way less cruft. :) Co-authored-by: Ignacio Roldán Etcheverry <neikeq@users.noreply.github.com>
2021-08-17 13:06:54 +00:00
} else if (ClassDB::has_property(parent, name, true)) {
Fix for not being able to ignore shadowing warnings on class scope
2023-04-03 13:57:41 +00: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 20:06:29 +00:00
return;
Remove underscore hacks Way less cruft. :) Co-authored-by: Ignacio Roldán Etcheverry <neikeq@users.noreply.github.com>
2021-08-17 13:06:54 +00: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 13:57:41 +00: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 20:06:29 +00:00
return;
Remove underscore hacks Way less cruft. :) Co-authored-by: Ignacio Roldán Etcheverry <neikeq@users.noreply.github.com>
2021-08-17 13:06:54 +00:00
} else if (ClassDB::has_enum(parent, name, true)) {
Fix for not being able to ignore shadowing warnings on class scope
2023-04-03 13:57:41 +00: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 20:06:29 +00:00
return;
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-11 22:31:28 +00:00
}
Remove underscore hacks Way less cruft. :) Co-authored-by: Ignacio Roldán Etcheverry <neikeq@users.noreply.github.com>
2021-08-17 13:06:54 +00:00
parent = ClassDB::get_parent_class(parent);
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-11 22:31:28 +00:00
}
}
Wrap up GDScript 2.0 base implementation
2020-07-16 01:02:44 +00:00
#endif
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-11 22:31:28 +00: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 17:41:55 +00: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 12:45:24 +00: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 17:41:55 +00:00
return get_operation_type(p_operation, p_a, nil_type, r_valid, p_source);
}
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 17:41:55 +00: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 19:01:17 +00: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-10 22:53:25 +00: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 16:57:24 +00: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 21:38:29 +00:00
GDScriptParser::DataType result;
Fix operation result type inference
2021-12-23 12:45:24 +00:00
bool hard_operation = p_a.is_hard_type() && p_b.is_hard_type();
Fix: Typed arrays aren't working with +
2023-02-22 21:38:29 +00:00
if (p_operation == Variant::OP_ADD && a_type == Variant::ARRAY && b_type == Variant::ARRAY) {
Change container_element_type to vector container
2023-09-14 18:31:07 +00:00
if (p_a.has_container_element_type(0) && p_b.has_container_element_type(0) && p_a.get_container_element_type(0) == p_b.get_container_element_type(0)) {
Fix: Typed arrays aren't working with +
2023-02-22 21:38:29 +00: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 12:45:24 +00:00
bool validated = op_eval != nullptr;
GDScript: Fix some issues with assignments that involve untyped things
2022-12-30 07:58:07 +00:00
if (validated) {
Fix operation result type inference
2021-12-23 12:45:24 +00:00
r_valid = true;
GDScript: Fix some issues with assignments that involve untyped things
2022-12-30 07:58:07 +00:00
result.type_source = hard_operation ? GDScriptParser::DataType::ANNOTATED_INFERRED : GDScriptParser::DataType::INFERRED;
Fix operation result type inference
2021-12-23 12:45:24 +00: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 07:58:07 +00:00
} else {
r_valid = !hard_operation;
Fix operation result type inference
2021-12-23 12:45:24 +00:00
result.kind = GDScriptParser::DataType::VARIANT;
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
}
return result;
}
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 14:34:33 +00: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) {
Prefer identifiers annotated type if assigned type is incompatible to it
2023-11-22 15:39:30 +00:00
#ifdef DEBUG_ENABLED
if (p_source_node) {
if (p_target.kind == GDScriptParser::DataType::ENUM) {
if (p_source.kind == GDScriptParser::DataType::BUILTIN && p_source.builtin_type == Variant::INT) {
parser->push_warning(p_source_node, GDScriptWarning::INT_AS_ENUM_WITHOUT_CAST);
}
}
}
#endif
return check_type_compatibility(p_target, p_source, p_allow_implicit_conversion, p_source_node);
}
// TODO: Add safe/unsafe return variable (for variant cases)
bool GDScriptAnalyzer::check_type_compatibility(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-10 22:53:25 +00: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 14:34:33 +00: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 00:49:58 +00: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 15:32:35 +00:00
if (valid && p_target.builtin_type == Variant::ARRAY && p_source.builtin_type == Variant::ARRAY) {
// Check the element type.
Change container_element_type to vector container
2023-09-14 18:31:07 +00:00
if (p_target.has_container_element_type(0) && p_source.has_container_element_type(0)) {
valid = p_target.get_container_element_type(0) == p_source.get_container_element_type(0);
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 15:32:35 +00:00
}
}
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
return valid;
}
Added support for enums to be used as types in GDScript
2020-06-12 00:49:58 +00:00
if (p_target.kind == GDScriptParser::DataType::ENUM) {
if (p_source.kind == GDScriptParser::DataType::BUILTIN && p_source.builtin_type == Variant::INT) {
return true;
}
Accept non unnamed enums as valid values for enums. Fixes #49357
2021-08-15 19:25:47 +00: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 00:49:58 +00:00
return false;
}
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 00:49:58 +00:00
case GDScriptParser::DataType::ENUM:
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
case GDScriptParser::DataType::RESOLVING:
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 13:06:54 +00:00
return ClassDB::is_parent_class(src_native, p_target.native_type);
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 07:56:53 +00:00
if (src_class == p_target.class_type || src_class->fqcn == p_target.class_type->fqcn) {
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 00:49:58 +00:00
case GDScriptParser::DataType::ENUM:
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
case GDScriptParser::DataType::RESOLVING:
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 01:02:44 +00:00
#ifdef DEBUG_ENABLED
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
if (p_node == nullptr) {
return;
}
Add new GDScript type checker
2020-06-10 22:53:25 +00: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 01:02:44 +00:00
#endif
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
}
GDScript: Fix some issues with assignments that involve untyped things
2022-12-30 07:58:07 +00: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 17:22:22 +00:00
void GDScriptAnalyzer::mark_lambda_use_self() {
GDScript: Fix lambda resolution with cyclic references
2023-08-23 09:37:18 +00:00
GDScriptParser::LambdaNode *lambda = current_lambda;
while (lambda != nullptr) {
GDScript: Allow using self in lambdas
2022-04-20 17:22:22 +00:00
lambda->use_self = true;
GDScript: Fix lambda resolution with cyclic references
2023-08-23 09:37:18 +00: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 17:22:22 +00:00
}
GDScript: Fix lambda resolution with cyclic references
2023-08-23 09:37:18 +00:00
GDScriptParser::LambdaNode *previous_lambda = current_lambda;
GDScript: Fix non-static call is allowed in static var lambda body
2023-10-17 09:46:41 +00:00
bool previous_static_context = static_context;
GDScript: Fix lambda resolution with cyclic references
2023-08-23 09:37:18 +00:00
List<GDScriptParser::LambdaNode *> lambdas = pending_body_resolution_lambdas;
pending_body_resolution_lambdas.clear();
for (GDScriptParser::LambdaNode *lambda : lambdas) {
current_lambda = lambda;
GDScript: Fix non-static call is allowed in static var lambda body
2023-10-17 09:46:41 +00:00
static_context = lambda->function->is_static;
GDScript: Fix lambda resolution with cyclic references
2023-08-23 09:37:18 +00:00
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: Fix non-static call is allowed in static var lambda body
2023-10-17 09:46:41 +00:00
static_context = previous_static_context;
GDScript: Allow using self in lambdas
2022-04-20 17:22:22 +00: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 15:32:35 +00: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 13:06:54 +00:00
return ClassDB::class_exists(p_class) && ClassDB::is_class_exposed(p_class);
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
}
Error GDScriptAnalyzer::resolve_inheritance() {
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
return resolve_class_inheritance(parser->head, true);
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
}
Error GDScriptAnalyzer::resolve_interface() {
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
resolve_class_interface(parser->head, true);
Rename empty() to is_empty()
2020-12-15 12:04:21 +00:00
return parser->errors.is_empty() ? OK : ERR_PARSE_ERROR;
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
}
Error GDScriptAnalyzer::resolve_body() {
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
resolve_class_body(parser->head, true);
GDScript: invalidate GDScriptParserRef when reloading
2024-04-12 23:13:25 +00:00
#ifdef DEBUG_ENABLED
// Apply here, after all `@warning_ignore`s have been resolved and applied.
parser->apply_pending_warnings();
#endif
Rename empty() to is_empty()
2020-12-15 12:04:21 +00:00
return parser->errors.is_empty() ? OK : ERR_PARSE_ERROR;
Add new GDScript type checker
2020-06-10 22:53:25 +00:00
}
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
Error GDScriptAnalyzer::resolve_dependencies() {
GDScript: invalidate GDScriptParserRef when reloading
2024-04-12 23:13:25 +00:00
for (KeyValue<String, Ref<GDScriptParserRef>> &K : parser->depended_parsers) {
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 08:09:19 +00:00
if (K.value.is_null()) {
GDScript: Fix issues when deriving from other scripts
2020-08-26 17:50:27 +00:00
return ERR_PARSE_ERROR;
}
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
K.value->raise_status(GDScriptParserRef::INHERITANCE_SOLVED);
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-11 22:31:28 +00:00
}
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
Rename empty() to is_empty()
2020-12-15 12:04:21 +00: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-01 22:14:56 +00:00
}
Error GDScriptAnalyzer::analyze() {
parser->errors.clear();
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
GDScript: Fix `@warning_ignore` annotation issues
2024-02-28 14:23:11 +00:00
Error 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-01 22:14:56 +00:00
if (err) {
return err;
}
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
resolve_interface();
GDScript: invalidate GDScriptParserRef when reloading
2024-04-12 23:13:25 +00:00
err = resolve_body();
if (err) {
return err;
GDScript: Allow out of order member resolution
2022-12-11 02:57:35 +00:00
}
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-01 22:14:56 +00:00
}
GDScriptAnalyzer::GDScriptAnalyzer(GDScriptParser *p_parser) {
parser = p_parser;
}
Reference in New Issue Copy Permalink