From eeaf5ebd88379ddb861f0d9f6b022737b8f6e44f Mon Sep 17 00:00:00 2001
From: rune-scape <spartacrafter@gmail.com>
Date: Tue, 18 Jun 2024 04:21:22 -0700
Subject: [PATCH] Variant: add method `get_full_type_name` and used in many
 places

---
 core/math/expression.cpp                      |  6 +-
 core/variant/array.cpp                        | 12 +--
 core/variant/container_type_validate.h        | 43 ++++++++++-
 core/variant/variant.cpp                      | 74 ++++++++++++++++++-
 core/variant/variant.h                        |  1 +
 editor/animation_track_editor.cpp             |  2 +-
 editor/connections_dialog.cpp                 |  2 +-
 .../debug_adapter/debug_adapter_protocol.cpp  |  6 +-
 modules/gdscript/gdscript_analyzer.cpp        |  8 +-
 modules/gdscript/gdscript_parser.cpp          |  2 +-
 .../gdscript/gdscript_utility_functions.cpp   |  2 +-
 modules/gdscript/gdscript_vm.cpp              | 28 +++----
 .../runtime/errors/global_base.notest.gd      |  1 +
 .../runtime/errors/global_class_1.notest.gd   |  1 +
 .../runtime/errors/global_class_2.notest.gd   |  1 +
 .../typed_array_assign_wrong_to_typed.gd      |  6 +-
 .../typed_array_assign_wrong_to_typed.out     |  2 +-
 modules/gdscript/tests/test_gdscript.cpp      |  2 +-
 .../editor/editor_import_blend_runner.cpp     |  4 +-
 modules/mono/editor/bindings_generator.cpp    | 12 +--
 modules/mono/glue/runtime_interop.cpp         |  2 +-
 scene/animation/tween.cpp                     |  2 +-
 scene/resources/theme.cpp                     | 12 +--
 23 files changed, 172 insertions(+), 59 deletions(-)
 create mode 100644 modules/gdscript/tests/scripts/runtime/errors/global_base.notest.gd
 create mode 100644 modules/gdscript/tests/scripts/runtime/errors/global_class_1.notest.gd
 create mode 100644 modules/gdscript/tests/scripts/runtime/errors/global_class_2.notest.gd

diff --git a/core/math/expression.cpp b/core/math/expression.cpp
index 35303fe9ac47..9d317a1b6613 100644
--- a/core/math/expression.cpp
+++ b/core/math/expression.cpp
@@ -1278,7 +1278,7 @@ bool Expression::_execute(const Array &p_inputs, Object *p_instance, Expression:
 			bool valid = true;
 			Variant::evaluate(op->op, a, b, r_ret, valid);
 			if (!valid) {
-				r_error_str = vformat(RTR("Invalid operands to operator %s, %s and %s."), Variant::get_operator_name(op->op), Variant::get_type_name(a.get_type()), Variant::get_type_name(b.get_type()));
+				r_error_str = vformat(RTR("Invalid operands to operator %s, %s and %s."), Variant::get_operator_name(op->op), a.get_full_type_name(), b.get_full_type_name());
 				return true;
 			}
 
@@ -1302,7 +1302,7 @@ bool Expression::_execute(const Array &p_inputs, Object *p_instance, Expression:
 			bool valid;
 			r_ret = base.get(idx, &valid);
 			if (!valid) {
-				r_error_str = vformat(RTR("Invalid index of type %s for base type %s"), Variant::get_type_name(idx.get_type()), Variant::get_type_name(base.get_type()));
+				r_error_str = vformat(RTR("Invalid index of type %s for base type %s"), idx.get_full_type_name(), base.get_full_type_name());
 				return true;
 			}
 
@@ -1319,7 +1319,7 @@ bool Expression::_execute(const Array &p_inputs, Object *p_instance, Expression:
 			bool valid;
 			r_ret = base.get_named(index->name, valid);
 			if (!valid) {
-				r_error_str = vformat(RTR("Invalid named index '%s' for base type %s"), String(index->name), Variant::get_type_name(base.get_type()));
+				r_error_str = vformat(RTR("Invalid named index '%s' for base type %s"), String(index->name), base.get_full_type_name());
 				return true;
 			}
 
diff --git a/core/variant/array.cpp b/core/variant/array.cpp
index f7a86b8fa386..115147592710 100644
--- a/core/variant/array.cpp
+++ b/core/variant/array.cpp
@@ -235,14 +235,14 @@ void Array::assign(const Array &p_array) {
 		for (int i = 0; i < size; i++) {
 			const Variant &element = source[i];
 			if (element.get_type() != Variant::NIL && (element.get_type() != Variant::OBJECT || !typed.validate_object(element, "assign"))) {
-				ERR_FAIL_MSG(vformat(R"(Unable to convert array index %d from "%s" to "%s".)", i, Variant::get_type_name(element.get_type()), Variant::get_type_name(typed.type)));
+				ERR_FAIL_MSG(vformat(R"(Unable to convert array index %d from "%s" to "%s".)", i, element.get_full_type_name(), typed.get_contained_type_name()));
 			}
 		}
 		_p->array = p_array._p->array;
 		return;
 	}
 	if (typed.type == Variant::OBJECT || source_typed.type == Variant::OBJECT) {
-		ERR_FAIL_MSG(vformat(R"(Cannot assign contents of "Array[%s]" to "Array[%s]".)", Variant::get_type_name(source_typed.type), Variant::get_type_name(typed.type)));
+		ERR_FAIL_MSG(vformat(R"(Cannot assign contents of "Array[%s]" to "Array[%s]".)", source_typed.get_contained_type_name(), typed.get_contained_type_name()));
 	}
 
 	Vector<Variant> array;
@@ -258,11 +258,11 @@ void Array::assign(const Array &p_array) {
 				continue;
 			}
 			if (!Variant::can_convert_strict(value->get_type(), typed.type)) {
-				ERR_FAIL_MSG(vformat(R"(Unable to convert array index %d from "%s" to "%s".)", i, Variant::get_type_name(value->get_type()), Variant::get_type_name(typed.type)));
+				ERR_FAIL_MSG(vformat(R"(Unable to convert array index %d from "%s" to "%s".)", i, value->get_full_type_name(), typed.get_contained_type_name()));
 			}
 			Callable::CallError ce;
 			Variant::construct(typed.type, data[i], &value, 1, ce);
-			ERR_FAIL_COND_MSG(ce.error, vformat(R"(Unable to convert array index %d from "%s" to "%s".)", i, Variant::get_type_name(value->get_type()), Variant::get_type_name(typed.type)));
+			ERR_FAIL_COND_MSG(ce.error, vformat(R"(Unable to convert array index %d from "%s" to "%s".)", i, value->get_full_type_name(), typed.get_contained_type_name()));
 		}
 	} else if (Variant::can_convert_strict(source_typed.type, typed.type)) {
 		// from primitives to different convertible primitives
@@ -270,10 +270,10 @@ void Array::assign(const Array &p_array) {
 			const Variant *value = source + i;
 			Callable::CallError ce;
 			Variant::construct(typed.type, data[i], &value, 1, ce);
-			ERR_FAIL_COND_MSG(ce.error, vformat(R"(Unable to convert array index %d from "%s" to "%s".)", i, Variant::get_type_name(value->get_type()), Variant::get_type_name(typed.type)));
+			ERR_FAIL_COND_MSG(ce.error, vformat(R"(Unable to convert array index %d from "%s" to "%s".)", i, value->get_full_type_name(), typed.get_contained_type_name()));
 		}
 	} else {
-		ERR_FAIL_MSG(vformat(R"(Cannot assign contents of "Array[%s]" to "Array[%s]".)", Variant::get_type_name(source_typed.type), Variant::get_type_name(typed.type)));
+		ERR_FAIL_MSG(vformat(R"(Cannot assign contents of "Array[%s]" to "Array[%s]".)", source_typed.get_contained_type_name(), typed.get_contained_type_name()));
 	}
 
 	_p->array = array;
diff --git a/core/variant/container_type_validate.h b/core/variant/container_type_validate.h
index 8971fadf7320..25fcc02cab87 100644
--- a/core/variant/container_type_validate.h
+++ b/core/variant/container_type_validate.h
@@ -34,12 +34,53 @@
 #include "core/object/script_language.h"
 #include "core/variant/variant.h"
 
+#include "modules/modules_enabled.gen.h"
+
+#ifdef MODULE_GDSCRIPT_ENABLED
+#include "modules/gdscript/gdscript.h"
+#endif // MODULE_GDSCRIPT_ENABLED
+
 struct ContainerTypeValidate {
 	Variant::Type type = Variant::NIL;
 	StringName class_name;
 	Ref<Script> script;
 	const char *where = "container";
 
+	String get_contained_type_name() const {
+		if (type == Variant::NIL) {
+			return "";
+		}
+
+		String contained_typename;
+		if (type != Variant::OBJECT) {
+			contained_typename = Variant::get_type_name(type);
+		} else {
+			contained_typename = class_name;
+			if (contained_typename.is_empty()) {
+				contained_typename = "Object";
+			}
+
+			if (!script.is_null()) {
+				String script_name;
+#ifdef MODULE_GDSCRIPT_ENABLED
+				Ref<GDScript> gdscript = script;
+				if (!gdscript.is_null()) {
+					script_name = gdscript->get_fully_qualified_name();
+				} else
+#endif // MODULE_GDSCRIPT_ENABLED
+				{
+					script_name = script->get_global_name();
+					if (script_name.is_empty()) {
+						script_name = script->get_path();
+					}
+				}
+				contained_typename += " (" + script_name + ")";
+			}
+		}
+
+		return contained_typename;
+	}
+
 	_FORCE_INLINE_ bool can_reference(const ContainerTypeValidate &p_type) const {
 		if (type != p_type.type) {
 			return false;
@@ -94,7 +135,7 @@ struct ContainerTypeValidate {
 				return true;
 			}
 
-			ERR_FAIL_V_MSG(false, vformat("Attempted to %s a variable of type '%s' into a %s of type '%s'.", String(p_operation), Variant::get_type_name(inout_variant.get_type()), where, Variant::get_type_name(type)));
+			ERR_FAIL_V_MSG(false, vformat("Attempted to %s a variable of type '%s' into a %s of type '%s'.", String(p_operation), inout_variant.get_full_type_name(), where, get_contained_type_name()));
 		}
 
 		if (type != Variant::OBJECT) {
diff --git a/core/variant/variant.cpp b/core/variant/variant.cpp
index 65bfc29a555c..7db15ed2edec 100644
--- a/core/variant/variant.cpp
+++ b/core/variant/variant.cpp
@@ -35,6 +35,7 @@
 #include "core/io/marshalls.h"
 #include "core/io/resource.h"
 #include "core/math/math_funcs.h"
+#include "core/object/script_language.h"
 #include "core/string/print_string.h"
 #include "core/variant/variant_parser.h"
 
@@ -176,6 +177,77 @@ String Variant::get_type_name(Variant::Type p_type) {
 	return "";
 }
 
+String Variant::get_full_type_name() const {
+	switch (get_type()) {
+		case OBJECT: {
+			Object *obj = _get_obj().obj;
+			if (obj == nullptr) {
+				return "Object (null instance)";
+			}
+
+			ObjectID id = _get_obj().id;
+			if (!id.is_ref_counted() && ObjectDB::get_instance(id) == nullptr) {
+				return "Object (previously freed)";
+			}
+
+			String class_name = obj->get_class();
+			Vector<Pair<Ref<Script>, String>> scripts;
+			scripts.push_back({ Object::cast_to<Script>(obj), "{0}[{1}]" });
+			scripts.push_back({ obj->get_script(), "{0} ({1})" });
+
+			for (const Pair<Ref<Script>, String> &script_and_fmt : scripts) {
+				const Ref<Script> &script = script_and_fmt.first;
+				const String &fmt = script_and_fmt.second;
+				if (script.is_null()) {
+					continue;
+				}
+
+				String script_name = script->get_global_name();
+				if (script_name.is_empty()) {
+					script_name = script->get_path();
+				}
+				if (!script_name.is_empty()) {
+					Array format_values;
+					format_values.push_back(class_name);
+					format_values.push_back(script_name);
+					class_name = fmt.format(format_values);
+				}
+			}
+
+			return class_name;
+		}
+		case ARRAY: {
+			const Array &arr = *reinterpret_cast<const Array *>(_data._mem);
+			if (!arr.is_typed()) {
+				return "Array";
+			}
+
+			String contained_typename;
+			if (arr.get_typed_builtin() != OBJECT) {
+				contained_typename = get_type_name(get_type());
+			} else {
+				contained_typename = arr.get_typed_class_name();
+				if (contained_typename.is_empty()) {
+					contained_typename = "Object";
+				}
+				Ref<Script> script = arr.get_typed_script();
+				if (!script.is_null()) {
+					String script_name = script->get_global_name();
+					if (script_name.is_empty()) {
+						script_name = script->get_path();
+					}
+					contained_typename += " (" + script_name + ")";
+				}
+			}
+
+			return "Array[" + contained_typename + "]";
+		}
+		default: {
+			return get_type_name(get_type());
+		}
+	}
+}
+
 bool Variant::can_convert(Variant::Type p_type_from, Variant::Type p_type_to) {
 	if (p_type_from == p_type_to) {
 		return true;
@@ -3632,7 +3704,7 @@ String Variant::get_call_error_text(Object *p_base, const StringName &p_method,
 	if (ce.error == Callable::CallError::CALL_ERROR_INVALID_ARGUMENT) {
 		int errorarg = ce.argument;
 		if (p_argptrs) {
-			err_text = "Cannot convert argument " + itos(errorarg + 1) + " from " + Variant::get_type_name(p_argptrs[errorarg]->get_type()) + " to " + Variant::get_type_name(Variant::Type(ce.expected));
+			err_text = "Cannot convert argument " + itos(errorarg + 1) + " from " + p_argptrs[errorarg]->get_full_type_name() + " to " + Variant::get_type_name(Variant::Type(ce.expected));
 		} else {
 			err_text = "Cannot convert argument " + itos(errorarg + 1) + " from [missing argptr, type unknown] to " + Variant::get_type_name(Variant::Type(ce.expected));
 		}
diff --git a/core/variant/variant.h b/core/variant/variant.h
index 9702c67a3719..f123d547c0b5 100644
--- a/core/variant/variant.h
+++ b/core/variant/variant.h
@@ -354,6 +354,7 @@ class Variant {
 		return type;
 	}
 	static String get_type_name(Variant::Type p_type);
+	String get_full_type_name() const;
 	static bool can_convert(Type p_type_from, Type p_type_to);
 	static bool can_convert_strict(Type p_type_from, Type p_type_to);
 	static bool is_type_shared(Variant::Type p_type);
diff --git a/editor/animation_track_editor.cpp b/editor/animation_track_editor.cpp
index c210ad0761b2..05a2ce82d939 100644
--- a/editor/animation_track_editor.cpp
+++ b/editor/animation_track_editor.cpp
@@ -2807,7 +2807,7 @@ String AnimationTrackEdit::get_tooltip(const Point2 &p_pos) const {
 				} break;
 				case Animation::TYPE_VALUE: {
 					const Variant &v = animation->track_get_key_value(track, key_idx);
-					text += TTR("Type:") + " " + Variant::get_type_name(v.get_type()) + "\n";
+					text += TTR("Type:") + " " + v.get_full_type_name() + "\n";
 					Variant::Type valid_type = Variant::NIL;
 					text += TTR("Value:") + " " + String(v);
 					if (!_is_value_key_valid(v, valid_type)) {
diff --git a/editor/connections_dialog.cpp b/editor/connections_dialog.cpp
index b114977c3b1e..66ead4bb9605 100644
--- a/editor/connections_dialog.cpp
+++ b/editor/connections_dialog.cpp
@@ -989,7 +989,7 @@ void ConnectionsDock::_make_or_edit_connection() {
 		PackedStringArray script_function_args = connect_dialog->get_signal_args();
 		script_function_args.resize(script_function_args.size() - cd.unbinds);
 		for (int i = 0; i < cd.binds.size(); i++) {
-			script_function_args.push_back("extra_arg_" + itos(i) + ":" + Variant::get_type_name(cd.binds[i].get_type()));
+			script_function_args.push_back("extra_arg_" + itos(i) + ":" + cd.binds[i].get_full_type_name());
 		}
 
 		EditorNode::get_singleton()->emit_signal(SNAME("script_add_function_request"), target, cd.method, script_function_args);
diff --git a/editor/debugger/debug_adapter/debug_adapter_protocol.cpp b/editor/debugger/debug_adapter/debug_adapter_protocol.cpp
index 066cf6330149..1aead4d9808f 100644
--- a/editor/debugger/debug_adapter/debug_adapter_protocol.cpp
+++ b/editor/debugger/debug_adapter/debug_adapter_protocol.cpp
@@ -434,7 +434,7 @@ int DebugAdapterProtocol::parse_variant(const Variant &p_var) {
 			for (int i = 0; i < array.size(); i++) {
 				DAP::Variable var;
 				var.name = itos(i);
-				var.type = Variant::get_type_name(array[i].get_type());
+				var.type = array[i].get_full_type_name();
 				var.value = array[i];
 				var.variablesReference = parse_variant(array[i]);
 				arr.push_back(var.to_json());
@@ -451,7 +451,7 @@ int DebugAdapterProtocol::parse_variant(const Variant &p_var) {
 				DAP::Variable var;
 				var.name = dictionary.get_key_at_index(i);
 				Variant value = dictionary.get_value_at_index(i);
-				var.type = Variant::get_type_name(value.get_type());
+				var.type = value.get_full_type_name();
 				var.value = value;
 				var.variablesReference = parse_variant(value);
 				arr.push_back(var.to_json());
@@ -1157,7 +1157,7 @@ void DebugAdapterProtocol::on_debug_stack_frame_var(const Array &p_data) {
 
 	variable.name = stack_var.name;
 	variable.value = stack_var.value;
-	variable.type = Variant::get_type_name(stack_var.value.get_type());
+	variable.type = stack_var.value.get_full_type_name();
 	variable.variablesReference = parse_variant(stack_var.value);
 
 	variable_list.find(var_id)->value.push_back(variable.to_json());
diff --git a/modules/gdscript/gdscript_analyzer.cpp b/modules/gdscript/gdscript_analyzer.cpp
index 93d4a512a923..1607f7bc8641 100644
--- a/modules/gdscript/gdscript_analyzer.cpp
+++ b/modules/gdscript/gdscript_analyzer.cpp
@@ -1637,7 +1637,7 @@ void GDScriptAnalyzer::resolve_annotation(GDScriptParser::AnnotationNode *p_anno
 			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);
+				push_error(vformat(R"(Cannot convert argument %d of annotation "%s" from "%s" to "%s".)", i + 1, p_annotation->name, value.get_full_type_name(), Variant::get_type_name(argument_info.type)), argument);
 				return;
 			}
 
@@ -2135,7 +2135,7 @@ void GDScriptAnalyzer::resolve_for(GDScriptParser::ForNode *p_for) {
 						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);
+								push_error(vformat(R"*(Invalid argument for "range()" call. Argument %d should be int or float but "%s" was given.)*", i + 1, argument->reduced_value.get_full_type_name()), argument);
 							}
 							if (can_reduce) {
 								args.write[i] = argument->reduced_value;
@@ -3036,8 +3036,8 @@ void GDScriptAnalyzer::reduce_binary_op(GDScriptParser::BinaryOpNode *p_binary_o
 				} else {
 					push_error(vformat(R"(Invalid operands to operator %s, %s and %s.)",
 									   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->left_operand->reduced_value.get_full_type_name(),
+									   p_binary_op->right_operand->reduced_value.get_full_type_name()),
 							p_binary_op);
 				}
 			}
diff --git a/modules/gdscript/gdscript_parser.cpp b/modules/gdscript/gdscript_parser.cpp
index ee8d53639c63..7ece72bc0180 100644
--- a/modules/gdscript/gdscript_parser.cpp
+++ b/modules/gdscript/gdscript_parser.cpp
@@ -884,7 +884,7 @@ void GDScriptParser::parse_extends() {
 
 	if (match(GDScriptTokenizer::Token::LITERAL)) {
 		if (previous.literal.get_type() != Variant::STRING) {
-			push_error(vformat(R"(Only strings or identifiers can be used after "extends", found "%s" instead.)", Variant::get_type_name(previous.literal.get_type())));
+			push_error(vformat(R"(Only strings or identifiers can be used after "extends", found "%s" instead.)", previous.literal.get_full_type_name()));
 		}
 		current_class->extends_path = previous.literal;
 
diff --git a/modules/gdscript/gdscript_utility_functions.cpp b/modules/gdscript/gdscript_utility_functions.cpp
index 82460696964d..b9445d6c7942 100644
--- a/modules/gdscript/gdscript_utility_functions.cpp
+++ b/modules/gdscript/gdscript_utility_functions.cpp
@@ -442,7 +442,7 @@ struct GDScriptUtilityFunctionsDefinitions {
 				*r_ret = d.size();
 			} break;
 			default: {
-				*r_ret = vformat(RTR("Value of type '%s' can't provide a length."), Variant::get_type_name(p_args[0]->get_type()));
+				*r_ret = vformat(RTR("Value of type '%s' can't provide a length."), p_args[0]->get_full_type_name());
 				r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
 				r_error.argument = 0;
 				r_error.expected = Variant::NIL;
diff --git a/modules/gdscript/gdscript_vm.cpp b/modules/gdscript/gdscript_vm.cpp
index 26c5cfe23ca5..8ed7e27de53d 100644
--- a/modules/gdscript/gdscript_vm.cpp
+++ b/modules/gdscript/gdscript_vm.cpp
@@ -95,7 +95,7 @@ static String _get_var_type(const Variant *p_var) {
 						", " + _get_element_type((Variant::Type)p_dictionary->get_typed_value_builtin(), p_dictionary->get_typed_value_class_name(), p_dictionary->get_typed_value_script()) + "]";
 			}
 		} else {
-			basestr = Variant::get_type_name(p_var->get_type());
+			basestr = p_var->get_full_type_name();
 		}
 	}
 
@@ -173,7 +173,7 @@ String GDScriptFunction::_get_call_error(const String &p_where, const Variant **
 				return "Invalid type in " + p_where + ". The dictionary of argument " + itos(p_err.argument + 1) + " (" + _get_var_type(p_argptrs[p_err.argument]) + ") does not have the same element type as the expected typed dictionary argument.";
 			}
 #endif // DEBUG_ENABLED
-			return "Invalid type in " + p_where + ". Cannot convert argument " + itos(p_err.argument + 1) + " from " + Variant::get_type_name(p_argptrs[p_err.argument]->get_type()) + " to " + Variant::get_type_name(Variant::Type(p_err.expected)) + ".";
+			return "Invalid type in " + p_where + ". Cannot convert argument " + itos(p_err.argument + 1) + " from " + p_argptrs[p_err.argument]->get_full_type_name() + " to " + Variant::get_type_name(Variant::Type(p_err.expected)) + ".";
 		case Callable::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS:
 		case Callable::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS:
 			return "Invalid call to " + p_where + ". Expected " + itos(p_err.expected) + " arguments.";
@@ -794,7 +794,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 							err_text = ret;
 							err_text += " in operator '" + Variant::get_operator_name(op) + "'.";
 						} else {
-							err_text = "Invalid operands '" + Variant::get_type_name(a->get_type()) + "' and '" + Variant::get_type_name(b->get_type()) + "' in operator '" + Variant::get_operator_name(op) + "'.";
+							err_text = "Invalid operands '" + a->get_full_type_name() + "' and '" + b->get_full_type_name() + "' in operator '" + Variant::get_operator_name(op) + "'.";
 						}
 						OPCODE_BREAK;
 					}
@@ -1278,7 +1278,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 					err_text = "Internal error setting property: " + String(*index);
 					OPCODE_BREAK;
 				} else if (!valid) {
-					err_text = "Error setting property '" + String(*index) + "' with value of type " + Variant::get_type_name(src->get_type()) + ".";
+					err_text = "Error setting property '" + String(*index) + "' with value of type " + src->get_full_type_name() + ".";
 					OPCODE_BREAK;
 				}
 #endif
@@ -1398,7 +1398,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 						Variant::construct(var_type, *dst, const_cast<const Variant **>(&src), 1, ce);
 					} else {
 #ifdef DEBUG_ENABLED
-						err_text = "Trying to assign value of type '" + Variant::get_type_name(src->get_type()) +
+						err_text = "Trying to assign value of type '" + src->get_full_type_name() +
 								"' to a variable of type '" + Variant::get_type_name(var_type) + "'.";
 						OPCODE_BREAK;
 					}
@@ -1500,7 +1500,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 				GDScriptNativeClass *nc = Object::cast_to<GDScriptNativeClass>(type->operator Object *());
 				GD_ERR_BREAK(!nc);
 				if (src->get_type() != Variant::OBJECT && src->get_type() != Variant::NIL) {
-					err_text = "Trying to assign value of type '" + Variant::get_type_name(src->get_type()) +
+					err_text = "Trying to assign value of type '" + src->get_full_type_name() +
 							"' to a variable of type '" + nc->get_name() + "'.";
 					OPCODE_BREAK;
 				}
@@ -2749,7 +2749,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 					} else {
 #ifdef DEBUG_ENABLED
 						err_text = vformat(R"(Trying to return value of type "%s" from a function whose return type is "%s".)",
-								Variant::get_type_name(r->get_type()), Variant::get_type_name(ret_type));
+								r->get_full_type_name(), Variant::get_type_name(ret_type));
 #endif // DEBUG_ENABLED
 
 						// Construct a base type anyway so type constraints are met.
@@ -2779,7 +2779,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 				if (r->get_type() != Variant::ARRAY) {
 #ifdef DEBUG_ENABLED
 					err_text = vformat(R"(Trying to return value of type "%s" from a function whose return type is "Array[%s]".)",
-							Variant::get_type_name(r->get_type()), Variant::get_type_name(builtin_type));
+							r->get_full_type_name(), Variant::get_type_name(builtin_type));
 #endif
 					OPCODE_BREAK;
 				}
@@ -2857,7 +2857,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 
 				if (r->get_type() != Variant::OBJECT && r->get_type() != Variant::NIL) {
 					err_text = vformat(R"(Trying to return value of type "%s" from a function whose return type is "%s".)",
-							Variant::get_type_name(r->get_type()), nc->get_name());
+							r->get_full_type_name(), nc->get_name());
 					OPCODE_BREAK;
 				}
 
@@ -2898,7 +2898,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 				if (r->get_type() != Variant::OBJECT && r->get_type() != Variant::NIL) {
 #ifdef DEBUG_ENABLED
 					err_text = vformat(R"(Trying to return value of type "%s" from a function whose return type is "%s".)",
-							Variant::get_type_name(r->get_type()), GDScript::debug_get_script_name(Ref<Script>(base_type)));
+							r->get_full_type_name(), GDScript::debug_get_script_name(Ref<Script>(base_type)));
 #endif // DEBUG_ENABLED
 					OPCODE_BREAK;
 				}
@@ -2964,7 +2964,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 				if (!container->iter_init(*counter, valid)) {
 #ifdef DEBUG_ENABLED
 					if (!valid) {
-						err_text = "Unable to iterate on object of type '" + Variant::get_type_name(container->get_type()) + "'.";
+						err_text = "Unable to iterate on object of type '" + container->get_full_type_name() + "'.";
 						OPCODE_BREAK;
 					}
 #endif
@@ -2977,7 +2977,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 					*iterator = container->iter_get(*counter, valid);
 #ifdef DEBUG_ENABLED
 					if (!valid) {
-						err_text = "Unable to obtain iterator object of type '" + Variant::get_type_name(container->get_type()) + "'.";
+						err_text = "Unable to obtain iterator object of type '" + container->get_full_type_name() + "'.";
 						OPCODE_BREAK;
 					}
 #endif
@@ -3339,7 +3339,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 				if (!container->iter_next(*counter, valid)) {
 #ifdef DEBUG_ENABLED
 					if (!valid) {
-						err_text = "Unable to iterate on object of type '" + Variant::get_type_name(container->get_type()) + "' (type changed since first iteration?).";
+						err_text = "Unable to iterate on object of type '" + container->get_full_type_name() + "' (type changed since first iteration?).";
 						OPCODE_BREAK;
 					}
 #endif
@@ -3352,7 +3352,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 					*iterator = container->iter_get(*counter, valid);
 #ifdef DEBUG_ENABLED
 					if (!valid) {
-						err_text = "Unable to obtain iterator object of type '" + Variant::get_type_name(container->get_type()) + "' (but was obtained on first iteration?).";
+						err_text = "Unable to obtain iterator object of type '" + container->get_full_type_name() + "' (but was obtained on first iteration?).";
 						OPCODE_BREAK;
 					}
 #endif
diff --git a/modules/gdscript/tests/scripts/runtime/errors/global_base.notest.gd b/modules/gdscript/tests/scripts/runtime/errors/global_base.notest.gd
new file mode 100644
index 000000000000..b05e5a84ce5f
--- /dev/null
+++ b/modules/gdscript/tests/scripts/runtime/errors/global_base.notest.gd
@@ -0,0 +1 @@
+class_name GlobalBase
diff --git a/modules/gdscript/tests/scripts/runtime/errors/global_class_1.notest.gd b/modules/gdscript/tests/scripts/runtime/errors/global_class_1.notest.gd
new file mode 100644
index 000000000000..acaf3be514fb
--- /dev/null
+++ b/modules/gdscript/tests/scripts/runtime/errors/global_class_1.notest.gd
@@ -0,0 +1 @@
+class_name GlobalClass1 extends GlobalBase
diff --git a/modules/gdscript/tests/scripts/runtime/errors/global_class_2.notest.gd b/modules/gdscript/tests/scripts/runtime/errors/global_class_2.notest.gd
new file mode 100644
index 000000000000..5c40e1905a0b
--- /dev/null
+++ b/modules/gdscript/tests/scripts/runtime/errors/global_class_2.notest.gd
@@ -0,0 +1 @@
+class_name GlobalClass2 extends GlobalBase
diff --git a/modules/gdscript/tests/scripts/runtime/errors/typed_array_assign_wrong_to_typed.gd b/modules/gdscript/tests/scripts/runtime/errors/typed_array_assign_wrong_to_typed.gd
index 83ec6573dfed..68ba14036b2d 100644
--- a/modules/gdscript/tests/scripts/runtime/errors/typed_array_assign_wrong_to_typed.gd
+++ b/modules/gdscript/tests/scripts/runtime/errors/typed_array_assign_wrong_to_typed.gd
@@ -1,7 +1,3 @@
-class Foo: pass
-class Bar extends Foo: pass
-class Baz extends Foo: pass
-
 func test():
-	var typed: Array[Bar] = [Baz.new() as Foo]
+	var typed: Array[GlobalClass1] = [GlobalClass2.new() as GlobalBase]
 	print('not ok')
diff --git a/modules/gdscript/tests/scripts/runtime/errors/typed_array_assign_wrong_to_typed.out b/modules/gdscript/tests/scripts/runtime/errors/typed_array_assign_wrong_to_typed.out
index 9b389571019d..4594bec593a1 100644
--- a/modules/gdscript/tests/scripts/runtime/errors/typed_array_assign_wrong_to_typed.out
+++ b/modules/gdscript/tests/scripts/runtime/errors/typed_array_assign_wrong_to_typed.out
@@ -1,5 +1,5 @@
 GDTEST_RUNTIME_ERROR
 >> ERROR
 >> Method/function failed.
->> Unable to convert array index 0 from "Object" to "Object".
+>> Unable to convert array index 0 from "RefCounted (GlobalClass2)" to "RefCounted (GlobalClass1)".
 not ok
diff --git a/modules/gdscript/tests/test_gdscript.cpp b/modules/gdscript/tests/test_gdscript.cpp
index fbc72a050899..1059fa283c20 100644
--- a/modules/gdscript/tests/test_gdscript.cpp
+++ b/modules/gdscript/tests/test_gdscript.cpp
@@ -93,7 +93,7 @@ static void test_tokenizer(const String &p_code, const Vector<String> &p_lines)
 
 		if (current.type == GDScriptTokenizer::Token::ERROR || current.type == GDScriptTokenizer::Token::LITERAL || current.type == GDScriptTokenizer::Token::IDENTIFIER || current.type == GDScriptTokenizer::Token::ANNOTATION) {
 			token += "(";
-			token += Variant::get_type_name(current.literal.get_type());
+			token += current.literal.get_full_type_name();
 			token += ") ";
 			token += current.literal;
 		}
diff --git a/modules/gltf/editor/editor_import_blend_runner.cpp b/modules/gltf/editor/editor_import_blend_runner.cpp
index 22c8adfe888d..03c7c9c272a5 100644
--- a/modules/gltf/editor/editor_import_blend_runner.cpp
+++ b/modules/gltf/editor/editor_import_blend_runner.cpp
@@ -116,7 +116,7 @@ String dict_to_python(const Dictionary &p_dict) {
 				break;
 			}
 			default: {
-				ERR_FAIL_V_MSG("", vformat("Unhandled Variant type %s for python dictionary", Variant::get_type_name(raw_value.get_type())));
+				ERR_FAIL_V_MSG("", vformat("Unhandled Variant type %s for python dictionary", raw_value.get_full_type_name()));
 			}
 		}
 
@@ -149,7 +149,7 @@ String dict_to_xmlrpc(const Dictionary &p_dict) {
 				break;
 			}
 			default: {
-				ERR_FAIL_V_MSG("", vformat("Unhandled Variant type %s for XMLRPC", Variant::get_type_name(raw_value.get_type())));
+				ERR_FAIL_V_MSG("", vformat("Unhandled Variant type %s for XMLRPC", raw_value.get_full_type_name()));
 			}
 		}
 
diff --git a/modules/mono/editor/bindings_generator.cpp b/modules/mono/editor/bindings_generator.cpp
index db90ac5a6e2c..d31520d2d45a 100644
--- a/modules/mono/editor/bindings_generator.cpp
+++ b/modules/mono/editor/bindings_generator.cpp
@@ -3741,22 +3741,22 @@ bool BindingsGenerator::_arg_default_value_is_assignable_to_type(const Variant &
 		case Variant::PACKED_COLOR_ARRAY:
 		case Variant::CALLABLE:
 		case Variant::SIGNAL:
-			return p_arg_type.name == Variant::get_type_name(p_val.get_type());
+			return p_arg_type.name == p_val.get_full_type_name();
 		case Variant::ARRAY:
-			return p_arg_type.name == Variant::get_type_name(p_val.get_type()) || p_arg_type.cname == name_cache.type_Array_generic;
+			return p_arg_type.name == p_val.get_full_type_name() || p_arg_type.cname == name_cache.type_Array_generic;
 		case Variant::DICTIONARY:
-			return p_arg_type.name == Variant::get_type_name(p_val.get_type()) || p_arg_type.cname == name_cache.type_Dictionary_generic;
+			return p_arg_type.name == p_val.get_full_type_name() || p_arg_type.cname == name_cache.type_Dictionary_generic;
 		case Variant::OBJECT:
 			return p_arg_type.is_object_type;
 		case Variant::VECTOR2I:
 			return p_arg_type.name == name_cache.type_Vector2 ||
-					p_arg_type.name == Variant::get_type_name(p_val.get_type());
+					p_arg_type.name == p_val.get_full_type_name();
 		case Variant::RECT2I:
 			return p_arg_type.name == name_cache.type_Rect2 ||
-					p_arg_type.name == Variant::get_type_name(p_val.get_type());
+					p_arg_type.name == p_val.get_full_type_name();
 		case Variant::VECTOR3I:
 			return p_arg_type.name == name_cache.type_Vector3 ||
-					p_arg_type.name == Variant::get_type_name(p_val.get_type());
+					p_arg_type.name == p_val.get_full_type_name();
 		default:
 			CRASH_NOW_MSG("Unexpected Variant type: " + itos(p_val.get_type()));
 			break;
diff --git a/modules/mono/glue/runtime_interop.cpp b/modules/mono/glue/runtime_interop.cpp
index 73c10eba830a..080998937cb8 100644
--- a/modules/mono/glue/runtime_interop.cpp
+++ b/modules/mono/glue/runtime_interop.cpp
@@ -1416,7 +1416,7 @@ void godotsharp_convert(const godot_variant *p_what, int32_t p_type, godot_varia
 	if (ce.error != Callable::CallError::CALL_OK) {
 		memnew_placement(r_ret, Variant);
 		ERR_FAIL_MSG("Unable to convert parameter from '" +
-				Variant::get_type_name(reinterpret_cast<const Variant *>(p_what)->get_type()) +
+				reinterpret_cast<const Variant *>(p_what)->get_full_type_name() +
 				"' to '" + Variant::get_type_name(Variant::Type(p_type)) + "'.");
 	}
 	memnew_placement(r_ret, Variant(ret));
diff --git a/scene/animation/tween.cpp b/scene/animation/tween.cpp
index e1fd8abedebd..492c2a1b64e9 100644
--- a/scene/animation/tween.cpp
+++ b/scene/animation/tween.cpp
@@ -78,7 +78,7 @@ bool Tween::_validate_type_match(const Variant &p_from, Variant &r_to) {
 		} else if (p_from.get_type() == Variant::INT && r_to.get_type() == Variant::FLOAT) {
 			r_to = int(r_to);
 		} else {
-			ERR_FAIL_V_MSG(false, "Type mismatch between initial and final value: " + Variant::get_type_name(p_from.get_type()) + " and " + Variant::get_type_name(r_to.get_type()));
+			ERR_FAIL_V_MSG(false, "Type mismatch between initial and final value: " + p_from.get_full_type_name() + " and " + r_to.get_full_type_name());
 		}
 	}
 	return true;
diff --git a/scene/resources/theme.cpp b/scene/resources/theme.cpp
index 1ac90b89803f..203312b3f78a 100644
--- a/scene/resources/theme.cpp
+++ b/scene/resources/theme.cpp
@@ -856,37 +856,37 @@ void Theme::get_constant_type_list(List<StringName> *p_list) const {
 void Theme::set_theme_item(DataType p_data_type, const StringName &p_name, const StringName &p_theme_type, const Variant &p_value) {
 	switch (p_data_type) {
 		case DATA_TYPE_COLOR: {
-			ERR_FAIL_COND_MSG(p_value.get_type() != Variant::COLOR, "Theme item's data type (Color) does not match Variant's type (" + Variant::get_type_name(p_value.get_type()) + ").");
+			ERR_FAIL_COND_MSG(p_value.get_type() != Variant::COLOR, "Theme item's data type (Color) does not match Variant's type (" + p_value.get_full_type_name() + ").");
 
 			Color color_value = p_value;
 			set_color(p_name, p_theme_type, color_value);
 		} break;
 		case DATA_TYPE_CONSTANT: {
-			ERR_FAIL_COND_MSG(p_value.get_type() != Variant::INT, "Theme item's data type (int) does not match Variant's type (" + Variant::get_type_name(p_value.get_type()) + ").");
+			ERR_FAIL_COND_MSG(p_value.get_type() != Variant::INT, "Theme item's data type (int) does not match Variant's type (" + p_value.get_full_type_name() + ").");
 
 			int constant_value = p_value;
 			set_constant(p_name, p_theme_type, constant_value);
 		} break;
 		case DATA_TYPE_FONT: {
-			ERR_FAIL_COND_MSG(p_value.get_type() != Variant::OBJECT, "Theme item's data type (Object) does not match Variant's type (" + Variant::get_type_name(p_value.get_type()) + ").");
+			ERR_FAIL_COND_MSG(p_value.get_type() != Variant::OBJECT, "Theme item's data type (Object) does not match Variant's type (" + p_value.get_full_type_name() + ").");
 
 			Ref<Font> font_value = Object::cast_to<Font>(p_value.get_validated_object());
 			set_font(p_name, p_theme_type, font_value);
 		} break;
 		case DATA_TYPE_FONT_SIZE: {
-			ERR_FAIL_COND_MSG(p_value.get_type() != Variant::INT, "Theme item's data type (int) does not match Variant's type (" + Variant::get_type_name(p_value.get_type()) + ").");
+			ERR_FAIL_COND_MSG(p_value.get_type() != Variant::INT, "Theme item's data type (int) does not match Variant's type (" + p_value.get_full_type_name() + ").");
 
 			int font_size_value = p_value;
 			set_font_size(p_name, p_theme_type, font_size_value);
 		} break;
 		case DATA_TYPE_ICON: {
-			ERR_FAIL_COND_MSG(p_value.get_type() != Variant::OBJECT, "Theme item's data type (Object) does not match Variant's type (" + Variant::get_type_name(p_value.get_type()) + ").");
+			ERR_FAIL_COND_MSG(p_value.get_type() != Variant::OBJECT, "Theme item's data type (Object) does not match Variant's type (" + p_value.get_full_type_name() + ").");
 
 			Ref<Texture2D> icon_value = Object::cast_to<Texture2D>(p_value.get_validated_object());
 			set_icon(p_name, p_theme_type, icon_value);
 		} break;
 		case DATA_TYPE_STYLEBOX: {
-			ERR_FAIL_COND_MSG(p_value.get_type() != Variant::OBJECT, "Theme item's data type (Object) does not match Variant's type (" + Variant::get_type_name(p_value.get_type()) + ").");
+			ERR_FAIL_COND_MSG(p_value.get_type() != Variant::OBJECT, "Theme item's data type (Object) does not match Variant's type (" + p_value.get_full_type_name() + ").");
 
 			Ref<StyleBox> stylebox_value = Object::cast_to<StyleBox>(p_value.get_validated_object());
 			set_stylebox(p_name, p_theme_type, stylebox_value);