Fix C# bindings after recent breaking changes

Implementation for new Variant types Callable, Signal, StringName.
Added support for PackedInt64Array and PackedFloat64Array.

Add generation of signal members as events, as well as support for
user created signals as events.
NOTE: As of now, raising such events will not emit the signal. As such,
one must use `EmitSignal` instead of raising the event directly.

Removed old ThreadLocal fallback class. It's safe to use thread_local now since
it's supported on all minimum versions of compilers we support.

1 files changed, 142 insertions, 63 deletions

diff --git a/modules/mono/signal_awaiter_utils.cpp b/modules/mono/signal_awaiter_utils.cpp
index 718bc2bb93..28719f7bc6 100644
--- a/modules/mono/signal_awaiter_utils.cpp
+++ b/modules/mono/signal_awaiter_utils.cpp
@@ -36,103 +36,182 @@
 #include "mono_gd/gd_mono_marshal.h"
 #include "mono_gd/gd_mono_utils.h"
 
-namespace SignalAwaiterUtils {
-
-Error connect_signal_awaiter(Object *p_source, const String &p_signal, Object *p_target, MonoObject *p_awaiter) {
-
+Error gd_mono_connect_signal_awaiter(Object *p_source, const StringName &p_signal, Object *p_target, MonoObject *p_awaiter) {
 	ERR_FAIL_NULL_V(p_source, ERR_INVALID_DATA);
 	ERR_FAIL_NULL_V(p_target, ERR_INVALID_DATA);
 
-	Ref<SignalAwaiterHandle> sa_con = memnew(SignalAwaiterHandle(p_awaiter));
-#ifdef DEBUG_ENABLED
-	sa_con->set_connection_target(p_target);
-#endif
+	// TODO: Use pooling for ManagedCallable instances.
+	SignalAwaiterCallable *awaiter_callable = memnew(SignalAwaiterCallable(p_target, p_awaiter, p_signal));
+	Callable callable = Callable(awaiter_callable);
 
-	Vector<Variant> binds;
-	binds.push_back(sa_con);
+	return p_source->connect(p_signal, callable, Vector<Variant>(), Object::CONNECT_ONESHOT);
+}
 
-	Error err = p_source->connect_compat(p_signal, sa_con.ptr(),
-			CSharpLanguage::get_singleton()->get_string_names()._signal_callback,
-			binds, Object::CONNECT_ONESHOT);
+bool SignalAwaiterCallable::compare_equal(const CallableCustom *p_a, const CallableCustom *p_b) {
+	const SignalAwaiterCallable *a = static_cast<const SignalAwaiterCallable *>(p_a);
+	const SignalAwaiterCallable *b = static_cast<const SignalAwaiterCallable *>(p_b);
 
-	if (err != OK) {
-		// Set it as completed to prevent it from calling the failure callback when released.
-		// The awaiter will be aware of the failure by checking the returned error.
-		sa_con->set_completed(true);
-	}
+	if (a->target_id != b->target_id)
+		return false;
+
+	if (a->signal != b->signal)
+		return false;
 
-	return err;
+	return true;
 }
-} // namespace SignalAwaiterUtils
 
-Variant SignalAwaiterHandle::_signal_callback(const Variant **p_args, int p_argcount, Callable::CallError &r_error) {
+bool SignalAwaiterCallable::compare_less(const CallableCustom *p_a, const CallableCustom *p_b) {
+	if (compare_equal(p_a, p_b))
+		return false;
+	return p_a < p_b;
+}
 
-#ifdef DEBUG_ENABLED
-	ERR_FAIL_COND_V_MSG(conn_target_id.is_valid() && !ObjectDB::get_instance(conn_target_id), Variant(),
-			"Resumed after await, but class instance is gone.");
-#endif
+uint32_t SignalAwaiterCallable::hash() const {
+	uint32_t hash = signal.hash();
+	return hash_djb2_one_64(target_id, hash);
+}
+
+String SignalAwaiterCallable::get_as_text() const {
+	Object *base = ObjectDB::get_instance(target_id);
+	if (base) {
+		String class_name = base->get_class();
+		Ref<Script> script = base->get_script();
+		if (script.is_valid() && script->get_path().is_resource_file()) {
 
-	if (p_argcount < 1) {
-		r_error.error = Callable::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
-		r_error.argument = 1;
-		return Variant();
+			class_name += "(" + script->get_path().get_file() + ")";
+		}
+		return class_name + "::SignalAwaiterMiddleman::" + String(signal);
+	} else {
+		return "null::SignalAwaiterMiddleman::" + String(signal);
 	}
+}
 
-	Ref<SignalAwaiterHandle> self = *p_args[p_argcount - 1];
+CallableCustom::CompareEqualFunc SignalAwaiterCallable::get_compare_equal_func() const {
+	return compare_equal_func_ptr;
+}
 
-	if (self.is_null()) {
-		r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
-		r_error.argument = p_argcount - 1;
-		r_error.expected = Variant::OBJECT;
-		return Variant();
-	}
+CallableCustom::CompareLessFunc SignalAwaiterCallable::get_compare_less_func() const {
+	return compare_less_func_ptr;
+}
 
-	set_completed(true);
+ObjectID SignalAwaiterCallable::get_object() const {
+	return target_id;
+}
 
-	int signal_argc = p_argcount - 1;
-	MonoArray *signal_args = mono_array_new(mono_domain_get(), CACHED_CLASS_RAW(MonoObject), signal_argc);
+void SignalAwaiterCallable::call(const Variant **p_arguments, int p_argcount, Variant &r_return_value, Callable::CallError &r_call_error) const {
+	r_call_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD; // Can't find anything better
+	r_return_value = Variant();
 
-	for (int i = 0; i < signal_argc; i++) {
-		MonoObject *boxed = GDMonoMarshal::variant_to_mono_object(*p_args[i]);
+#ifdef DEBUG_ENABLED
+	ERR_FAIL_COND_MSG(target_id.is_valid() && !ObjectDB::get_instance(target_id),
+			"Resumed after await, but class instance is gone.");
+#endif
+
+	MonoArray *signal_args = mono_array_new(mono_domain_get(), CACHED_CLASS_RAW(MonoObject), p_argcount);
+
+	for (int i = 0; i < p_argcount; i++) {
+		MonoObject *boxed = GDMonoMarshal::variant_to_mono_object(*p_arguments[i]);
 		mono_array_setref(signal_args, i, boxed);
 	}
 
 	MonoException *exc = NULL;
-	GD_MONO_BEGIN_RUNTIME_INVOKE;
-	CACHED_METHOD_THUNK(SignalAwaiter, SignalCallback).invoke(get_target(), signal_args, &exc);
-	GD_MONO_END_RUNTIME_INVOKE;
+	CACHED_METHOD_THUNK(SignalAwaiter, SignalCallback).invoke(awaiter_handle->get_target(), signal_args, &exc);
 
 	if (exc) {
 		GDMonoUtils::set_pending_exception(exc);
-		ERR_FAIL_V(Variant());
+		ERR_FAIL();
+	} else {
+		r_call_error.error = Callable::CallError::CALL_OK;
+	}
+}
+
+SignalAwaiterCallable::SignalAwaiterCallable(Object *p_target, MonoObject *p_awaiter, const StringName &p_signal) :
+		target_id(p_target->get_instance_id()),
+		awaiter_handle(MonoGCHandle::create_strong(p_awaiter)),
+		signal(p_signal) {
+}
+
+bool EventSignalCallable::compare_equal(const CallableCustom *p_a, const CallableCustom *p_b) {
+	const EventSignalCallable *a = static_cast<const EventSignalCallable *>(p_a);
+	const EventSignalCallable *b = static_cast<const EventSignalCallable *>(p_b);
+
+	if (a->owner != b->owner)
+		return false;
+
+	if (a->event_signal != b->event_signal)
+		return false;
+
+	return true;
+}
+
+bool EventSignalCallable::compare_less(const CallableCustom *p_a, const CallableCustom *p_b) {
+	if (compare_equal(p_a, p_b))
+		return false;
+	return p_a < p_b;
+}
+
+uint32_t EventSignalCallable::hash() const {
+	uint32_t hash = event_signal->field->get_name().hash();
+	return hash_djb2_one_64(owner->get_instance_id(), hash);
+}
+
+String EventSignalCallable::get_as_text() const {
+	String class_name = owner->get_class();
+	Ref<Script> script = owner->get_script();
+	if (script.is_valid() && script->get_path().is_resource_file()) {
+
+		class_name += "(" + script->get_path().get_file() + ")";
 	}
+	StringName signal = event_signal->field->get_name();
+	return class_name + "::EventSignalMiddleman::" + String(signal);
+}
 
-	return Variant();
+CallableCustom::CompareEqualFunc EventSignalCallable::get_compare_equal_func() const {
+	return compare_equal_func_ptr;
 }
 
-void SignalAwaiterHandle::_bind_methods() {
+CallableCustom::CompareLessFunc EventSignalCallable::get_compare_less_func() const {
+	return compare_less_func_ptr;
+}
 
-	ClassDB::bind_vararg_method(METHOD_FLAGS_DEFAULT, "_signal_callback", &SignalAwaiterHandle::_signal_callback, MethodInfo("_signal_callback"));
+ObjectID EventSignalCallable::get_object() const {
+	return owner->get_instance_id();
 }
 
-SignalAwaiterHandle::SignalAwaiterHandle(MonoObject *p_managed) :
-		MonoGCHandle(MonoGCHandle::new_strong_handle(p_managed), STRONG_HANDLE) {}
+StringName EventSignalCallable::get_signal() const {
+	return event_signal->field->get_name();
+}
 
-SignalAwaiterHandle::~SignalAwaiterHandle() {
+void EventSignalCallable::call(const Variant **p_arguments, int p_argcount, Variant &r_return_value, Callable::CallError &r_call_error) const {
+	r_call_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD; // Can't find anything better
+	r_return_value = Variant();
 
-	if (!completed) {
-		MonoObject *awaiter = get_target();
+	ERR_FAIL_COND(p_argcount < event_signal->invoke_method->get_parameters_count());
 
-		if (awaiter) {
-			MonoException *exc = NULL;
-			GD_MONO_BEGIN_RUNTIME_INVOKE;
-			CACHED_METHOD_THUNK(SignalAwaiter, FailureCallback).invoke(awaiter, &exc);
-			GD_MONO_END_RUNTIME_INVOKE;
+	CSharpInstance *csharp_instance = CAST_CSHARP_INSTANCE(owner->get_script_instance());
+	ERR_FAIL_NULL(csharp_instance);
 
-			if (exc) {
-				GDMonoUtils::set_pending_exception(exc);
-				ERR_FAIL();
-			}
-		}
+	MonoObject *owner_managed = csharp_instance->get_mono_object();
+	ERR_FAIL_NULL(owner_managed);
+
+	MonoObject *delegate_field_value = event_signal->field->get_value(owner_managed);
+	if (!delegate_field_value) {
+		r_call_error.error = Callable::CallError::CALL_OK;
+		return;
 	}
+
+	MonoException *exc = NULL;
+	event_signal->invoke_method->invoke(delegate_field_value, p_arguments, &exc);
+
+	if (exc) {
+		GDMonoUtils::set_pending_exception(exc);
+		ERR_FAIL();
+	} else {
+		r_call_error.error = Callable::CallError::CALL_OK;
+	}
+}
+
+EventSignalCallable::EventSignalCallable(Object *p_owner, const CSharpScript::EventSignal *p_event_signal) :
+		owner(p_owner),
+		event_signal(p_event_signal) {
 }