mirror/godot
2
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2024-12-27 11:24:59 +08:00
Code Issues Packages Projects Releases Wiki Activity
e6125ef51b
godot/modules/gdscript/gdscript_analyzer.h

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

172 lines
12 KiB
C++
Raw Normal View History

New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 06:14:56 +08:00
/**************************************************************************/
/* gdscript_analyzer.h */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
#ifndef GDSCRIPT_ANALYZER_H
#define 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 22:56:21 +08:00
#include "gdscript_cache.h"
#include "gdscript_parser.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-08 06:33:38 +08:00
#include "core/object/object.h"
Rename Reference to RefCounted
2021-06-05 00:03:15 +08:00
#include "core/object/ref_counted.h"
Add a new HashSet template * Intended to replace RBSet in most cases. * Optimized for iteration speed
2022-05-19 23:00:06 +08:00
#include "core/templates/hash_set.h"
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 06:14:56 +08:00
class GDScriptAnalyzer {
GDScriptParser *parser = nullptr;
GDScript: Fix common mismatched external parser errors
2024-07-23 19:46:28 +08:00
template <typename Fn>
class Finally {
Fn fn;
public:
Finally(Fn p_fn) :
fn(p_fn) {}
~Finally() {
fn();
}
};
GDScript: Allow enum values to be set to constant expressions Also allow them to access previous values wihout referencing the enum.
2020-08-19 04:44:20 +08:00
const GDScriptParser::EnumNode *current_enum = nullptr;
GDScript: Fix lambda resolution with cyclic references
2023-08-23 17:37:18 +08:00
GDScriptParser::LambdaNode *current_lambda = nullptr;
List<GDScriptParser::LambdaNode *> pending_body_resolution_lambdas;
GDScript: Fix common mismatched external parser errors
2024-07-23 19:46:28 +08:00
HashMap<const GDScriptParser::ClassNode *, Ref<GDScriptParserRef>> external_class_parser_cache;
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 22:10:35 +08:00
bool static_context = false;
GDScript: Allow enum values to be set to constant expressions Also allow them to access previous values wihout referencing the enum.
2020-08-19 04:44:20 +08:00
Check for GDScript member and class naming conflicts in a variety of conditions.
2021-08-25 00:49:03 +08:00
// Tests for detecting invalid overloading of script members
Fix ability to overload "script" variable
2022-11-09 06:41:50 +08:00
static _FORCE_INLINE_ bool has_member_name_conflict_in_script_class(const StringName &p_name, const GDScriptParser::ClassNode *p_current_class_node, const GDScriptParser::Node *p_member);
Check for GDScript member and class naming conflicts in a variety of conditions.
2021-08-25 00:49:03 +08:00
static _FORCE_INLINE_ bool has_member_name_conflict_in_native_type(const StringName &p_name, const StringName &p_native_type_string);
Error check_native_member_name_conflict(const StringName &p_member_name, const GDScriptParser::Node *p_member_node, const StringName &p_native_type_string);
Error check_class_member_name_conflict(const GDScriptParser::ClassNode *p_class_node, const StringName &p_member_name, const GDScriptParser::Node *p_member_node);
GDScript: Fix common mismatched external parser errors
2024-07-23 19:46:28 +08:00
void get_class_node_current_scope_classes(GDScriptParser::ClassNode *p_node, List<GDScriptParser::ClassNode *> *p_list, GDScriptParser::Node *p_source);
Fix constant base typing in extended GDScript class
2022-12-05 05:55:40 +08:00
GDScript: Allow out of order member resolution
2022-12-11 10:57:35 +08:00
Error resolve_class_inheritance(GDScriptParser::ClassNode *p_class, const GDScriptParser::Node *p_source = nullptr);
Error resolve_class_inheritance(GDScriptParser::ClassNode *p_class, bool p_recursive);
Add warning checks in GDScript analyzer Reenable checking those when validating code.
2020-06-12 06:31:28 +08:00
GDScriptParser::DataType resolve_datatype(GDScriptParser::TypeNode *p_type);
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 06:14:56 +08:00
Add new GDScript type checker
2020-06-11 06:53:25 +08:00
void decide_suite_type(GDScriptParser::Node *p_suite, GDScriptParser::Node *p_statement);
void resolve_annotation(GDScriptParser::AnnotationNode *p_annotation);
Add const lvalue ref to container parameters
2021-08-02 03:47:20 +08:00
void resolve_class_member(GDScriptParser::ClassNode *p_class, const StringName &p_name, const GDScriptParser::Node *p_source = nullptr);
GDScript: Allow out of order member resolution
2022-12-11 10:57:35 +08:00
void resolve_class_member(GDScriptParser::ClassNode *p_class, int p_index, const GDScriptParser::Node *p_source = nullptr);
void resolve_class_interface(GDScriptParser::ClassNode *p_class, const GDScriptParser::Node *p_source = nullptr);
void resolve_class_interface(GDScriptParser::ClassNode *p_class, bool p_recursive);
void resolve_class_body(GDScriptParser::ClassNode *p_class, const GDScriptParser::Node *p_source = nullptr);
void resolve_class_body(GDScriptParser::ClassNode *p_class, bool p_recursive);
GDScript: Fix typing of lambda functions
2022-12-28 13:41:03 +08:00
void resolve_function_signature(GDScriptParser::FunctionNode *p_function, const GDScriptParser::Node *p_source = nullptr, bool p_is_lambda = false);
void resolve_function_body(GDScriptParser::FunctionNode *p_function, bool p_is_lambda = false);
Implement RETURN_VALUE_DISCARDED warning in GDscript
2022-10-14 01:31:12 +08:00
void resolve_node(GDScriptParser::Node *p_node, bool p_is_root = true);
Add new GDScript type checker
2020-06-11 06:53:25 +08:00
void resolve_suite(GDScriptParser::SuiteNode *p_suite);
Unify typing of variables, constants and parameters in GDScript
2022-12-23 04:43:36 +08:00
void resolve_assignable(GDScriptParser::AssignableNode *p_assignable, const char *p_kind);
void resolve_variable(GDScriptParser::VariableNode *p_variable, bool p_is_local);
void resolve_constant(GDScriptParser::ConstantNode *p_constant, bool p_is_local);
void resolve_parameter(GDScriptParser::ParameterNode *p_parameter);
Add new GDScript type checker
2020-06-11 06:53:25 +08:00
void resolve_if(GDScriptParser::IfNode *p_if);
void resolve_for(GDScriptParser::ForNode *p_for);
void resolve_while(GDScriptParser::WhileNode *p_while);
void resolve_assert(GDScriptParser::AssertNode *p_assert);
void resolve_match(GDScriptParser::MatchNode *p_match);
void resolve_match_branch(GDScriptParser::MatchBranchNode *p_match_branch, GDScriptParser::ExpressionNode *p_match_test);
void resolve_match_pattern(GDScriptParser::PatternNode *p_match_pattern, GDScriptParser::ExpressionNode *p_match_test);
void resolve_return(GDScriptParser::ReturnNode *p_return);
// Reduction functions.
GDScript: Remove error when coroutine is called without await In the case the call happens as a statement, since the return value isn't used in this case.
2021-10-15 07:12:01 +08:00
void reduce_expression(GDScriptParser::ExpressionNode *p_expression, bool p_is_root = false);
Add new GDScript type checker
2020-06-11 06:53:25 +08:00
void reduce_array(GDScriptParser::ArrayNode *p_array);
void reduce_assignment(GDScriptParser::AssignmentNode *p_assignment);
void reduce_await(GDScriptParser::AwaitNode *p_await);
void reduce_binary_op(GDScriptParser::BinaryOpNode *p_binary_op);
GDScript: Remove error when coroutine is called without await In the case the call happens as a statement, since the return value isn't used in this case.
2021-10-15 07:12:01 +08:00
void reduce_call(GDScriptParser::CallNode *p_call, bool p_is_await = false, bool p_is_root = false);
Add new GDScript type checker
2020-06-11 06:53:25 +08:00
void reduce_cast(GDScriptParser::CastNode *p_cast);
void reduce_dictionary(GDScriptParser::DictionaryNode *p_dictionary);
void reduce_get_node(GDScriptParser::GetNodeNode *p_get_node);
Added support for enums to be used as types in GDScript
2020-06-12 08:49:58 +08:00
void reduce_identifier(GDScriptParser::IdentifierNode *p_identifier, bool can_be_builtin = false);
Add new GDScript type checker
2020-06-11 06:53:25 +08:00
void reduce_identifier_from_base(GDScriptParser::IdentifierNode *p_identifier, GDScriptParser::DataType *p_base = nullptr);
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 20:03:16 +08:00
void reduce_lambda(GDScriptParser::LambdaNode *p_lambda);
Add new GDScript type checker
2020-06-11 06:53:25 +08:00
void reduce_literal(GDScriptParser::LiteralNode *p_literal);
void reduce_preload(GDScriptParser::PreloadNode *p_preload);
void reduce_self(GDScriptParser::SelfNode *p_self);
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 23:57:09 +08:00
void reduce_subscript(GDScriptParser::SubscriptNode *p_subscript, bool p_can_be_pseudo_type = false);
Allow standalone ternary expressions
2023-01-09 22:02:37 +08:00
void reduce_ternary_op(GDScriptParser::TernaryOpNode *p_ternary_op, bool p_is_root = false);
GDScript: Rework type check
2023-02-17 07:16:24 +08:00
void reduce_type_test(GDScriptParser::TypeTestNode *p_type_test);
Add new GDScript type checker
2020-06-11 06:53:25 +08:00
void reduce_unary_op(GDScriptParser::UnaryOpNode *p_unary_op);
GDScript: Fix issues with typed arrays
2022-11-27 15:56:53 +08:00
Variant make_expression_reduced_value(GDScriptParser::ExpressionNode *p_expression, bool &is_reduced);
Variant make_array_reduced_value(GDScriptParser::ArrayNode *p_array, bool &is_reduced);
Variant make_dictionary_reduced_value(GDScriptParser::DictionaryNode *p_dictionary, bool &is_reduced);
Variant make_subscript_reduced_value(GDScriptParser::SubscriptNode *p_subscript, bool &is_reduced);
Array/Dictinoary no more reduced to array/dictionary variant Fix: #41377 Fix: #20436 Fix: #41953
2020-09-11 22:16:20 +08:00
Add new GDScript type checker
2020-06-11 06:53:25 +08:00
// Helpers.
GDScript: Fix issues with typed arrays
2022-11-27 15:56:53 +08:00
Array make_array_from_element_datatype(const GDScriptParser::DataType &p_element_datatype, const GDScriptParser::Node *p_source_node = nullptr);
Implement typed dictionaries
2023-06-25 02:03:28 +08:00
Dictionary make_dictionary_from_element_datatype(const GDScriptParser::DataType &p_key_element_datatype, const GDScriptParser::DataType &p_value_element_datatype, const GDScriptParser::Node *p_source_node = nullptr);
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 20:53:02 +08:00
GDScriptParser::DataType type_from_variant(const Variant &p_value, const GDScriptParser::Node *p_source);
Assorted enum and native type fixes
2022-12-04 11:02:03 +08:00
static GDScriptParser::DataType type_from_metatype(const GDScriptParser::DataType &p_meta_type);
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-31 01:50:08 +08:00
GDScriptParser::DataType type_from_property(const PropertyInfo &p_property, bool p_is_arg = false, bool p_is_readonly = false) const;
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 23:27:48 +08:00
GDScriptParser::DataType make_global_class_meta_type(const StringName &p_class_name, const GDScriptParser::Node *p_source);
GDScript: add errors when calling unimplemented virtual functions This PR does a small refactor of how method flags are handled in the GDScript analyzer. This way, it adds support for the analyzer to use any of MethodInfo's flags, where previously it could only use METHOD_FLAG_STATIC and METHOD_FLAG_VARARG. As a side-effect, this also normalizes behavior between editor and release templates, which fixes #76938. The tests added also brought a different issue to light, where using `super()` appears to generate a return variable discarded on calling super's _init(), which doesn't have a return value. This should be tackled in a different PR, which will have to change the output of this PR's tests.
2023-05-22 07:22:00 +08:00
bool get_function_signature(GDScriptParser::Node *p_source, bool p_is_constructor, GDScriptParser::DataType 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 = nullptr);
bool 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);
GDScript: Fix constant conversions
2023-01-22 16:32:05 +08:00
void validate_call_arg(const List<GDScriptParser::DataType> &p_par_types, int p_default_args_count, bool p_is_vararg, const GDScriptParser::CallNode *p_call);
void validate_call_arg(const MethodInfo &p_method, const GDScriptParser::CallNode *p_call);
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 20:53:02 +08:00
GDScriptParser::DataType 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: 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-27 01:41:55 +08:00
GDScriptParser::DataType get_operation_type(Variant::Operator p_operation, const GDScriptParser::DataType &p_a, bool &r_valid, const GDScriptParser::Node *p_source);
GDScript: Fix constant conversions
2023-01-22 16:32:05 +08:00
void update_const_expression_builtin_type(GDScriptParser::ExpressionNode *p_expression, const GDScriptParser::DataType &p_type, const char *p_usage, bool p_is_cast = false);
GDScript: Fix issues with typed arrays
2022-11-27 15:56:53 +08:00
void update_array_literal_element_type(GDScriptParser::ArrayNode *p_array, const GDScriptParser::DataType &p_element_type);
Implement typed dictionaries
2023-06-25 02:03:28 +08:00
void update_dictionary_literal_element_type(GDScriptParser::DictionaryNode *p_dictionary, const GDScriptParser::DataType &p_key_element_type, const GDScriptParser::DataType &p_value_element_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 22:34:33 +08:00
bool is_type_compatible(const GDScriptParser::DataType &p_target, const GDScriptParser::DataType &p_source, bool p_allow_implicit_conversion = false, const GDScriptParser::Node *p_source_node = nullptr);
GDScript: Allow out of order member resolution
2022-12-11 10:57:35 +08:00
void push_error(const String &p_message, const GDScriptParser::Node *p_origin = nullptr);
Add new GDScript type checker
2020-06-11 06:53:25 +08:00
void mark_node_unsafe(const GDScriptParser::Node *p_node);
GDScript: Fix some issues with assignments that involve untyped things
2022-12-30 15:58:07 +08:00
void downgrade_node_type_source(GDScriptParser::Node *p_node);
GDScript: Allow using self in lambdas
2022-04-21 01:22:22 +08:00
void mark_lambda_use_self();
GDScript: Fix lambda resolution with cyclic references
2023-08-23 17:37:18 +08:00
void resolve_pending_lambda_bodies();
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 23:32:35 +08:00
bool class_exists(const StringName &p_class) const;
GDScript: Fix issues with typed arrays
2022-11-27 15:56:53 +08:00
void reduce_identifier_from_base_set_class(GDScriptParser::IdentifierNode *p_identifier, GDScriptParser::DataType p_identifier_datatype);
GDScript: Fix too many calls to 'remove_parser' +fix excessive memory allocations when 'load'ing many dependant scripts +fix excessive calls to vformat
2024-08-03 11:55:13 +08:00
Ref<GDScriptParserRef> ensure_cached_external_parser_for_class(const GDScriptParser::ClassNode *p_class, const GDScriptParser::ClassNode *p_from_class, const char *p_context, const GDScriptParser::Node *p_source);
Ref<GDScriptParserRef> find_cached_external_parser_for_class(const GDScriptParser::ClassNode *p_class, const Ref<GDScriptParserRef> &p_dependant_parser);
Ref<GDScriptParserRef> find_cached_external_parser_for_class(const GDScriptParser::ClassNode *p_class, GDScriptParser *p_dependant_parser);
GDScript: Fix common mismatched external parser errors
2024-07-23 19:46:28 +08:00
Ref<GDScript> get_depended_shallow_script(const String &p_path, Error &r_error);
Wrap up GDScript 2.0 base implementation
2020-07-16 09:02:44 +08:00
#ifdef DEBUG_ENABLED
Fix for not being able to ignore shadowing warnings on class scope
2023-04-03 21:57:41 +08:00
void is_shadowing(GDScriptParser::IdentifierNode *p_identifier, const String &p_context, const bool p_in_local_scope);
Wrap up GDScript 2.0 base implementation
2020-07-16 09:02:44 +08: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-02 06:14:56 +08:00
public:
Error resolve_inheritance();
Add new GDScript type checker
2020-06-11 06:53:25 +08:00
Error resolve_interface();
Error resolve_body();
GDScript: Allow out of order member resolution
2022-12-11 10:57:35 +08:00
Error resolve_dependencies();
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 06:14:56 +08:00
Error analyze();
GDScript: Fix issues with typed arrays
2022-11-27 15:56:53 +08:00
Variant make_variable_default_value(GDScriptParser::VariableNode *p_variable);
Prefer identifiers annotated type if assigned type is incompatible to it
2023-11-22 23:39:30 +08:00
static bool check_type_compatibility(const GDScriptParser::DataType &p_target, const GDScriptParser::DataType &p_source, bool p_allow_implicit_conversion = false, const GDScriptParser::Node *p_source_node = nullptr);
GDScript: Fix issues with typed arrays
2022-11-27 15:56:53 +08:00
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-02 06:14:56 +08:00
GDScriptAnalyzer(GDScriptParser *p_parser);
};
#endif // GDSCRIPT_ANALYZER_H
Reference in New Issue Copy Permalink