From bf2ba7b7b6c04a3e2d8a699ab43459238def0b7c Mon Sep 17 00:00:00 2001
From: nlupugla <lupu.gladstein@gmail.com>
Date: Tue, 17 Sep 2024 21:48:24 -0400
Subject: [PATCH] Removed my added compatibility methods.

---
 core/core_bind.compat.inc              | 62 --------------------------
 core/core_bind.h                       |  8 ----
 core/object/object.compat.inc          |  0
 core/object/object.h                   | 10 -----
 core/variant/container_type_validate.h |  5 ++-
 core/variant/dictionary.cpp            | 42 ++++++++---------
 core/variant/variant_setget.cpp        |  8 ++--
 7 files changed, 28 insertions(+), 107 deletions(-)
 delete mode 100644 core/object/object.compat.inc

diff --git a/core/core_bind.compat.inc b/core/core_bind.compat.inc
index 42c05670abf3..3e8ac3c5de6a 100644
--- a/core/core_bind.compat.inc
+++ b/core/core_bind.compat.inc
@@ -29,7 +29,6 @@
 /**************************************************************************/
 
 #ifndef DISABLE_DEPRECATED
-#include "core_bind.h"
 
 namespace core_bind {
 
@@ -53,67 +52,6 @@ void OS::_bind_compatibility_methods() {
 	ClassDB::bind_compatibility_method(D_METHOD("execute_with_pipe", "path", "arguments"), &OS::_execute_with_pipe_bind_compat_94434);
 }
 
-// ClassDB
-
-namespace special {
-
-Dictionary ClassDB::class_get_signal_compat_82198(const StringName &p_class, const StringName &p_signal) const {
-	MethodInfo signal;
-	if (::ClassDB::get_signal(p_class, p_signal, &signal)) {
-		return signal.operator Dictionary();
-	} else {
-		return Dictionary();
-	}
-}
-
-TypedArray<Dictionary> ClassDB::class_get_signal_list_compat_82198(const StringName &p_class, bool p_no_inheritance) const {
-	List<MethodInfo> signals;
-	::ClassDB::get_signal_list(p_class, &signals, p_no_inheritance);
-	TypedArray<Dictionary> ret;
-
-	for (const MethodInfo &E : signals) {
-		ret.push_back(E.operator Dictionary());
-	}
-
-	return ret;
-}
-
-TypedArray<Dictionary> ClassDB::class_get_property_list_compat_82198(const StringName &p_class, bool p_no_inheritance) const {
-	List<PropertyInfo> plist;
-	::ClassDB::get_property_list(p_class, &plist, p_no_inheritance);
-	TypedArray<Dictionary> ret;
-	for (const PropertyInfo &E : plist) {
-		ret.push_back(E.operator Dictionary());
-	}
-
-	return ret;
-}
-
-TypedArray<Dictionary> ClassDB::class_get_method_list_compat_82198(const StringName &p_class, bool p_no_inheritance) const {
-	List<MethodInfo> methods;
-	::ClassDB::get_method_list(p_class, &methods, p_no_inheritance);
-	TypedArray<Dictionary> ret;
-
-	for (const MethodInfo &E : methods) {
-#ifdef DEBUG_METHODS_ENABLED
-		ret.push_back(E.operator Dictionary());
-#else
-		Dictionary dict;
-		dict["name"] = E.name;
-		ret.push_back(dict);
-#endif
-	}
-
-	return ret;
-}
-
-void ClassDB::_bind_compatibility_methods() {
-	::ClassDB::bind_compatibility_method(D_METHOD("class_get_signal", "class", "signal"), &ClassDB::class_get_signal_compat_82198);
-	::ClassDB::bind_compatibility_method(D_METHOD("class_get_signal_list", "class", "no_inheritance"), &ClassDB::class_get_signal_list_compat_82198, DEFVAL(false));
-	::ClassDB::bind_compatibility_method(D_METHOD("class_get_property_list", "class", "no_inheritance"), &ClassDB::class_get_property_list_compat_82198, DEFVAL(false));
-	::ClassDB::bind_compatibility_method(D_METHOD("class_get_method_list", "class", "no_inheritance"), &ClassDB::class_get_method_list_compat_82198, DEFVAL(false));
-}
-} // namespace special
 } // namespace core_bind
 
 #endif // DISABLE_DEPRECATED
diff --git a/core/core_bind.h b/core/core_bind.h
index 038e33b13a85..62d2da26569b 100644
--- a/core/core_bind.h
+++ b/core/core_bind.h
@@ -445,7 +445,6 @@ class ClassDB : public Object {
 
 protected:
 	static void _bind_methods();
-	static void _bind_compatibility_methods();
 
 public:
 	PackedStringArray get_class_list() const;
@@ -496,13 +495,6 @@ class ClassDB : public Object {
 	TypedArray<Dictionary> class_get_struct_list(const StringName &p_class, bool p_no_inheritance = false) const;
 	TypedArray<Dictionary> class_get_struct_members(const StringName &p_class, const StringName &p_struct) const;
 
-#ifndef DISABLE_DEPRECATED
-	Dictionary class_get_signal_compat_82198(const StringName &p_class, const StringName &p_signal) const;
-	TypedArray<Dictionary> class_get_signal_list_compat_82198(const StringName &p_class, bool p_no_inheritance = false) const;
-	TypedArray<Dictionary> class_get_property_list_compat_82198(const StringName &p_class, bool p_no_inheritance = false) const;
-	TypedArray<Dictionary> class_get_method_list_compat_82198(const StringName &p_class, bool p_no_inheritance = false) const;
-#endif
-
 #ifdef TOOLS_ENABLED
 	virtual void get_argument_options(const StringName &p_function, int p_idx, List<String> *r_options) const override;
 #endif
diff --git a/core/object/object.compat.inc b/core/object/object.compat.inc
deleted file mode 100644
index e69de29bb2d1..000000000000
diff --git a/core/object/object.h b/core/object/object.h
index 99954289893e..d5985ef8be24 100644
--- a/core/object/object.h
+++ b/core/object/object.h
@@ -417,12 +417,6 @@ class Object {
 	TypedArray<Struct<MethodInfo>> _get_signal_list_as_structs() const;
 	TypedArray<Struct<Connection>> _get_signal_connection_list_as_structs(const StringName &p_signal) const;
 	TypedArray<Struct<Connection>> _get_incoming_connections_as_structs() const;
-#ifndef DISABLE_DEPRECATED
-	void _add_user_signal_compat_82198(const String &p_name, const Array &p_args = Array());
-	TypedArray<Dictionary> _get_signal_list_compat_82198() const;
-	TypedArray<Dictionary> _get_signal_connection_list_compat_82198(const StringName &p_signal) const;
-	TypedArray<Dictionary> _get_incoming_connections_compat_82198() const;
-#endif
 	void _set_bind(const StringName &p_set, const Variant &p_value);
 	Variant _get_bind(const StringName &p_name) const;
 	void _set_indexed_bind(const NodePath &p_name, const Variant &p_value);
@@ -530,10 +524,6 @@ class Object {
 	TypedArray<Struct<PropertyInfo>> _get_property_list_as_structs_bind() const;
 	TypedArray<Dictionary> _get_method_list_bind() const;
 	TypedArray<Struct<MethodInfo>> _get_method_list_as_structs_bind() const;
-#ifndef DISABLE_DEPRECATED
-	TypedArray<Dictionary> _get_property_list_bind_compat_82198() const;
-	TypedArray<Dictionary> _get_method_list_bind_compat_82198() const;
-#endif
 
 	void _clear_internal_resource_paths(const Variant &p_var);
 
diff --git a/core/variant/container_type_validate.h b/core/variant/container_type_validate.h
index e11a169d922c..708745793a23 100644
--- a/core/variant/container_type_validate.h
+++ b/core/variant/container_type_validate.h
@@ -51,10 +51,11 @@ struct ContainerTypeValidate {
 	Ref<Script> script;
 
 	bool is_array_of_structs = false;
-	const StructInfo *struct_info; // TODO: if is_array_of_structs == true, then require struct_info != nullptr, but not sure the best way to enforce this.
+	const StructInfo *struct_info = nullptr; // TODO: if is_array_of_structs == true, then require struct_info != nullptr, but not sure the best way to enforce this.
 	const char *where = "container";
 
-	ContainerTypeValidate(const Variant::Type p_type = Variant::NIL, const StringName &p_class_name = StringName(), const Ref<Script> &p_script = Ref<Script>(), const char *p_where = "container") {
+	ContainerTypeValidate(){};
+	ContainerTypeValidate(const Variant::Type p_type, const StringName &p_class_name, const Ref<Script> &p_script, const char *p_where = "container") {
 		type = p_type;
 		class_name = p_class_name;
 		script = p_script;
diff --git a/core/variant/dictionary.cpp b/core/variant/dictionary.cpp
index bfd8ecd14c49..cffef3c97aed 100644
--- a/core/variant/dictionary.cpp
+++ b/core/variant/dictionary.cpp
@@ -86,31 +86,31 @@ Variant Dictionary::get_value_at_index(int p_index) const {
 // WARNING: This operator does not validate the value type. For scripting/extensions this is
 // done in `variant_setget.cpp`. Consider using `set()` if the data might be invalid.
 Variant &Dictionary::operator[](const Variant &p_key) {
-	Variant key = p_key;
-	if (unlikely(!_p->typed_key.validate(key, "use `operator[]`"))) {
+	ValidatedVariant validated_key = _p->typed_key.validate(p_key, "use `operator[]`");
+	if (unlikely(!validated_key.valid)) {
 		if (unlikely(!_p->typed_fallback)) {
 			_p->typed_fallback = memnew(Variant);
 		}
 		VariantInternal::initialize(_p->typed_fallback, _p->typed_value.type);
 		return *_p->typed_fallback;
 	} else if (unlikely(_p->read_only)) {
-		if (likely(_p->variant_map.has(key))) {
-			*_p->read_only = _p->variant_map[key];
+		if (likely(_p->variant_map.has(validated_key.value))) {
+			*_p->read_only = _p->variant_map[validated_key.value];
 		} else {
 			VariantInternal::initialize(_p->read_only, _p->typed_value.type);
 		}
 		return *_p->read_only;
 	} else {
-		if (unlikely(!_p->variant_map.has(key))) {
-			VariantInternal::initialize(&_p->variant_map[key], _p->typed_value.type);
+		if (unlikely(!_p->variant_map.has(validated_key.value))) {
+			VariantInternal::initialize(&_p->variant_map[validated_key.value], _p->typed_value.type);
 		}
-		return _p->variant_map[key];
+		return _p->variant_map[validated_key.value];
 	}
 }
 
 const Variant &Dictionary::operator[](const Variant &p_key) const {
-	Variant key = p_key;
-	if (unlikely(!_p->typed_key.validate(key, "use `operator[]`"))) {
+	ValidatedVariant validated_key = _p->typed_key.validate(p_key, "use `operator[]`");
+	if (unlikely(!validated_key.valid)) {
 		if (unlikely(!_p->typed_fallback)) {
 			_p->typed_fallback = memnew(Variant);
 		}
@@ -118,16 +118,16 @@ const Variant &Dictionary::operator[](const Variant &p_key) const {
 		return *_p->typed_fallback;
 	} else {
 		// Will not insert key, so no initialization is necessary.
-		return _p->variant_map[key];
+		return _p->variant_map[validated_key.value];
 	}
 }
 
 const Variant *Dictionary::getptr(const Variant &p_key) const {
-	Variant key = p_key;
-	if (unlikely(!_p->typed_key.validate(key, "getptr"))) {
+	ValidatedVariant validated_key = _p->typed_key.validate(p_key, "getptr");
+	if (unlikely(!validated_key.valid)) {
 		return nullptr;
 	}
-	HashMap<Variant, Variant, VariantHasher, StringLikeVariantComparator>::ConstIterator E(_p->variant_map.find(key));
+	HashMap<Variant, Variant, VariantHasher, StringLikeVariantComparator>::ConstIterator E(_p->variant_map.find(validated_key.value));
 	if (!E) {
 		return nullptr;
 	}
@@ -136,11 +136,11 @@ const Variant *Dictionary::getptr(const Variant &p_key) const {
 
 // WARNING: This method does not validate the value type.
 Variant *Dictionary::getptr(const Variant &p_key) {
-	Variant key = p_key;
-	if (unlikely(!_p->typed_key.validate(key, "getptr"))) {
+	ValidatedVariant validated_key = _p->typed_key.validate(p_key, "getptr");
+	if (unlikely(!validated_key.valid)) {
 		return nullptr;
 	}
-	HashMap<Variant, Variant, VariantHasher, StringLikeVariantComparator>::Iterator E(_p->variant_map.find(key));
+	HashMap<Variant, Variant, VariantHasher, StringLikeVariantComparator>::Iterator E(_p->variant_map.find(validated_key.value));
 	if (!E) {
 		return nullptr;
 	}
@@ -191,11 +191,11 @@ Variant Dictionary::get_or_add(const Variant &p_key, const Variant &p_default) {
 
 bool Dictionary::set(const Variant &p_key, const Variant &p_value) {
 	ERR_FAIL_COND_V_MSG(_p->read_only, false, "Dictionary is in read-only state.");
-	Variant key = p_key;
-	ERR_FAIL_COND_V(!_p->typed_key.validate(key, "set"), false);
-	Variant value = p_value;
-	ERR_FAIL_COND_V(!_p->typed_value.validate(value, "set"), false);
-	_p->variant_map[key] = value;
+	ValidatedVariant validated_key = _p->typed_key.validate(p_key, "set");
+	ERR_FAIL_COND_V(!validated_key.valid, false);
+	ValidatedVariant validated_value = _p->typed_value.validate(p_value, "set");
+	ERR_FAIL_COND_V(!validated_value.valid, false);
+	_p->variant_map[validated_key.value] = validated_value.value;
 	return true;
 }
 
diff --git a/core/variant/variant_setget.cpp b/core/variant/variant_setget.cpp
index 400fa0b4cb4a..d53c7e214d2f 100644
--- a/core/variant/variant_setget.cpp
+++ b/core/variant/variant_setget.cpp
@@ -447,9 +447,9 @@ Variant Variant::get_named(const StringName &p_member, bool &r_valid) const {
 			}                                                                                                                        \
 			m_assign_type num;                                                                                                       \
 			if (value->get_type() == Variant::INT) {                                                                                 \
-				num = (m_assign_type)*VariantGetInternalPtr<int64_t>::get_ptr(value);                                                \
+				num = (m_assign_type) * VariantGetInternalPtr<int64_t>::get_ptr(value);                                              \
 			} else if (value->get_type() == Variant::FLOAT) {                                                                        \
-				num = (m_assign_type)*VariantGetInternalPtr<double>::get_ptr(value);                                                 \
+				num = (m_assign_type) * VariantGetInternalPtr<double>::get_ptr(value);                                               \
 			} else {                                                                                                                 \
 				*oob = false;                                                                                                        \
 				*valid = false;                                                                                                      \
@@ -509,9 +509,9 @@ Variant Variant::get_named(const StringName &p_member, bool &r_valid) const {
 			}                                                                                                                  \
 			m_assign_type num;                                                                                                 \
 			if (value->get_type() == Variant::INT) {                                                                           \
-				num = (m_assign_type)*VariantGetInternalPtr<int64_t>::get_ptr(value);                                          \
+				num = (m_assign_type) * VariantGetInternalPtr<int64_t>::get_ptr(value);                                        \
 			} else if (value->get_type() == Variant::FLOAT) {                                                                  \
-				num = (m_assign_type)*VariantGetInternalPtr<double>::get_ptr(value);                                           \
+				num = (m_assign_type) * VariantGetInternalPtr<double>::get_ptr(value);                                         \
 			} else {                                                                                                           \
 				*oob = false;                                                                                                  \
 				*valid = false;                                                                                                \