Added tests for ClassDB
This commit is contained in:
Ignacio Etcheverry
parent
6815bf42b3
commit
9fa4b402a7
|
|
@ -0,0 +1,882 @@
|
|||
/*************************************************************************/
|
||||
/* test_class_db.cpp */
|
||||
/*************************************************************************/
|
||||
/* This file is part of: */
|
||||
/* GODOT ENGINE */
|
||||
/* https://godotengine.org */
|
||||
/*************************************************************************/
|
||||
/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
|
||||
/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
|
||||
/* */
|
||||
/* Permission is hereby granted, free of charge, to any person obtaining */
|
||||
/* a copy of this software and associated documentation files (the */
|
||||
/* "Software"), to deal in the Software without restriction, including */
|
||||
/* without limitation the rights to use, copy, modify, merge, publish, */
|
||||
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
||||
/* permit persons to whom the Software is furnished to do so, subject to */
|
||||
/* the following conditions: */
|
||||
/* */
|
||||
/* The above copyright notice and this permission notice shall be */
|
||||
/* included in all copies or substantial portions of the Software. */
|
||||
/* */
|
||||
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
||||
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
||||
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
||||
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
||||
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
||||
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
||||
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
||||
/*************************************************************************/
|
||||
|
||||
#include "test_class_db.h"
|
||||
|
||||
#include "core/global_constants.h"
|
||||
#include "core/ordered_hash_map.h"
|
||||
#include "core/os/os.h"
|
||||
#include "core/string_name.h"
|
||||
#include "core/ustring.h"
|
||||
#include "core/variant.h"
|
||||
|
||||
namespace TestClassDB {
|
||||
|
||||
enum class [[nodiscard]] TestResult{
|
||||
FAILED,
|
||||
PASS
|
||||
};
|
||||
|
||||
#define TEST_FAIL_COND_FATAL(m_cond, m_msg) \
|
||||
if (unlikely(m_cond)) { \
|
||||
ERR_PRINT(m_msg); \
|
||||
return TestResult::FAILED; \
|
||||
} else \
|
||||
((void)0)
|
||||
|
||||
#define TEST_FAIL_COND(m_cond, m_msg) \
|
||||
if (unlikely(m_cond)) { \
|
||||
ERR_PRINT(m_msg); \
|
||||
__test_result__ = TestResult::FAILED; \
|
||||
} else \
|
||||
((void)0)
|
||||
|
||||
#define TEST_CHECK_FATAL(m_test_expr) \
|
||||
if (unlikely((m_test_expr) == TestResult::FAILED)) { \
|
||||
return TestResult::FAILED; \
|
||||
} else \
|
||||
((void)0)
|
||||
|
||||
#define TEST_CHECK(m_test_expr) \
|
||||
if (unlikely((m_test_expr) == TestResult::FAILED)) { \
|
||||
__test_result__ = TestResult::FAILED; \
|
||||
} else \
|
||||
((void)0)
|
||||
|
||||
#define TEST_START() \
|
||||
TestResult __test_result__ = TestResult::PASS; \
|
||||
((void)0)
|
||||
|
||||
#define TEST_END() return __test_result__;
|
||||
|
||||
struct TypeReference {
|
||||
StringName name;
|
||||
bool is_enum = false;
|
||||
};
|
||||
|
||||
struct ConstantData {
|
||||
String name;
|
||||
int value = 0;
|
||||
};
|
||||
|
||||
struct EnumData {
|
||||
StringName name;
|
||||
List<ConstantData> constants;
|
||||
|
||||
_FORCE_INLINE_ bool operator==(const EnumData &p_enum) const {
|
||||
return p_enum.name == name;
|
||||
}
|
||||
};
|
||||
|
||||
struct PropertyData {
|
||||
StringName name;
|
||||
int index = 0;
|
||||
|
||||
StringName getter;
|
||||
StringName setter;
|
||||
};
|
||||
|
||||
struct ArgumentData {
|
||||
TypeReference type;
|
||||
String name;
|
||||
bool has_defval = false;
|
||||
Variant defval;
|
||||
};
|
||||
|
||||
struct MethodData {
|
||||
StringName name;
|
||||
TypeReference return_type;
|
||||
List<ArgumentData> arguments;
|
||||
bool is_virtual = false;
|
||||
bool is_vararg = false;
|
||||
};
|
||||
|
||||
struct SignalData {
|
||||
StringName name;
|
||||
List<ArgumentData> arguments;
|
||||
};
|
||||
|
||||
struct ExposedClass {
|
||||
StringName name;
|
||||
StringName base;
|
||||
|
||||
bool is_singleton = false;
|
||||
bool is_instantiable = false;
|
||||
bool is_reference = false;
|
||||
|
||||
ClassDB::APIType api_type;
|
||||
|
||||
List<ConstantData> constants;
|
||||
List<EnumData> enums;
|
||||
List<PropertyData> properties;
|
||||
List<MethodData> methods;
|
||||
List<SignalData> signals_;
|
||||
|
||||
const PropertyData *find_property_by_name(const StringName &p_name) const {
|
||||
for (const List<PropertyData>::Element *E = properties.front(); E; E = E->next()) {
|
||||
if (E->get().name == p_name) {
|
||||
return &E->get();
|
||||
}
|
||||
}
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
const MethodData *find_method_by_name(const StringName &p_name) const {
|
||||
for (const List<MethodData>::Element *E = methods.front(); E; E = E->next()) {
|
||||
if (E->get().name == p_name) {
|
||||
return &E->get();
|
||||
}
|
||||
}
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
};
|
||||
|
||||
struct NamesCache {
|
||||
StringName variant_type = StaticCString::create("Variant");
|
||||
StringName object_class = StaticCString::create("Object");
|
||||
StringName reference_class = StaticCString::create("Reference");
|
||||
StringName string_type = StaticCString::create("String");
|
||||
StringName string_name_type = StaticCString::create("StringName");
|
||||
StringName node_path_type = StaticCString::create("NodePath");
|
||||
StringName bool_type = StaticCString::create("bool");
|
||||
StringName int_type = StaticCString::create("int");
|
||||
StringName float_type = StaticCString::create("float");
|
||||
StringName void_type = StaticCString::create("void");
|
||||
StringName vararg_stub_type = StaticCString::create("@VarArg@");
|
||||
StringName vector2_type = StaticCString::create("Vector2");
|
||||
StringName rect2_type = StaticCString::create("Rect2");
|
||||
StringName vector3_type = StaticCString::create("Vector3");
|
||||
|
||||
// Object not included as it must be checked for all derived classes
|
||||
static constexpr int nullable_types_count = 17;
|
||||
StringName nullable_types[nullable_types_count] = {
|
||||
string_type,
|
||||
string_name_type,
|
||||
node_path_type,
|
||||
|
||||
StaticCString::create(_STR(Array)),
|
||||
StaticCString::create(_STR(Dictionary)),
|
||||
StaticCString::create(_STR(Callable)),
|
||||
StaticCString::create(_STR(Signal)),
|
||||
|
||||
StaticCString::create(_STR(PackedByteArray)),
|
||||
StaticCString::create(_STR(PackedInt32Array)),
|
||||
StaticCString::create(_STR(PackedInt64rray)),
|
||||
StaticCString::create(_STR(PackedFloat32Array)),
|
||||
StaticCString::create(_STR(PackedFloat64Array)),
|
||||
StaticCString::create(_STR(PackedStringArray)),
|
||||
StaticCString::create(_STR(PackedVector2Array)),
|
||||
StaticCString::create(_STR(PackedVector3Array)),
|
||||
StaticCString::create(_STR(PackedColorArray)),
|
||||
};
|
||||
|
||||
bool is_nullable_type(const StringName &p_type) const {
|
||||
for (int i = 0; i < nullable_types_count; i++) {
|
||||
if (p_type == nullable_types[i]) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
typedef OrderedHashMap<StringName, ExposedClass> ExposedClasses;
|
||||
|
||||
struct Context {
|
||||
Vector<StringName> enum_types;
|
||||
Vector<StringName> builtin_types;
|
||||
ExposedClasses exposed_classes;
|
||||
List<EnumData> global_enums;
|
||||
NamesCache names_cache;
|
||||
|
||||
const ExposedClass *find_exposed_class(const StringName &p_name) const {
|
||||
ExposedClasses::ConstElement elem = exposed_classes.find(p_name);
|
||||
return elem ? &elem.value() : nullptr;
|
||||
}
|
||||
|
||||
const ExposedClass *find_exposed_class(const TypeReference &p_type_ref) const {
|
||||
ExposedClasses::ConstElement elem = exposed_classes.find(p_type_ref.name);
|
||||
return elem ? &elem.value() : nullptr;
|
||||
}
|
||||
|
||||
bool has_type(const Context &p_context, const TypeReference &p_type_ref) const {
|
||||
if (p_context.builtin_types.find(p_type_ref.name) >= 0) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (p_type_ref.is_enum) {
|
||||
if (p_context.enum_types.find(p_type_ref.name) >= 0) {
|
||||
return true;
|
||||
}
|
||||
|
||||
// Enum not found. Most likely because none of its constants were bound, so it's empty. That's fine. Use int instead.
|
||||
return p_context.builtin_types.find(p_context.names_cache.int_type);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
bool arg_default_value_is_assignable_to_type(const Context &p_context, const Variant &p_val, const TypeReference &p_arg_type) {
|
||||
if (p_arg_type.name == p_context.names_cache.variant_type) {
|
||||
// Variant can take anything
|
||||
return true;
|
||||
}
|
||||
|
||||
switch (p_val.get_type()) {
|
||||
case Variant::NIL:
|
||||
return p_context.find_exposed_class(p_arg_type) ||
|
||||
p_context.names_cache.is_nullable_type(p_arg_type.name);
|
||||
case Variant::BOOL:
|
||||
return p_arg_type.name == p_context.names_cache.bool_type;
|
||||
case Variant::INT:
|
||||
return p_arg_type.name == p_context.names_cache.int_type ||
|
||||
p_arg_type.name == p_context.names_cache.float_type ||
|
||||
p_arg_type.is_enum;
|
||||
case Variant::FLOAT:
|
||||
return p_arg_type.name == p_context.names_cache.float_type;
|
||||
case Variant::STRING:
|
||||
case Variant::STRING_NAME:
|
||||
return p_arg_type.name == p_context.names_cache.string_type ||
|
||||
p_arg_type.name == p_context.names_cache.string_name_type ||
|
||||
p_arg_type.name == p_context.names_cache.node_path_type;
|
||||
case Variant::NODE_PATH:
|
||||
return p_arg_type.name == p_context.names_cache.node_path_type;
|
||||
case Variant::TRANSFORM:
|
||||
case Variant::TRANSFORM2D:
|
||||
case Variant::BASIS:
|
||||
case Variant::QUAT:
|
||||
case Variant::PLANE:
|
||||
case Variant::AABB:
|
||||
case Variant::COLOR:
|
||||
case Variant::VECTOR2:
|
||||
case Variant::RECT2:
|
||||
case Variant::VECTOR3:
|
||||
case Variant::_RID:
|
||||
case Variant::ARRAY:
|
||||
case Variant::DICTIONARY:
|
||||
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:
|
||||
case Variant::CALLABLE:
|
||||
case Variant::SIGNAL:
|
||||
return p_arg_type.name == Variant::get_type_name(p_val.get_type());
|
||||
case Variant::OBJECT:
|
||||
return p_context.find_exposed_class(p_arg_type);
|
||||
case Variant::VECTOR2I:
|
||||
return p_arg_type.name == p_context.names_cache.vector2_type ||
|
||||
p_arg_type.name == Variant::get_type_name(p_val.get_type());
|
||||
case Variant::RECT2I:
|
||||
return p_arg_type.name == p_context.names_cache.rect2_type ||
|
||||
p_arg_type.name == Variant::get_type_name(p_val.get_type());
|
||||
case Variant::VECTOR3I:
|
||||
return p_arg_type.name == p_context.names_cache.vector3_type ||
|
||||
p_arg_type.name == Variant::get_type_name(p_val.get_type());
|
||||
default:
|
||||
ERR_PRINT("Unexpected Variant type: " + itos(p_val.get_type()));
|
||||
break;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
TestResult validate_property(const Context &p_context, const ExposedClass &p_class, const PropertyData &p_prop) {
|
||||
TEST_START();
|
||||
|
||||
const MethodData *setter = p_class.find_method_by_name(p_prop.setter);
|
||||
|
||||
// Search it in base classes too
|
||||
const ExposedClass *top = &p_class;
|
||||
while (!setter && top->base != StringName()) {
|
||||
top = p_context.find_exposed_class(top->base);
|
||||
TEST_FAIL_COND(!top, "Class not found '" + top->base + "'. Inherited by '" + top->name + "'.");
|
||||
setter = top->find_method_by_name(p_prop.setter);
|
||||
}
|
||||
|
||||
const MethodData *getter = p_class.find_method_by_name(p_prop.getter);
|
||||
|
||||
// Search it in base classes too
|
||||
top = &p_class;
|
||||
while (!getter && top->base != StringName()) {
|
||||
top = p_context.find_exposed_class(top->base);
|
||||
TEST_FAIL_COND(!top, "Class not found '" + top->base + "'. Inherited by '" + top->name + "'.");
|
||||
getter = top->find_method_by_name(p_prop.getter);
|
||||
}
|
||||
|
||||
TEST_FAIL_COND(!setter && !getter,
|
||||
"Couldn't find neither the setter nor the getter for property: '" + p_class.name + "." + String(p_prop.name) + "'.");
|
||||
|
||||
if (setter) {
|
||||
int setter_argc = p_prop.index != -1 ? 2 : 1;
|
||||
TEST_FAIL_COND(setter->arguments.size() != setter_argc,
|
||||
"Invalid property setter argument count: '" + p_class.name + "." + String(p_prop.name) + "'.");
|
||||
}
|
||||
|
||||
if (getter) {
|
||||
int getter_argc = p_prop.index != -1 ? 1 : 0;
|
||||
TEST_FAIL_COND(getter->arguments.size() != getter_argc,
|
||||
"Invalid property setter argument count: '" + p_class.name + "." + String(p_prop.name) + "'.");
|
||||
}
|
||||
|
||||
if (getter && setter) {
|
||||
const ArgumentData &setter_first_arg = setter->arguments.back()->get();
|
||||
if (getter->return_type.name != setter_first_arg.type.name) {
|
||||
// Special case for Node::set_name
|
||||
bool whitelisted = getter->return_type.name == p_context.names_cache.string_name_type &&
|
||||
setter_first_arg.type.name == p_context.names_cache.string_type;
|
||||
|
||||
TEST_FAIL_COND(!whitelisted,
|
||||
"Return type from getter doesn't match first argument of setter, for property: '" + p_class.name + "." + String(p_prop.name) + "'.");
|
||||
}
|
||||
}
|
||||
|
||||
const TypeReference &prop_type_ref = getter ? getter->return_type : setter->arguments.back()->get().type;
|
||||
|
||||
const ExposedClass *prop_class = p_context.find_exposed_class(prop_type_ref);
|
||||
if (prop_class) {
|
||||
TEST_FAIL_COND(prop_class->is_singleton,
|
||||
"Property type is a singleton: '" + p_class.name + "." + String(p_prop.name) + "'.");
|
||||
} else {
|
||||
TEST_FAIL_COND(!p_context.has_type(p_context, prop_type_ref),
|
||||
"Property type '" + prop_type_ref.name + "' not found: '" + p_class.name + "." + String(p_prop.name) + "'.");
|
||||
}
|
||||
|
||||
if (getter) {
|
||||
if (p_prop.index != -1) {
|
||||
const ArgumentData &idx_arg = getter->arguments.front()->get();
|
||||
if (idx_arg.type.name != p_context.names_cache.int_type) {
|
||||
// If not an int, it can be an enum
|
||||
TEST_FAIL_COND(p_context.enum_types.find(idx_arg.type.name) < 0,
|
||||
"Invalid type '" + idx_arg.type.name + "' for index argument of property getter: '" + p_class.name + "." + String(p_prop.name) + "'.");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (setter) {
|
||||
if (p_prop.index != -1) {
|
||||
const ArgumentData &idx_arg = setter->arguments.front()->get();
|
||||
if (idx_arg.type.name != p_context.names_cache.int_type) {
|
||||
// Assume the index parameter is an enum
|
||||
// If not an int, it can be an enum
|
||||
TEST_FAIL_COND(p_context.enum_types.find(idx_arg.type.name) < 0,
|
||||
"Invalid type '" + idx_arg.type.name + "' for index argument of property setter: '" + p_class.name + "." + String(p_prop.name) + "'.");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST_END();
|
||||
}
|
||||
|
||||
TestResult validate_method(const Context &p_context, const ExposedClass &p_class, const MethodData &p_method) {
|
||||
TEST_START();
|
||||
|
||||
const ExposedClass *return_class = p_context.find_exposed_class(p_method.return_type);
|
||||
if (return_class) {
|
||||
TEST_FAIL_COND(return_class->is_singleton,
|
||||
"Method return type is a singleton: '" + p_class.name + "." + p_method.name + "'.");
|
||||
}
|
||||
|
||||
for (const List<ArgumentData>::Element *F = p_method.arguments.front(); F; F = F->next()) {
|
||||
const ArgumentData &arg = F->get();
|
||||
|
||||
const ExposedClass *arg_class = p_context.find_exposed_class(arg.type);
|
||||
if (arg_class) {
|
||||
TEST_FAIL_COND(arg_class->is_singleton,
|
||||
"Argument type is a singleton: '" + arg.name + "' of method '" + p_class.name + "." + p_method.name + "'.");
|
||||
} else {
|
||||
TEST_FAIL_COND(!p_context.has_type(p_context, arg.type),
|
||||
"Argument type '" + arg.type.name + "' not found: '" + arg.name + "' of method" + p_class.name + "." + p_method.name + "'.");
|
||||
}
|
||||
|
||||
if (arg.has_defval) {
|
||||
TEST_FAIL_COND(!arg_default_value_is_assignable_to_type(p_context, arg.defval, arg.type),
|
||||
"Invalid default value for parameter '" + arg.name + "' of method '" + p_class.name + "." + p_method.name + "'.");
|
||||
}
|
||||
}
|
||||
|
||||
TEST_END();
|
||||
}
|
||||
|
||||
TestResult validate_signal(const Context &p_context, const ExposedClass &p_class, const SignalData &p_signal) {
|
||||
TEST_START();
|
||||
|
||||
for (const List<ArgumentData>::Element *F = p_signal.arguments.front(); F; F = F->next()) {
|
||||
const ArgumentData &arg = F->get();
|
||||
|
||||
const ExposedClass *arg_class = p_context.find_exposed_class(arg.type);
|
||||
if (arg_class) {
|
||||
TEST_FAIL_COND(arg_class->is_singleton,
|
||||
"Argument class is a singleton: '" + arg.name + "' of signal" + p_class.name + "." + p_signal.name + "'.");
|
||||
} else {
|
||||
TEST_FAIL_COND(!p_context.has_type(p_context, arg.type),
|
||||
"Argument type '" + arg.type.name + "' not found: '" + arg.name + "' of signal" + p_class.name + "." + p_signal.name + "'.");
|
||||
}
|
||||
}
|
||||
|
||||
TEST_END();
|
||||
}
|
||||
|
||||
TestResult validate_class(const Context &p_context, const ExposedClass &p_exposed_class) {
|
||||
TEST_START();
|
||||
|
||||
bool is_derived_type = p_exposed_class.base != StringName();
|
||||
|
||||
if (!is_derived_type) {
|
||||
// Asserts about the base Object class
|
||||
TEST_FAIL_COND_FATAL(p_exposed_class.name != p_context.names_cache.object_class,
|
||||
"Class '" + p_exposed_class.name + "' has no base class.");
|
||||
TEST_FAIL_COND_FATAL(!p_exposed_class.is_instantiable,
|
||||
"Object class is not instantiable.");
|
||||
TEST_FAIL_COND_FATAL(p_exposed_class.api_type != ClassDB::API_CORE,
|
||||
"Object class is API is not API_CORE.");
|
||||
TEST_FAIL_COND_FATAL(p_exposed_class.is_singleton,
|
||||
"Object class is registered as a singleton.");
|
||||
}
|
||||
|
||||
CRASH_COND_MSG(p_exposed_class.is_singleton && p_exposed_class.base != p_context.names_cache.object_class,
|
||||
"Singleton base class '" + String(p_exposed_class.base) + "' is not Object, for class '" + p_exposed_class.name + "'.");
|
||||
|
||||
CRASH_COND_MSG(is_derived_type && !p_context.exposed_classes.has(p_exposed_class.base),
|
||||
"Base type '" + p_exposed_class.base.operator String() + "' does not exist, for class '" + p_exposed_class.name + "'.");
|
||||
|
||||
for (const List<PropertyData>::Element *F = p_exposed_class.properties.front(); F; F = F->next()) {
|
||||
TEST_CHECK(validate_property(p_context, p_exposed_class, F->get()));
|
||||
}
|
||||
|
||||
for (const List<MethodData>::Element *F = p_exposed_class.methods.front(); F; F = F->next()) {
|
||||
TEST_CHECK(validate_method(p_context, p_exposed_class, F->get()));
|
||||
}
|
||||
|
||||
for (const List<SignalData>::Element *F = p_exposed_class.signals_.front(); F; F = F->next()) {
|
||||
TEST_CHECK(validate_signal(p_context, p_exposed_class, F->get()));
|
||||
}
|
||||
|
||||
TEST_END();
|
||||
}
|
||||
|
||||
TestResult add_exposed_classes(Context &r_context) {
|
||||
TEST_START();
|
||||
|
||||
List<StringName> class_list;
|
||||
ClassDB::get_class_list(&class_list);
|
||||
class_list.sort_custom<StringName::AlphCompare>();
|
||||
|
||||
while (class_list.size()) {
|
||||
StringName class_name = class_list.front()->get();
|
||||
|
||||
ClassDB::APIType api_type = ClassDB::get_api_type(class_name);
|
||||
|
||||
if (api_type == ClassDB::API_NONE) {
|
||||
class_list.pop_front();
|
||||
continue;
|
||||
}
|
||||
|
||||
if (!ClassDB::is_class_exposed(class_name)) {
|
||||
OS::get_singleton()->print("Ignoring class '%s' because it's not exposed\n", String(class_name).utf8().get_data());
|
||||
class_list.pop_front();
|
||||
continue;
|
||||
}
|
||||
|
||||
if (!ClassDB::is_class_enabled(class_name)) {
|
||||
OS::get_singleton()->print("Ignoring class '%s' because it's not enabled\n", String(class_name).utf8().get_data());
|
||||
class_list.pop_front();
|
||||
continue;
|
||||
}
|
||||
|
||||
ClassDB::ClassInfo *class_info = ClassDB::classes.getptr(class_name);
|
||||
|
||||
ExposedClass exposed_class;
|
||||
exposed_class.name = class_name;
|
||||
exposed_class.api_type = api_type;
|
||||
exposed_class.is_singleton = Engine::get_singleton()->has_singleton(class_name);
|
||||
exposed_class.is_instantiable = class_info->creation_func && !exposed_class.is_singleton;
|
||||
exposed_class.is_reference = ClassDB::is_parent_class(class_name, "Reference");
|
||||
exposed_class.base = ClassDB::get_parent_class(class_name);
|
||||
|
||||
// Add properties
|
||||
|
||||
List<PropertyInfo> property_list;
|
||||
ClassDB::get_property_list(class_name, &property_list, true);
|
||||
|
||||
Map<StringName, StringName> accessor_methods;
|
||||
|
||||
for (const List<PropertyInfo>::Element *E = property_list.front(); E; E = E->next()) {
|
||||
const PropertyInfo &property = E->get();
|
||||
|
||||
if (property.usage & PROPERTY_USAGE_GROUP || property.usage & PROPERTY_USAGE_SUBGROUP || property.usage & PROPERTY_USAGE_CATEGORY) {
|
||||
continue;
|
||||
}
|
||||
|
||||
PropertyData prop;
|
||||
prop.name = property.name;
|
||||
prop.setter = ClassDB::get_property_setter(class_name, prop.name);
|
||||
prop.getter = ClassDB::get_property_getter(class_name, prop.name);
|
||||
|
||||
if (prop.setter != StringName()) {
|
||||
accessor_methods[prop.setter] = prop.name;
|
||||
}
|
||||
if (prop.getter != StringName()) {
|
||||
accessor_methods[prop.getter] = prop.name;
|
||||
}
|
||||
|
||||
bool valid = false;
|
||||
prop.index = ClassDB::get_property_index(class_name, prop.name, &valid);
|
||||
TEST_FAIL_COND(!valid, "Invalid property: '" + exposed_class.name + "." + String(prop.name) + "'.");
|
||||
|
||||
exposed_class.properties.push_back(prop);
|
||||
}
|
||||
|
||||
// Add methods
|
||||
|
||||
List<MethodInfo> virtual_method_list;
|
||||
ClassDB::get_virtual_methods(class_name, &virtual_method_list, true);
|
||||
|
||||
List<MethodInfo> method_list;
|
||||
ClassDB::get_method_list(class_name, &method_list, true);
|
||||
method_list.sort();
|
||||
|
||||
for (List<MethodInfo>::Element *E = method_list.front(); E; E = E->next()) {
|
||||
const MethodInfo &method_info = E->get();
|
||||
|
||||
int argc = method_info.arguments.size();
|
||||
|
||||
if (method_info.name.empty()) {
|
||||
continue;
|
||||
}
|
||||
|
||||
MethodData method;
|
||||
method.name = method_info.name;
|
||||
|
||||
if (method_info.flags & METHOD_FLAG_VIRTUAL) {
|
||||
method.is_virtual = true;
|
||||
}
|
||||
|
||||
PropertyInfo return_info = method_info.return_val;
|
||||
|
||||
MethodBind *m = method.is_virtual ? nullptr : ClassDB::get_method(class_name, method_info.name);
|
||||
|
||||
method.is_vararg = m && m->is_vararg();
|
||||
|
||||
if (!m && !method.is_virtual) {
|
||||
TEST_FAIL_COND(!virtual_method_list.find(method_info),
|
||||
"Missing MethodBind for non-virtual method: '" + exposed_class.name + "." + method.name + "'.");
|
||||
|
||||
// A virtual method without the virtual flag. This is a special case.
|
||||
|
||||
// The method Object.free is registered as a virtual method, but without the virtual flag.
|
||||
// This is because this method is not supposed to be overridden, but called.
|
||||
// We assume the return type is void.
|
||||
method.return_type.name = r_context.names_cache.void_type;
|
||||
|
||||
// Actually, more methods like this may be added in the future, which could return
|
||||
// something different. Let's put this check to notify us if that ever happens.
|
||||
if (exposed_class.name != r_context.names_cache.object_class || String(method.name) != "free") {
|
||||
WARN_PRINT("Notification: New unexpected virtual non-overridable method found."
|
||||
" We only expected Object.free, but found '" +
|
||||
exposed_class.name + "." + method.name + "'.");
|
||||
}
|
||||
} else if (return_info.type == Variant::INT && return_info.usage & PROPERTY_USAGE_CLASS_IS_ENUM) {
|
||||
method.return_type.name = return_info.class_name;
|
||||
method.return_type.is_enum = true;
|
||||
} else if (return_info.class_name != StringName()) {
|
||||
method.return_type.name = return_info.class_name;
|
||||
|
||||
bool bad_reference_hint = !method.is_virtual && return_info.hint != PROPERTY_HINT_RESOURCE_TYPE &&
|
||||
ClassDB::is_parent_class(return_info.class_name, r_context.names_cache.reference_class);
|
||||
TEST_FAIL_COND(bad_reference_hint, String() + "Return type is reference but hint is not '" _STR(PROPERTY_HINT_RESOURCE_TYPE) "'." +
|
||||
" Are you returning a reference type by pointer? Method: '" +
|
||||
exposed_class.name + "." + method.name + "'.");
|
||||
} else if (return_info.hint == PROPERTY_HINT_RESOURCE_TYPE) {
|
||||
method.return_type.name = return_info.hint_string;
|
||||
} else if (return_info.type == Variant::NIL && return_info.usage & PROPERTY_USAGE_NIL_IS_VARIANT) {
|
||||
method.return_type.name = r_context.names_cache.variant_type;
|
||||
} else if (return_info.type == Variant::NIL) {
|
||||
method.return_type.name = r_context.names_cache.void_type;
|
||||
} else {
|
||||
// NOTE: We don't care about the size and sign of int and float in these tests
|
||||
method.return_type.name = Variant::get_type_name(return_info.type);
|
||||
}
|
||||
|
||||
for (int i = 0; i < argc; i++) {
|
||||
PropertyInfo arg_info = method_info.arguments[i];
|
||||
|
||||
String orig_arg_name = arg_info.name;
|
||||
|
||||
ArgumentData arg;
|
||||
arg.name = orig_arg_name;
|
||||
|
||||
if (arg_info.type == Variant::INT && arg_info.usage & PROPERTY_USAGE_CLASS_IS_ENUM) {
|
||||
arg.type.name = arg_info.class_name;
|
||||
arg.type.is_enum = true;
|
||||
} else if (arg_info.class_name != StringName()) {
|
||||
arg.type.name = arg_info.class_name;
|
||||
} else if (arg_info.hint == PROPERTY_HINT_RESOURCE_TYPE) {
|
||||
arg.type.name = arg_info.hint_string;
|
||||
} else if (arg_info.type == Variant::NIL) {
|
||||
arg.type.name = r_context.names_cache.variant_type;
|
||||
} else {
|
||||
// NOTE: We don't care about the size and sign of int and float in these tests
|
||||
arg.type.name = Variant::get_type_name(arg_info.type);
|
||||
}
|
||||
|
||||
if (m && m->has_default_argument(i)) {
|
||||
arg.has_defval = true;
|
||||
arg.defval = m->get_default_argument(i);
|
||||
}
|
||||
|
||||
method.arguments.push_back(arg);
|
||||
}
|
||||
|
||||
if (method.is_vararg) {
|
||||
ArgumentData vararg;
|
||||
vararg.type.name = r_context.names_cache.vararg_stub_type;
|
||||
vararg.name = "@varargs@";
|
||||
method.arguments.push_back(vararg);
|
||||
}
|
||||
|
||||
TEST_FAIL_COND(exposed_class.find_property_by_name(method.name),
|
||||
"Method name conflicts with property: '" + String(class_name) + "." + String(method.name) + "'.");
|
||||
|
||||
// Classes starting with an underscore are ignored unless they're used as a property setter or getter
|
||||
if (!method.is_virtual && String(method.name)[0] == '_') {
|
||||
for (const List<PropertyData>::Element *F = exposed_class.properties.front(); F; F = F->next()) {
|
||||
const PropertyData &prop = F->get();
|
||||
|
||||
if (prop.setter == method.name || prop.getter == method.name) {
|
||||
exposed_class.methods.push_back(method);
|
||||
break;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
exposed_class.methods.push_back(method);
|
||||
}
|
||||
}
|
||||
|
||||
// Add signals
|
||||
|
||||
const HashMap<StringName, MethodInfo> &signal_map = class_info->signal_map;
|
||||
const StringName *k = nullptr;
|
||||
|
||||
while ((k = signal_map.next(k))) {
|
||||
SignalData signal;
|
||||
|
||||
const MethodInfo &method_info = signal_map.get(*k);
|
||||
|
||||
signal.name = method_info.name;
|
||||
|
||||
int argc = method_info.arguments.size();
|
||||
|
||||
for (int i = 0; i < argc; i++) {
|
||||
PropertyInfo arg_info = method_info.arguments[i];
|
||||
|
||||
String orig_arg_name = arg_info.name;
|
||||
|
||||
ArgumentData arg;
|
||||
arg.name = orig_arg_name;
|
||||
|
||||
if (arg_info.type == Variant::INT && arg_info.usage & PROPERTY_USAGE_CLASS_IS_ENUM) {
|
||||
arg.type.name = arg_info.class_name;
|
||||
arg.type.is_enum = true;
|
||||
} else if (arg_info.class_name != StringName()) {
|
||||
arg.type.name = arg_info.class_name;
|
||||
} else if (arg_info.hint == PROPERTY_HINT_RESOURCE_TYPE) {
|
||||
arg.type.name = arg_info.hint_string;
|
||||
} else if (arg_info.type == Variant::NIL) {
|
||||
arg.type.name = r_context.names_cache.variant_type;
|
||||
} else {
|
||||
// NOTE: We don't care about the size and sign of int and float in these tests
|
||||
arg.type.name = Variant::get_type_name(arg_info.type);
|
||||
}
|
||||
|
||||
signal.arguments.push_back(arg);
|
||||
}
|
||||
|
||||
bool method_conflict = exposed_class.find_property_by_name(signal.name);
|
||||
|
||||
if (method_conflict || exposed_class.find_method_by_name(signal.name)) {
|
||||
// TODO:
|
||||
// ClassDB allows signal names that conflict with method or property names.
|
||||
// However registering a signal with a conflicting name is still considered wrong.
|
||||
// Unfortunately there are some existing cases that are yet to be fixed.
|
||||
// Until those are fixed we will print a warning instead of failing the test.
|
||||
WARN_PRINT("Signal name conflicts with " + String(method_conflict ? "method" : "property") +
|
||||
": '" + String(class_name) + "." + String(signal.name) + "'.");
|
||||
}
|
||||
|
||||
exposed_class.signals_.push_back(signal);
|
||||
}
|
||||
|
||||
// Add enums and constants
|
||||
|
||||
List<String> constants;
|
||||
ClassDB::get_integer_constant_list(class_name, &constants, true);
|
||||
|
||||
const HashMap<StringName, List<StringName>> &enum_map = class_info->enum_map;
|
||||
k = nullptr;
|
||||
|
||||
while ((k = enum_map.next(k))) {
|
||||
EnumData enum_;
|
||||
enum_.name = *k;
|
||||
|
||||
const List<StringName> &enum_constants = enum_map.get(*k);
|
||||
for (const List<StringName>::Element *E = enum_constants.front(); E; E = E->next()) {
|
||||
const StringName &constant_name = E->get();
|
||||
int *value = class_info->constant_map.getptr(constant_name);
|
||||
TEST_FAIL_COND(!value, "Missing enum constant value: '" +
|
||||
String(class_name) + "." + String(enum_.name) + "." + String(constant_name) + "'.");
|
||||
constants.erase(constant_name);
|
||||
|
||||
ConstantData constant;
|
||||
constant.name = constant_name;
|
||||
constant.value = *value;
|
||||
|
||||
enum_.constants.push_back(constant);
|
||||
}
|
||||
|
||||
exposed_class.enums.push_back(enum_);
|
||||
|
||||
r_context.enum_types.push_back(String(class_name) + "." + String(*k));
|
||||
}
|
||||
|
||||
for (const List<String>::Element *E = constants.front(); E; E = E->next()) {
|
||||
const String &constant_name = E->get();
|
||||
int *value = class_info->constant_map.getptr(StringName(E->get()));
|
||||
TEST_FAIL_COND(!value, "Missing enum constant value: '" + String(class_name) + "." + String(constant_name) + "'.");
|
||||
|
||||
ConstantData constant;
|
||||
constant.name = constant_name;
|
||||
constant.value = *value;
|
||||
|
||||
exposed_class.constants.push_back(constant);
|
||||
}
|
||||
|
||||
r_context.exposed_classes.insert(class_name, exposed_class);
|
||||
class_list.pop_front();
|
||||
}
|
||||
|
||||
TEST_END();
|
||||
}
|
||||
|
||||
void add_builtin_types(Context &r_context) {
|
||||
// NOTE: We don't care about the size and sign of int and float in these tests
|
||||
for (int i = 0; i < Variant::VARIANT_MAX; i++) {
|
||||
r_context.builtin_types.push_back(Variant::get_type_name(Variant::Type(i)));
|
||||
}
|
||||
|
||||
r_context.builtin_types.push_back(_STR(Variant));
|
||||
r_context.builtin_types.push_back(r_context.names_cache.vararg_stub_type);
|
||||
r_context.builtin_types.push_back("void");
|
||||
}
|
||||
|
||||
void add_global_enums(Context &r_context) {
|
||||
int global_constants_count = GlobalConstants::get_global_constant_count();
|
||||
|
||||
if (global_constants_count > 0) {
|
||||
for (int i = 0; i < global_constants_count; i++) {
|
||||
StringName enum_name = GlobalConstants::get_global_constant_enum(i);
|
||||
|
||||
if (enum_name != StringName()) {
|
||||
ConstantData constant;
|
||||
constant.name = GlobalConstants::get_global_constant_name(i);
|
||||
constant.value = GlobalConstants::get_global_constant_value(i);
|
||||
|
||||
EnumData enum_;
|
||||
enum_.name = enum_name;
|
||||
List<EnumData>::Element *enum_match = r_context.global_enums.find(enum_);
|
||||
if (enum_match) {
|
||||
enum_match->get().constants.push_back(constant);
|
||||
} else {
|
||||
enum_.constants.push_back(constant);
|
||||
r_context.global_enums.push_back(enum_);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (List<EnumData>::Element *E = r_context.global_enums.front(); E; E = E->next()) {
|
||||
r_context.enum_types.push_back(E->get().name);
|
||||
}
|
||||
}
|
||||
|
||||
// HARDCODED
|
||||
List<StringName> hardcoded_enums;
|
||||
hardcoded_enums.push_back("Vector2.Axis");
|
||||
hardcoded_enums.push_back("Vector2i.Axis");
|
||||
hardcoded_enums.push_back("Vector3.Axis");
|
||||
hardcoded_enums.push_back("Vector3i.Axis");
|
||||
for (List<StringName>::Element *E = hardcoded_enums.front(); E; E = E->next()) {
|
||||
// These enums are not generated and must be written manually (e.g.: Vector3.Axis)
|
||||
// Here, we assume core types do not begin with underscore
|
||||
r_context.enum_types.push_back(E->get());
|
||||
}
|
||||
}
|
||||
|
||||
TestResult run_class_db_tests() {
|
||||
TEST_START();
|
||||
|
||||
Context context;
|
||||
|
||||
TEST_CHECK_FATAL(add_exposed_classes(context));
|
||||
add_builtin_types(context);
|
||||
add_global_enums(context);
|
||||
|
||||
const ExposedClass *object_class = context.find_exposed_class(context.names_cache.object_class);
|
||||
TEST_FAIL_COND_FATAL(!object_class, "Object class not found.");
|
||||
TEST_FAIL_COND_FATAL(object_class->base != StringName(),
|
||||
"Object class derives from another class: '" + object_class->base + "'.");
|
||||
|
||||
for (ExposedClasses::Element E = context.exposed_classes.front(); E; E = E.next()) {
|
||||
TEST_CHECK(validate_class(context, E.value()));
|
||||
}
|
||||
|
||||
TEST_END();
|
||||
}
|
||||
|
||||
MainLoop *test() {
|
||||
TestResult pass = run_class_db_tests();
|
||||
|
||||
OS::get_singleton()->print("ClassDB tests: %s\n", pass == TestResult::PASS ? "PASS" : "FAILED");
|
||||
|
||||
if (pass == TestResult::FAILED) {
|
||||
OS::get_singleton()->set_exit_code(pass == TestResult::PASS ? 0 : 1);
|
||||
}
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
} // namespace TestClassDB
|
||||
|
|
@ -0,0 +1,42 @@
|
|||
/*************************************************************************/
|
||||
/* test_class_db.h */
|
||||
/*************************************************************************/
|
||||
/* This file is part of: */
|
||||
/* GODOT ENGINE */
|
||||
/* https://godotengine.org */
|
||||
/*************************************************************************/
|
||||
/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
|
||||
/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
|
||||
/* */
|
||||
/* Permission is hereby granted, free of charge, to any person obtaining */
|
||||
/* a copy of this software and associated documentation files (the */
|
||||
/* "Software"), to deal in the Software without restriction, including */
|
||||
/* without limitation the rights to use, copy, modify, merge, publish, */
|
||||
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
||||
/* permit persons to whom the Software is furnished to do so, subject to */
|
||||
/* the following conditions: */
|
||||
/* */
|
||||
/* The above copyright notice and this permission notice shall be */
|
||||
/* included in all copies or substantial portions of the Software. */
|
||||
/* */
|
||||
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
||||
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
||||
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
||||
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
||||
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
||||
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
||||
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
||||
/*************************************************************************/
|
||||
|
||||
#ifndef GODOT_TEST_CLASS_DB_H
|
||||
#define GODOT_TEST_CLASS_DB_H
|
||||
|
||||
#include "core/os/main_loop.h"
|
||||
|
||||
namespace TestClassDB {
|
||||
|
||||
MainLoop *test();
|
||||
|
||||
}
|
||||
|
||||
#endif //GODOT_TEST_CLASS_DB_H
|
||||
|
|
@ -35,6 +35,7 @@
|
|||
#ifdef DEBUG_ENABLED
|
||||
|
||||
#include "test_astar.h"
|
||||
#include "test_class_db.h"
|
||||
#include "test_gdscript.h"
|
||||
#include "test_gui.h"
|
||||
#include "test_math.h"
|
||||
|
|
@ -54,6 +55,7 @@ const char **tests_get_names() {
|
|||
"physics_3d",
|
||||
"render",
|
||||
"oa_hash_map",
|
||||
"class_db",
|
||||
"gui",
|
||||
"shaderlang",
|
||||
"gd_tokenizer",
|
||||
|
|
@ -93,6 +95,10 @@ MainLoop *test_main(String p_test, const List<String> &p_args) {
|
|||
return TestOAHashMap::test();
|
||||
}
|
||||
|
||||
if (p_test == "class_db") {
|
||||
return TestClassDB::test();
|
||||
}
|
||||
|
||||
#ifndef _3D_DISABLED
|
||||
if (p_test == "gui") {
|
||||
return TestGUI::test();
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -102,6 +102,8 @@ class BindingsGenerator {
|
|||
TypeReference type;
|
||||
|
||||
String name;
|
||||
|
||||
Variant def_param_value;
|
||||
DefaultParamMode def_param_mode = CONSTANT;
|
||||
|
||||
/**
|
||||
|
|
@ -355,8 +357,9 @@ class BindingsGenerator {
|
|||
|
||||
const MethodInterface *find_method_by_name(const StringName &p_cname) const {
|
||||
for (const List<MethodInterface>::Element *E = methods.front(); E; E = E->next()) {
|
||||
if (E->get().cname == p_cname)
|
||||
if (E->get().cname == p_cname) {
|
||||
return &E->get();
|
||||
}
|
||||
}
|
||||
|
||||
return nullptr;
|
||||
|
|
@ -364,8 +367,9 @@ class BindingsGenerator {
|
|||
|
||||
const PropertyInterface *find_property_by_name(const StringName &p_cname) const {
|
||||
for (const List<PropertyInterface>::Element *E = properties.front(); E; E = E->next()) {
|
||||
if (E->get().cname == p_cname)
|
||||
if (E->get().cname == p_cname) {
|
||||
return &E->get();
|
||||
}
|
||||
}
|
||||
|
||||
return nullptr;
|
||||
|
|
@ -373,8 +377,9 @@ class BindingsGenerator {
|
|||
|
||||
const PropertyInterface *find_property_by_proxy_name(const String &p_proxy_name) const {
|
||||
for (const List<PropertyInterface>::Element *E = properties.front(); E; E = E->next()) {
|
||||
if (E->get().proxy_name == p_proxy_name)
|
||||
if (E->get().proxy_name == p_proxy_name) {
|
||||
return &E->get();
|
||||
}
|
||||
}
|
||||
|
||||
return nullptr;
|
||||
|
|
@ -382,8 +387,9 @@ class BindingsGenerator {
|
|||
|
||||
const MethodInterface *find_method_by_proxy_name(const String &p_proxy_name) const {
|
||||
for (const List<MethodInterface>::Element *E = methods.front(); E; E = E->next()) {
|
||||
if (E->get().proxy_name == p_proxy_name)
|
||||
if (E->get().proxy_name == p_proxy_name) {
|
||||
return &E->get();
|
||||
}
|
||||
}
|
||||
|
||||
return nullptr;
|
||||
|
|
@ -523,58 +529,70 @@ class BindingsGenerator {
|
|||
void _initialize_blacklisted_methods();
|
||||
|
||||
struct NameCache {
|
||||
StringName type_void;
|
||||
StringName type_Array;
|
||||
StringName type_Dictionary;
|
||||
StringName type_Variant;
|
||||
StringName type_VarArg;
|
||||
StringName type_Object;
|
||||
StringName type_Reference;
|
||||
StringName type_RID;
|
||||
StringName type_String;
|
||||
StringName type_StringName;
|
||||
StringName type_NodePath;
|
||||
StringName type_at_GlobalScope;
|
||||
StringName enum_Error;
|
||||
StringName type_void = StaticCString::create("void");
|
||||
StringName type_Variant = StaticCString::create("Variant");
|
||||
StringName type_VarArg = StaticCString::create("VarArg");
|
||||
StringName type_Object = StaticCString::create("Object");
|
||||
StringName type_Reference = StaticCString::create("Reference");
|
||||
StringName type_RID = StaticCString::create("RID");
|
||||
StringName type_String = StaticCString::create("String");
|
||||
StringName type_StringName = StaticCString::create("StringName");
|
||||
StringName type_NodePath = StaticCString::create("NodePath");
|
||||
StringName type_at_GlobalScope = StaticCString::create("@GlobalScope");
|
||||
StringName enum_Error = StaticCString::create("Error");
|
||||
|
||||
StringName type_sbyte;
|
||||
StringName type_short;
|
||||
StringName type_int;
|
||||
StringName type_long;
|
||||
StringName type_byte;
|
||||
StringName type_ushort;
|
||||
StringName type_uint;
|
||||
StringName type_ulong;
|
||||
StringName type_float;
|
||||
StringName type_double;
|
||||
StringName type_sbyte = StaticCString::create("sbyte");
|
||||
StringName type_short = StaticCString::create("short");
|
||||
StringName type_int = StaticCString::create("int");
|
||||
StringName type_byte = StaticCString::create("byte");
|
||||
StringName type_ushort = StaticCString::create("ushort");
|
||||
StringName type_uint = StaticCString::create("uint");
|
||||
StringName type_long = StaticCString::create("long");
|
||||
StringName type_ulong = StaticCString::create("ulong");
|
||||
|
||||
NameCache() {
|
||||
type_void = StaticCString::create("void");
|
||||
type_Array = StaticCString::create("Array");
|
||||
type_Dictionary = StaticCString::create("Dictionary");
|
||||
type_Variant = StaticCString::create("Variant");
|
||||
type_VarArg = StaticCString::create("VarArg");
|
||||
type_Object = StaticCString::create("Object");
|
||||
type_Reference = StaticCString::create("Reference");
|
||||
type_RID = StaticCString::create("RID");
|
||||
type_String = StaticCString::create("String");
|
||||
type_StringName = StaticCString::create("StringName");
|
||||
type_NodePath = StaticCString::create("NodePath");
|
||||
type_at_GlobalScope = StaticCString::create("@GlobalScope");
|
||||
enum_Error = StaticCString::create("Error");
|
||||
StringName type_bool = StaticCString::create("bool");
|
||||
StringName type_float = StaticCString::create("float");
|
||||
StringName type_double = StaticCString::create("double");
|
||||
|
||||
type_sbyte = StaticCString::create("sbyte");
|
||||
type_short = StaticCString::create("short");
|
||||
type_int = StaticCString::create("int");
|
||||
type_long = StaticCString::create("long");
|
||||
type_byte = StaticCString::create("byte");
|
||||
type_ushort = StaticCString::create("ushort");
|
||||
type_uint = StaticCString::create("uint");
|
||||
type_ulong = StaticCString::create("ulong");
|
||||
type_float = StaticCString::create("float");
|
||||
type_double = StaticCString::create("double");
|
||||
StringName type_Vector2 = StaticCString::create("Vector2");
|
||||
StringName type_Rect2 = StaticCString::create("Rect2");
|
||||
StringName type_Vector3 = StaticCString::create("Vector3");
|
||||
|
||||
// Object not included as it must be checked for all derived classes
|
||||
static constexpr int nullable_types_count = 17;
|
||||
StringName nullable_types[nullable_types_count] = {
|
||||
type_String,
|
||||
type_StringName,
|
||||
type_NodePath,
|
||||
|
||||
StaticCString::create(_STR(Array)),
|
||||
StaticCString::create(_STR(Dictionary)),
|
||||
StaticCString::create(_STR(Callable)),
|
||||
StaticCString::create(_STR(Signal)),
|
||||
|
||||
StaticCString::create(_STR(PackedByteArray)),
|
||||
StaticCString::create(_STR(PackedInt32Array)),
|
||||
StaticCString::create(_STR(PackedInt64rray)),
|
||||
StaticCString::create(_STR(PackedFloat32Array)),
|
||||
StaticCString::create(_STR(PackedFloat64Array)),
|
||||
StaticCString::create(_STR(PackedStringArray)),
|
||||
StaticCString::create(_STR(PackedVector2Array)),
|
||||
StaticCString::create(_STR(PackedVector3Array)),
|
||||
StaticCString::create(_STR(PackedColorArray)),
|
||||
};
|
||||
|
||||
bool is_nullable_type(const StringName &p_type) const {
|
||||
for (int i = 0; i < nullable_types_count; i++) {
|
||||
if (p_type == nullable_types[i]) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
NameCache() {}
|
||||
|
||||
private:
|
||||
NameCache(const NameCache &);
|
||||
NameCache &operator=(const NameCache &);
|
||||
|
|
@ -585,8 +603,9 @@ class BindingsGenerator {
|
|||
const List<InternalCall>::Element *find_icall_by_name(const String &p_name, const List<InternalCall> &p_list) {
|
||||
const List<InternalCall>::Element *it = p_list.front();
|
||||
while (it) {
|
||||
if (it->get().name == p_name)
|
||||
if (it->get().name == p_name) {
|
||||
return it;
|
||||
}
|
||||
it = it->next();
|
||||
}
|
||||
return nullptr;
|
||||
|
|
@ -594,20 +613,22 @@ class BindingsGenerator {
|
|||
|
||||
const ConstantInterface *find_constant_by_name(const String &p_name, const List<ConstantInterface> &p_constants) const {
|
||||
for (const List<ConstantInterface>::Element *E = p_constants.front(); E; E = E->next()) {
|
||||
if (E->get().name == p_name)
|
||||
if (E->get().name == p_name) {
|
||||
return &E->get();
|
||||
}
|
||||
}
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
inline String get_unique_sig(const TypeInterface &p_type) {
|
||||
if (p_type.is_reference)
|
||||
if (p_type.is_reference) {
|
||||
return "Ref";
|
||||
else if (p_type.is_object_type)
|
||||
} else if (p_type.is_object_type) {
|
||||
return "Obj";
|
||||
else if (p_type.is_enum)
|
||||
} else if (p_type.is_enum) {
|
||||
return "int";
|
||||
}
|
||||
|
||||
return p_type.name;
|
||||
}
|
||||
|
|
@ -626,6 +647,7 @@ class BindingsGenerator {
|
|||
StringName _get_float_type_name_from_meta(GodotTypeInfo::Metadata p_meta);
|
||||
|
||||
bool _arg_default_value_from_variant(const Variant &p_val, ArgumentInterface &r_iarg);
|
||||
bool _arg_default_value_is_assignable_to_type(const Variant &p_val, const TypeInterface &p_arg_type);
|
||||
|
||||
bool _populate_object_type_interfaces();
|
||||
void _populate_builtin_type_interfaces();
|
||||
|
|
|
|||
Loading…
Reference in New Issue