C#: Move marshaling logic and generated glue to C#

We will be progressively moving most code to C#.
The plan is to only use Mono's embedding APIs to set things at launch.
This will make it much easier to later support CoreCLR too which
doesn't have rich embedding APIs.

Additionally the code in C# is more maintainable and makes it easier
to implement new features, e.g.: runtime codegen which we could use to
avoid using reflection for marshaling everytime a field, property or
method is accessed.

SOME NOTES ON INTEROP

We make the same assumptions as GDNative about the size of the Godot
structures we use. We take it a bit further by also assuming the layout
of fields in some cases, which is riskier but let's us squeeze out some
performance by avoiding unnecessary managed to native calls.

Code that deals with native structs is less safe than before as there's
no RAII and copy constructors in C#. It's like using the GDNative C API
directly. One has to take special care to free values they own.
Perhaps we could use roslyn analyzers to check this, but I don't know
any that uses attributes to determine what's owned or borrowed.

As to why we maily use pointers for native structs instead of ref/out:
- AFAIK (and confirmed with a benchmark) ref/out are pinned
  during P/Invoke calls and that has a cost.
- Native struct fields can't be ref/out in the first place.
- A `using` local can't be passed as ref/out, only `in`. Calling a
  method or property on an `in` value makes a silent copy, so we want
  to avoid `in`.

REGARDING THE BUILD SYSTEM

There's no longer a `mono_glue=yes/no` SCons options. We no longer
need to build with `mono_glue=no`, generate the glue and then build
again with `mono_glue=yes`. We build only once and generate the glue
(which is in C# now).
However, SCons no longer builds the C# projects for us. Instead one
must run `build_assemblies.py`, e.g.:
```sh
%godot_src_root%/modules/mono/build_scripts/build_assemblies.py \
        --godot-output-dir=%godot_src_root%/bin \
        --godot-target=release_debug`
```
We could turn this into a custom build target, but I don't know how
to do that with SCons (it's possible with Meson).

OTHER NOTES

Most of the moved code doesn't follow the C# naming convention and
still has the word Mono in the names despite no longer dealing with
Mono's embedding APIs. This is just temporary while transitioning,
to make it easier to understand what was moved where.

14 files changed, 188 insertions, 3145 deletions

diff --git a/modules/mono/mono_gd/gd_mono.cpp b/modules/mono/mono_gd/gd_mono.cpp
index d3d3bb2bef..eeaec30d73 100644
--- a/modules/mono/mono_gd/gd_mono.cpp
+++ b/modules/mono/mono_gd/gd_mono.cpp
@@ -408,10 +408,6 @@ void GDMono::initialize() {
 }
 
 void GDMono::initialize_load_assemblies() {
-#ifndef MONO_GLUE_ENABLED
-	CRASH_NOW_MSG("Mono: This binary was built with 'mono_glue=no'; cannot load assemblies.");
-#endif
-
 	// Load assemblies. The API and tools assemblies are required,
 	// the application is aborted if these assemblies cannot be loaded.
 
@@ -446,59 +442,34 @@ bool GDMono::_are_api_assemblies_out_of_sync() {
 	return out_of_sync;
 }
 
-namespace GodotSharpBindings {
-#ifdef MONO_GLUE_ENABLED
-
-uint64_t get_core_api_hash();
-#ifdef TOOLS_ENABLED
-uint64_t get_editor_api_hash();
-#endif
-uint32_t get_bindings_version();
-uint32_t get_cs_glue_version();
-
-void register_generated_icalls();
-
-#else
-
-uint64_t get_core_api_hash() {
-	GD_UNREACHABLE();
-}
-#ifdef TOOLS_ENABLED
-uint64_t get_editor_api_hash() {
-	GD_UNREACHABLE();
-}
-#endif
-uint32_t get_bindings_version() {
-	GD_UNREACHABLE();
-}
-
-uint32_t get_cs_glue_version() {
-	GD_UNREACHABLE();
-}
-
-void register_generated_icalls() {
-	/* Fine, just do nothing */
-}
-
-#endif // MONO_GLUE_ENABLED
-} // namespace GodotSharpBindings
+void godot_register_collections_icalls();
+void godot_register_gd_icalls();
+void godot_register_node_path_icalls();
+void godot_register_object_icalls();
+void godot_register_rid_icalls();
+void godot_register_string_icalls();
+void godot_register_scene_tree_icalls();
+void godot_register_placeholder_icalls();
 
 void GDMono::_register_internal_calls() {
-	GodotSharpBindings::register_generated_icalls();
+	// Registers internal calls that were not generated.
+	godot_register_collections_icalls();
+	godot_register_gd_icalls();
+	godot_register_node_path_icalls();
+	godot_register_object_icalls();
+	godot_register_string_icalls();
+	godot_register_scene_tree_icalls();
+	godot_register_placeholder_icalls();
 }
 
 void GDMono::_init_godot_api_hashes() {
-#if defined(MONO_GLUE_ENABLED) && defined(DEBUG_METHODS_ENABLED)
-	if (get_api_core_hash() != GodotSharpBindings::get_core_api_hash()) {
-		ERR_PRINT("Mono: Core API hash mismatch.");
-	}
+#ifdef DEBUG_METHODS_ENABLED
+	get_api_core_hash();
 
 #ifdef TOOLS_ENABLED
-	if (get_api_editor_hash() != GodotSharpBindings::get_editor_api_hash()) {
-		ERR_PRINT("Mono: Editor API hash mismatch.");
-	}
+	get_api_editor_hash();
 #endif // TOOLS_ENABLED
-#endif // MONO_GLUE_ENABLED && DEBUG_METHODS_ENABLED
+#endif // DEBUG_METHODS_ENABLED
 }
 
 void GDMono::_init_exception_policy() {
@@ -601,16 +572,6 @@ ApiAssemblyInfo::Version ApiAssemblyInfo::Version::get_from_loaded_assembly(GDMo
 		if (api_hash_field) {
 			api_assembly_version.godot_api_hash = GDMonoMarshal::unbox<uint64_t>(api_hash_field->get_value(nullptr));
 		}
-
-		GDMonoField *binds_ver_field = nativecalls_klass->get_field("bindings_version");
-		if (binds_ver_field) {
-			api_assembly_version.bindings_version = GDMonoMarshal::unbox<uint32_t>(binds_ver_field->get_value(nullptr));
-		}
-
-		GDMonoField *cs_glue_ver_field = nativecalls_klass->get_field("cs_glue_version");
-		if (cs_glue_ver_field) {
-			api_assembly_version.cs_glue_version = GDMonoMarshal::unbox<uint32_t>(cs_glue_ver_field->get_value(nullptr));
-		}
 	}
 
 	return api_assembly_version;
@@ -698,12 +659,8 @@ static bool try_get_cached_api_hash_for(const String &p_api_assemblies_dir, bool
 		return false;
 	}
 
-	r_out_of_sync = GodotSharpBindings::get_bindings_version() != (uint32_t)cfg->get_value("core", "bindings_version") ||
-			GodotSharpBindings::get_cs_glue_version() != (uint32_t)cfg->get_value("core", "cs_glue_version") ||
-			GodotSharpBindings::get_bindings_version() != (uint32_t)cfg->get_value("editor", "bindings_version") ||
-			GodotSharpBindings::get_cs_glue_version() != (uint32_t)cfg->get_value("editor", "cs_glue_version") ||
-			GodotSharpBindings::get_core_api_hash() != (uint64_t)cfg->get_value("core", "api_hash") ||
-			GodotSharpBindings::get_editor_api_hash() != (uint64_t)cfg->get_value("editor", "api_hash");
+	r_out_of_sync = GDMono::get_singleton()->get_api_core_hash() != (uint64_t)cfg->get_value("core", "api_hash") ||
+			GDMono::get_singleton()->get_api_editor_hash() != (uint64_t)cfg->get_value("editor", "api_hash");
 
 	return true;
 }
@@ -719,14 +676,9 @@ static void create_cached_api_hash_for(const String &p_api_assemblies_dir) {
 	cfg->set_value("core", "modified_time", FileAccess::get_modified_time(core_api_assembly_path));
 	cfg->set_value("editor", "modified_time", FileAccess::get_modified_time(editor_api_assembly_path));
 
-	cfg->set_value("core", "bindings_version", GodotSharpBindings::get_bindings_version());
-	cfg->set_value("core", "cs_glue_version", GodotSharpBindings::get_cs_glue_version());
-	cfg->set_value("editor", "bindings_version", GodotSharpBindings::get_bindings_version());
-	cfg->set_value("editor", "cs_glue_version", GodotSharpBindings::get_cs_glue_version());
-
 	// This assumes the prebuilt api assemblies we copied to the project are not out of sync
-	cfg->set_value("core", "api_hash", GodotSharpBindings::get_core_api_hash());
-	cfg->set_value("editor", "api_hash", GodotSharpBindings::get_editor_api_hash());
+	cfg->set_value("core", "api_hash", GDMono::get_singleton()->get_api_core_hash());
+	cfg->set_value("editor", "api_hash", GDMono::get_singleton()->get_api_editor_hash());
 
 	Error err = cfg->save(cached_api_hash_path);
 	ERR_FAIL_COND(err != OK);
@@ -764,7 +716,7 @@ String GDMono::update_api_assemblies_from_prebuilt(const String &p_config, const
 	bool api_assemblies_out_of_sync = false;
 
 	if (p_core_api_out_of_sync && p_editor_api_out_of_sync) {
-		api_assemblies_out_of_sync = p_core_api_out_of_sync || p_editor_api_out_of_sync;
+		api_assemblies_out_of_sync = *p_core_api_out_of_sync || *p_editor_api_out_of_sync;
 	} else if (FileAccess::exists(core_assembly_path) && FileAccess::exists(editor_assembly_path)) {
 		// Determine if they're out of sync
 		if (!try_get_cached_api_hash_for(dst_assemblies_dir, api_assemblies_out_of_sync)) {
@@ -824,14 +776,16 @@ bool GDMono::_load_core_api_assembly(LoadedApiAssembly &r_loaded_api_assembly, c
 	bool success = load_assembly(CORE_API_ASSEMBLY_NAME, &r_loaded_api_assembly.assembly, p_refonly);
 #endif
 
+#ifdef DEBUG_METHODS_ENABLED
 	if (success) {
 		ApiAssemblyInfo::Version api_assembly_ver = ApiAssemblyInfo::Version::get_from_loaded_assembly(r_loaded_api_assembly.assembly, ApiAssemblyInfo::API_CORE);
-		r_loaded_api_assembly.out_of_sync = GodotSharpBindings::get_core_api_hash() != api_assembly_ver.godot_api_hash ||
-				GodotSharpBindings::get_bindings_version() != api_assembly_ver.bindings_version ||
-				GodotSharpBindings::get_cs_glue_version() != api_assembly_ver.cs_glue_version;
+		r_loaded_api_assembly.out_of_sync = get_api_core_hash() != api_assembly_ver.godot_api_hash;
 	} else {
 		r_loaded_api_assembly.out_of_sync = false;
 	}
+#else
+	r_loaded_api_assembly.out_of_sync = false;
+#endif
 
 	return success;
 }
@@ -854,14 +808,16 @@ bool GDMono::_load_editor_api_assembly(LoadedApiAssembly &r_loaded_api_assembly,
 	bool success = FileAccess::exists(assembly_path) &&
 			load_assembly_from(EDITOR_API_ASSEMBLY_NAME, assembly_path, &r_loaded_api_assembly.assembly, p_refonly);
 
+#ifdef DEBUG_METHODS_ENABLED
 	if (success) {
 		ApiAssemblyInfo::Version api_assembly_ver = ApiAssemblyInfo::Version::get_from_loaded_assembly(r_loaded_api_assembly.assembly, ApiAssemblyInfo::API_EDITOR);
-		r_loaded_api_assembly.out_of_sync = GodotSharpBindings::get_editor_api_hash() != api_assembly_ver.godot_api_hash ||
-				GodotSharpBindings::get_bindings_version() != api_assembly_ver.bindings_version ||
-				GodotSharpBindings::get_cs_glue_version() != api_assembly_ver.cs_glue_version;
+		r_loaded_api_assembly.out_of_sync = get_api_editor_hash() != api_assembly_ver.godot_api_hash;
 	} else {
 		r_loaded_api_assembly.out_of_sync = false;
 	}
+#else
+	r_loaded_api_assembly.out_of_sync = false;
+#endif
 
 	return success;
 }
@@ -1091,13 +1047,13 @@ Error GDMono::_unload_scripts_domain() {
 Error GDMono::reload_scripts_domain() {
 	ERR_FAIL_COND_V(!runtime_initialized, ERR_BUG);
 
+	CSharpLanguage::get_singleton()->_on_scripts_domain_about_to_unload();
+
 	if (scripts_domain) {
 		Error domain_unload_err = _unload_scripts_domain();
 		ERR_FAIL_COND_V_MSG(domain_unload_err != OK, domain_unload_err, "Mono: Failed to unload scripts domain.");
 	}
 
-	CSharpLanguage::get_singleton()->_on_scripts_domain_unloaded();
-
 	Error domain_load_err = _load_scripts_domain();
 	ERR_FAIL_COND_V_MSG(domain_load_err != OK, domain_load_err, "Mono: Failed to load scripts domain.");
 
diff --git a/modules/mono/mono_gd/gd_mono.h b/modules/mono/mono_gd/gd_mono.h
index 51fd0f8483..bc871fe750 100644
--- a/modules/mono/mono_gd/gd_mono.h
+++ b/modules/mono/mono_gd/gd_mono.h
@@ -49,23 +49,15 @@ enum Type {
 
 struct Version {
 	uint64_t godot_api_hash = 0;
-	uint32_t bindings_version = 0;
-	uint32_t cs_glue_version = 0;
 
 	bool operator==(const Version &p_other) const {
-		return godot_api_hash == p_other.godot_api_hash &&
-				bindings_version == p_other.bindings_version &&
-				cs_glue_version == p_other.cs_glue_version;
+		return godot_api_hash == p_other.godot_api_hash;
 	}
 
 	Version() {}
 
-	Version(uint64_t p_godot_api_hash,
-			uint32_t p_bindings_version,
-			uint32_t p_cs_glue_version) :
-			godot_api_hash(p_godot_api_hash),
-			bindings_version(p_bindings_version),
-			cs_glue_version(p_cs_glue_version) {
+	Version(uint64_t p_godot_api_hash) :
+			godot_api_hash(p_godot_api_hash) {
 	}
 
 	static Version get_from_loaded_assembly(GDMonoAssembly *p_api_assembly, Type p_api_type);
diff --git a/modules/mono/mono_gd/gd_mono_cache.cpp b/modules/mono/mono_gd/gd_mono_cache.cpp
index 69d8c7edc9..08660e3701 100644
--- a/modules/mono/mono_gd/gd_mono_cache.cpp
+++ b/modules/mono/mono_gd/gd_mono_cache.cpp
@@ -48,8 +48,6 @@ CachedData cached_data;
 	}
 
 #define CACHE_CLASS_AND_CHECK(m_class, m_val) CACHE_AND_CHECK(cached_data.class_##m_class, m_val)
-#define CACHE_NS_CLASS_AND_CHECK(m_ns, m_class, m_val) CACHE_AND_CHECK(cached_data.class_##m_ns##_##m_class, m_val)
-#define CACHE_RAW_MONO_CLASS_AND_CHECK(m_class, m_val) CACHE_AND_CHECK(cached_data.rawclass_##m_class, m_val)
 #define CACHE_FIELD_AND_CHECK(m_class, m_field, m_val) CACHE_AND_CHECK(cached_data.field_##m_class##_##m_field, m_val)
 #define CACHE_METHOD_AND_CHECK(m_class, m_method, m_val) CACHE_AND_CHECK(cached_data.method_##m_class##_##m_method, m_val)
 #define CACHE_PROPERTY_AND_CHECK(m_class, m_property, m_val) CACHE_AND_CHECK(cached_data.property_##m_class##_##m_property, m_val)
@@ -68,23 +66,7 @@ void CachedData::clear_corlib_cache() {
 	corlib_cache_updated = false;
 
 	class_MonoObject = nullptr;
-	class_bool = nullptr;
-	class_int8_t = nullptr;
-	class_int16_t = nullptr;
-	class_int32_t = nullptr;
-	class_int64_t = nullptr;
-	class_uint8_t = nullptr;
-	class_uint16_t = nullptr;
-	class_uint32_t = nullptr;
-	class_uint64_t = nullptr;
-	class_float = nullptr;
-	class_double = nullptr;
 	class_String = nullptr;
-	class_IntPtr = nullptr;
-
-	class_System_Collections_IEnumerable = nullptr;
-	class_System_Collections_ICollection = nullptr;
-	class_System_Collections_IDictionary = nullptr;
 
 #ifdef DEBUG_ENABLED
 	class_System_Diagnostics_StackTrace = nullptr;
@@ -99,38 +81,12 @@ void CachedData::clear_corlib_cache() {
 void CachedData::clear_godot_api_cache() {
 	godot_api_cache_updated = false;
 
-	rawclass_Dictionary = nullptr;
-
-	class_Vector2 = nullptr;
-	class_Vector2i = nullptr;
-	class_Rect2 = nullptr;
-	class_Rect2i = nullptr;
-	class_Transform2D = nullptr;
-	class_Vector3 = nullptr;
-	class_Vector3i = nullptr;
-	class_Vector4 = nullptr;
-	class_Vector4i = nullptr;
-	class_Basis = nullptr;
-	class_Quaternion = nullptr;
-	class_Transform3D = nullptr;
-	class_Projection = nullptr;
-	class_AABB = nullptr;
-	class_Color = nullptr;
-	class_Plane = nullptr;
-	class_StringName = nullptr;
-	class_NodePath = nullptr;
-	class_RID = nullptr;
 	class_GodotObject = nullptr;
 	class_GodotResource = nullptr;
 	class_Node = nullptr;
 	class_Control = nullptr;
-	class_Node3D = nullptr;
-	class_WeakRef = nullptr;
 	class_Callable = nullptr;
 	class_SignalInfo = nullptr;
-	class_Array = nullptr;
-	class_Dictionary = nullptr;
-	class_MarshalUtils = nullptr;
 	class_ISerializationListener = nullptr;
 
 #ifdef DEBUG_ENABLED
@@ -157,68 +113,39 @@ void CachedData::clear_godot_api_cache() {
 	field_AssemblyHasScriptsAttribute_scriptTypes = nullptr;
 
 	field_GodotObject_ptr = nullptr;
-	field_StringName_ptr = nullptr;
-	field_NodePath_ptr = nullptr;
-	field_Image_ptr = nullptr;
-	field_RID_ptr = nullptr;
 
 	methodthunk_GodotObject_Dispose.nullify();
-	methodthunk_Array_GetPtr.nullify();
-	methodthunk_Dictionary_GetPtr.nullify();
 	methodthunk_SignalAwaiter_SignalCallback.nullify();
 	methodthunk_GodotTaskScheduler_Activate.nullify();
 
 	methodthunk_Delegate_Equals.nullify();
 
+	methodthunk_DelegateUtils_TrySerializeDelegateWithGCHandle.nullify();
+	methodthunk_DelegateUtils_TryDeserializeDelegateWithGCHandle.nullify();
 	methodthunk_DelegateUtils_TrySerializeDelegate.nullify();
 	methodthunk_DelegateUtils_TryDeserializeDelegate.nullify();
+	methodthunk_DelegateUtils_InvokeWithVariantArgs.nullify();
+	methodthunk_DelegateUtils_DelegateEquals.nullify();
+	methodthunk_DelegateUtils_FreeGCHandle.nullify();
 
-	// Start of MarshalUtils methods
-
-	methodthunk_MarshalUtils_TypeIsGenericArray.nullify();
-	methodthunk_MarshalUtils_TypeIsGenericDictionary.nullify();
-	methodthunk_MarshalUtils_TypeIsSystemGenericList.nullify();
-	methodthunk_MarshalUtils_TypeIsSystemGenericDictionary.nullify();
-	methodthunk_MarshalUtils_TypeIsGenericIEnumerable.nullify();
-	methodthunk_MarshalUtils_TypeIsGenericICollection.nullify();
-	methodthunk_MarshalUtils_TypeIsGenericIDictionary.nullify();
-	methodthunk_MarshalUtils_TypeHasFlagsAttribute.nullify();
-
-	methodthunk_MarshalUtils_GetGenericTypeDefinition.nullify();
-
-	methodthunk_MarshalUtils_ArrayGetElementType.nullify();
-	methodthunk_MarshalUtils_DictionaryGetKeyValueTypes.nullify();
+	methodthunk_Marshaling_managed_to_variant_type.nullify();
+	methodthunk_Marshaling_try_get_array_element_type.nullify();
+	methodthunk_Marshaling_variant_to_mono_object_of_type.nullify();
+	methodthunk_Marshaling_variant_to_mono_object.nullify();
+	methodthunk_Marshaling_mono_object_to_variant_out.nullify();
 
-	methodthunk_MarshalUtils_MakeGenericArrayType.nullify();
-	methodthunk_MarshalUtils_MakeGenericDictionaryType.nullify();
+	methodthunk_Marshaling_SetFieldValue.nullify();
 
-	// End of MarshalUtils methods
+	methodthunk_MarshalUtils_TypeHasFlagsAttribute.nullify();
 
 	task_scheduler_handle = Ref<MonoGCHandleRef>();
 }
 
 #define GODOT_API_CLASS(m_class) (GDMono::get_singleton()->get_core_api_assembly()->get_class(BINDINGS_NAMESPACE, #m_class))
-#define GODOT_API_NS_CLASS(m_ns, m_class) (GDMono::get_singleton()->get_core_api_assembly()->get_class(m_ns, #m_class))
 
 void update_corlib_cache() {
 	CACHE_CLASS_AND_CHECK(MonoObject, GDMono::get_singleton()->get_corlib_assembly()->get_class(mono_get_object_class()));
-	CACHE_CLASS_AND_CHECK(bool, GDMono::get_singleton()->get_corlib_assembly()->get_class(mono_get_boolean_class()));
-	CACHE_CLASS_AND_CHECK(int8_t, GDMono::get_singleton()->get_corlib_assembly()->get_class(mono_get_sbyte_class()));
-	CACHE_CLASS_AND_CHECK(int16_t, GDMono::get_singleton()->get_corlib_assembly()->get_class(mono_get_int16_class()));
-	CACHE_CLASS_AND_CHECK(int32_t, GDMono::get_singleton()->get_corlib_assembly()->get_class(mono_get_int32_class()));
-	CACHE_CLASS_AND_CHECK(int64_t, GDMono::get_singleton()->get_corlib_assembly()->get_class(mono_get_int64_class()));
-	CACHE_CLASS_AND_CHECK(uint8_t, GDMono::get_singleton()->get_corlib_assembly()->get_class(mono_get_byte_class()));
-	CACHE_CLASS_AND_CHECK(uint16_t, GDMono::get_singleton()->get_corlib_assembly()->get_class(mono_get_uint16_class()));
-	CACHE_CLASS_AND_CHECK(uint32_t, GDMono::get_singleton()->get_corlib_assembly()->get_class(mono_get_uint32_class()));
-	CACHE_CLASS_AND_CHECK(uint64_t, GDMono::get_singleton()->get_corlib_assembly()->get_class(mono_get_uint64_class()));
-	CACHE_CLASS_AND_CHECK(float, GDMono::get_singleton()->get_corlib_assembly()->get_class(mono_get_single_class()));
-	CACHE_CLASS_AND_CHECK(double, GDMono::get_singleton()->get_corlib_assembly()->get_class(mono_get_double_class()));
 	CACHE_CLASS_AND_CHECK(String, GDMono::get_singleton()->get_corlib_assembly()->get_class(mono_get_string_class()));
-	CACHE_CLASS_AND_CHECK(IntPtr, GDMono::get_singleton()->get_corlib_assembly()->get_class(mono_get_intptr_class()));
-
-	CACHE_CLASS_AND_CHECK(System_Collections_IEnumerable, GDMono::get_singleton()->get_corlib_assembly()->get_class("System.Collections", "IEnumerable"));
-	CACHE_CLASS_AND_CHECK(System_Collections_ICollection, GDMono::get_singleton()->get_corlib_assembly()->get_class("System.Collections", "ICollection"));
-	CACHE_CLASS_AND_CHECK(System_Collections_IDictionary, GDMono::get_singleton()->get_corlib_assembly()->get_class("System.Collections", "IDictionary"));
 
 #ifdef DEBUG_ENABLED
 	CACHE_CLASS_AND_CHECK(System_Diagnostics_StackTrace, GDMono::get_singleton()->get_corlib_assembly()->get_class("System.Diagnostics", "StackTrace"));
@@ -235,36 +162,12 @@ void update_corlib_cache() {
 }
 
 void update_godot_api_cache() {
-	CACHE_CLASS_AND_CHECK(Vector2, GODOT_API_CLASS(Vector2));
-	CACHE_CLASS_AND_CHECK(Vector2i, GODOT_API_CLASS(Vector2i));
-	CACHE_CLASS_AND_CHECK(Rect2, GODOT_API_CLASS(Rect2));
-	CACHE_CLASS_AND_CHECK(Rect2i, GODOT_API_CLASS(Rect2i));
-	CACHE_CLASS_AND_CHECK(Transform2D, GODOT_API_CLASS(Transform2D));
-	CACHE_CLASS_AND_CHECK(Vector3, GODOT_API_CLASS(Vector3));
-	CACHE_CLASS_AND_CHECK(Vector3i, GODOT_API_CLASS(Vector3i));
-	CACHE_CLASS_AND_CHECK(Vector4, GODOT_API_CLASS(Vector4));
-	CACHE_CLASS_AND_CHECK(Vector4i, GODOT_API_CLASS(Vector4i));
-	CACHE_CLASS_AND_CHECK(Basis, GODOT_API_CLASS(Basis));
-	CACHE_CLASS_AND_CHECK(Quaternion, GODOT_API_CLASS(Quaternion));
-	CACHE_CLASS_AND_CHECK(Transform3D, GODOT_API_CLASS(Transform3D));
-	CACHE_CLASS_AND_CHECK(Projection, GODOT_API_CLASS(Projection));
-	CACHE_CLASS_AND_CHECK(AABB, GODOT_API_CLASS(AABB));
-	CACHE_CLASS_AND_CHECK(Color, GODOT_API_CLASS(Color));
-	CACHE_CLASS_AND_CHECK(Plane, GODOT_API_CLASS(Plane));
-	CACHE_CLASS_AND_CHECK(StringName, GODOT_API_CLASS(StringName));
-	CACHE_CLASS_AND_CHECK(NodePath, GODOT_API_CLASS(NodePath));
-	CACHE_CLASS_AND_CHECK(RID, GODOT_API_CLASS(RID));
 	CACHE_CLASS_AND_CHECK(GodotObject, GODOT_API_CLASS(Object));
 	CACHE_CLASS_AND_CHECK(GodotResource, GODOT_API_CLASS(Resource));
 	CACHE_CLASS_AND_CHECK(Node, GODOT_API_CLASS(Node));
 	CACHE_CLASS_AND_CHECK(Control, GODOT_API_CLASS(Control));
-	CACHE_CLASS_AND_CHECK(Node3D, GODOT_API_CLASS(Node3D));
-	CACHE_CLASS_AND_CHECK(WeakRef, GODOT_API_CLASS(WeakRef));
 	CACHE_CLASS_AND_CHECK(Callable, GODOT_API_CLASS(Callable));
 	CACHE_CLASS_AND_CHECK(SignalInfo, GODOT_API_CLASS(SignalInfo));
-	CACHE_CLASS_AND_CHECK(Array, GODOT_API_NS_CLASS(BINDINGS_NAMESPACE_COLLECTIONS, Array));
-	CACHE_CLASS_AND_CHECK(Dictionary, GODOT_API_NS_CLASS(BINDINGS_NAMESPACE_COLLECTIONS, Dictionary));
-	CACHE_CLASS_AND_CHECK(MarshalUtils, GODOT_API_CLASS(MarshalUtils));
 	CACHE_CLASS_AND_CHECK(ISerializationListener, GODOT_API_CLASS(ISerializationListener));
 
 #ifdef DEBUG_ENABLED
@@ -291,40 +194,41 @@ void update_godot_api_cache() {
 	CACHE_FIELD_AND_CHECK(AssemblyHasScriptsAttribute, scriptTypes, CACHED_CLASS(AssemblyHasScriptsAttribute)->get_field("scriptTypes"));
 
 	CACHE_FIELD_AND_CHECK(GodotObject, ptr, CACHED_CLASS(GodotObject)->get_field(BINDINGS_PTR_FIELD));
-	CACHE_FIELD_AND_CHECK(StringName, ptr, CACHED_CLASS(StringName)->get_field(BINDINGS_PTR_FIELD));
-	CACHE_FIELD_AND_CHECK(NodePath, ptr, CACHED_CLASS(NodePath)->get_field(BINDINGS_PTR_FIELD));
-	CACHE_FIELD_AND_CHECK(RID, ptr, CACHED_CLASS(RID)->get_field(BINDINGS_PTR_FIELD));
 
 	CACHE_METHOD_THUNK_AND_CHECK(GodotObject, Dispose, CACHED_CLASS(GodotObject)->get_method("Dispose", 0));
-	CACHE_METHOD_THUNK_AND_CHECK(Array, GetPtr, GODOT_API_NS_CLASS(BINDINGS_NAMESPACE_COLLECTIONS, Array)->get_method("GetPtr", 0));
-	CACHE_METHOD_THUNK_AND_CHECK(Dictionary, GetPtr, GODOT_API_NS_CLASS(BINDINGS_NAMESPACE_COLLECTIONS, Dictionary)->get_method("GetPtr", 0));
 	CACHE_METHOD_THUNK_AND_CHECK(SignalAwaiter, SignalCallback, GODOT_API_CLASS(SignalAwaiter)->get_method("SignalCallback", 1));
 	CACHE_METHOD_THUNK_AND_CHECK(GodotTaskScheduler, Activate, GODOT_API_CLASS(GodotTaskScheduler)->get_method("Activate", 0));
 
+	CACHE_METHOD_THUNK_AND_CHECK(DelegateUtils, TrySerializeDelegateWithGCHandle, GODOT_API_CLASS(DelegateUtils)->get_method("TrySerializeDelegateWithGCHandle", 2));
+	CACHE_METHOD_THUNK_AND_CHECK(DelegateUtils, TryDeserializeDelegateWithGCHandle, GODOT_API_CLASS(DelegateUtils)->get_method("TryDeserializeDelegateWithGCHandle", 2));
 	CACHE_METHOD_THUNK_AND_CHECK(DelegateUtils, TrySerializeDelegate, GODOT_API_CLASS(DelegateUtils)->get_method("TrySerializeDelegate", 2));
 	CACHE_METHOD_THUNK_AND_CHECK(DelegateUtils, TryDeserializeDelegate, GODOT_API_CLASS(DelegateUtils)->get_method("TryDeserializeDelegate", 2));
+	CACHE_METHOD_THUNK_AND_CHECK(DelegateUtils, InvokeWithVariantArgs, GODOT_API_CLASS(DelegateUtils)->get_method("InvokeWithVariantArgs", 4));
+	CACHE_METHOD_THUNK_AND_CHECK(DelegateUtils, DelegateEquals, GODOT_API_CLASS(DelegateUtils)->get_method("DelegateEquals", 2));
+	CACHE_METHOD_THUNK_AND_CHECK(DelegateUtils, FreeGCHandle, GODOT_API_CLASS(DelegateUtils)->get_method("FreeGCHandle", 1));
+
+	GDMonoClass *gd_mono_marshal_class = GDMono::get_singleton()->get_core_api_assembly()->get_class(
+			"Godot.NativeInterop", "Marshaling");
+
+	ERR_FAIL_COND_MSG(gd_mono_marshal_class == nullptr,
+			"Mono Cache: Class `Godot.NativeInterop.Marshaling` not found.");
+
+	CACHE_METHOD_THUNK_AND_CHECK(Marshaling, managed_to_variant_type,
+			gd_mono_marshal_class->get_method("managed_to_variant_type", 2));
+	CACHE_METHOD_THUNK_AND_CHECK(Marshaling, try_get_array_element_type,
+			gd_mono_marshal_class->get_method("try_get_array_element_type", 2));
+	CACHE_METHOD_THUNK_AND_CHECK(Marshaling, variant_to_mono_object_of_type,
+			gd_mono_marshal_class->get_method("variant_to_mono_object_of_type", 2));
+	CACHE_METHOD_THUNK_AND_CHECK(Marshaling, variant_to_mono_object,
+			gd_mono_marshal_class->get_method("variant_to_mono_object", 1));
+	CACHE_METHOD_THUNK_AND_CHECK(Marshaling, mono_object_to_variant_out,
+			gd_mono_marshal_class->get_method("mono_object_to_variant_out", 3));
+
+	CACHE_METHOD_THUNK_AND_CHECK(Marshaling, SetFieldValue,
+			gd_mono_marshal_class->get_method("SetFieldValue", 3));
 
-	// Start of MarshalUtils methods
-
-	CACHE_METHOD_THUNK_AND_CHECK(MarshalUtils, TypeIsGenericArray, GODOT_API_CLASS(MarshalUtils)->get_method("TypeIsGenericArray", 1));
-	CACHE_METHOD_THUNK_AND_CHECK(MarshalUtils, TypeIsGenericDictionary, GODOT_API_CLASS(MarshalUtils)->get_method("TypeIsGenericDictionary", 1));
-	CACHE_METHOD_THUNK_AND_CHECK(MarshalUtils, TypeIsSystemGenericList, GODOT_API_CLASS(MarshalUtils)->get_method("TypeIsSystemGenericList", 1));
-	CACHE_METHOD_THUNK_AND_CHECK(MarshalUtils, TypeIsSystemGenericDictionary, GODOT_API_CLASS(MarshalUtils)->get_method("TypeIsSystemGenericDictionary", 1));
-	CACHE_METHOD_THUNK_AND_CHECK(MarshalUtils, TypeIsGenericIEnumerable, GODOT_API_CLASS(MarshalUtils)->get_method("TypeIsGenericIEnumerable", 1));
-	CACHE_METHOD_THUNK_AND_CHECK(MarshalUtils, TypeIsGenericICollection, GODOT_API_CLASS(MarshalUtils)->get_method("TypeIsGenericICollection", 1));
-	CACHE_METHOD_THUNK_AND_CHECK(MarshalUtils, TypeIsGenericIDictionary, GODOT_API_CLASS(MarshalUtils)->get_method("TypeIsGenericIDictionary", 1));
 	CACHE_METHOD_THUNK_AND_CHECK(MarshalUtils, TypeHasFlagsAttribute, GODOT_API_CLASS(MarshalUtils)->get_method("TypeHasFlagsAttribute", 1));
 
-	CACHE_METHOD_THUNK_AND_CHECK(MarshalUtils, GetGenericTypeDefinition, GODOT_API_CLASS(MarshalUtils)->get_method("GetGenericTypeDefinition", 2));
-
-	CACHE_METHOD_THUNK_AND_CHECK(MarshalUtils, ArrayGetElementType, GODOT_API_CLASS(MarshalUtils)->get_method("ArrayGetElementType", 2));
-	CACHE_METHOD_THUNK_AND_CHECK(MarshalUtils, DictionaryGetKeyValueTypes, GODOT_API_CLASS(MarshalUtils)->get_method("DictionaryGetKeyValueTypes", 3));
-
-	CACHE_METHOD_THUNK_AND_CHECK(MarshalUtils, MakeGenericArrayType, GODOT_API_CLASS(MarshalUtils)->get_method("MakeGenericArrayType", 1));
-	CACHE_METHOD_THUNK_AND_CHECK(MarshalUtils, MakeGenericDictionaryType, GODOT_API_CLASS(MarshalUtils)->get_method("MakeGenericDictionaryType", 2));
-
-	// End of MarshalUtils methods
-
 #ifdef DEBUG_ENABLED
 	CACHE_METHOD_THUNK_AND_CHECK(DebuggingUtils, GetStackFrameInfo, GODOT_API_CLASS(DebuggingUtils)->get_method("GetStackFrameInfo", 4));
 #endif
diff --git a/modules/mono/mono_gd/gd_mono_cache.h b/modules/mono/mono_gd/gd_mono_cache.h
index e9cc26899e..0db32b5885 100644
--- a/modules/mono/mono_gd/gd_mono_cache.h
+++ b/modules/mono/mono_gd/gd_mono_cache.h
@@ -42,23 +42,7 @@ struct CachedData {
 
 	// Let's use the no-namespace format for these too
 	GDMonoClass *class_MonoObject = nullptr; // object
-	GDMonoClass *class_bool = nullptr; // bool
-	GDMonoClass *class_int8_t = nullptr; // sbyte
-	GDMonoClass *class_int16_t = nullptr; // short
-	GDMonoClass *class_int32_t = nullptr; // int
-	GDMonoClass *class_int64_t = nullptr; // long
-	GDMonoClass *class_uint8_t = nullptr; // byte
-	GDMonoClass *class_uint16_t = nullptr; // ushort
-	GDMonoClass *class_uint32_t = nullptr; // uint
-	GDMonoClass *class_uint64_t = nullptr; // ulong
-	GDMonoClass *class_float = nullptr; // float
-	GDMonoClass *class_double = nullptr; // double
 	GDMonoClass *class_String = nullptr; // string
-	GDMonoClass *class_IntPtr = nullptr; // System.IntPtr
-
-	GDMonoClass *class_System_Collections_IEnumerable = nullptr;
-	GDMonoClass *class_System_Collections_ICollection = nullptr;
-	GDMonoClass *class_System_Collections_IDictionary = nullptr;
 
 #ifdef DEBUG_ENABLED
 	GDMonoClass *class_System_Diagnostics_StackTrace = nullptr;
@@ -68,40 +52,14 @@ struct CachedData {
 #endif
 
 	GDMonoClass *class_KeyNotFoundException = nullptr;
-
-	MonoClass *rawclass_Dictionary = nullptr;
 	// -----------------------------------------------
 
-	GDMonoClass *class_Vector2 = nullptr;
-	GDMonoClass *class_Vector2i = nullptr;
-	GDMonoClass *class_Rect2 = nullptr;
-	GDMonoClass *class_Rect2i = nullptr;
-	GDMonoClass *class_Transform2D = nullptr;
-	GDMonoClass *class_Vector3 = nullptr;
-	GDMonoClass *class_Vector3i = nullptr;
-	GDMonoClass *class_Vector4 = nullptr;
-	GDMonoClass *class_Vector4i = nullptr;
-	GDMonoClass *class_Basis = nullptr;
-	GDMonoClass *class_Quaternion = nullptr;
-	GDMonoClass *class_Transform3D = nullptr;
-	GDMonoClass *class_Projection = nullptr;
-	GDMonoClass *class_AABB = nullptr;
-	GDMonoClass *class_Color = nullptr;
-	GDMonoClass *class_Plane = nullptr;
-	GDMonoClass *class_StringName = nullptr;
-	GDMonoClass *class_NodePath = nullptr;
-	GDMonoClass *class_RID = nullptr;
 	GDMonoClass *class_GodotObject = nullptr;
 	GDMonoClass *class_GodotResource = nullptr;
 	GDMonoClass *class_Node = nullptr;
 	GDMonoClass *class_Control = nullptr;
-	GDMonoClass *class_Node3D = nullptr;
-	GDMonoClass *class_WeakRef = nullptr;
 	GDMonoClass *class_Callable = nullptr;
 	GDMonoClass *class_SignalInfo = nullptr;
-	GDMonoClass *class_Array = nullptr;
-	GDMonoClass *class_Dictionary = nullptr;
-	GDMonoClass *class_MarshalUtils = nullptr;
 	GDMonoClass *class_ISerializationListener = nullptr;
 
 #ifdef DEBUG_ENABLED
@@ -127,43 +85,34 @@ struct CachedData {
 	GDMonoField *field_AssemblyHasScriptsAttribute_requiresLookup = nullptr;
 	GDMonoField *field_AssemblyHasScriptsAttribute_scriptTypes = nullptr;
 
+
 	GDMonoField *field_GodotObject_ptr = nullptr;
-	GDMonoField *field_StringName_ptr = nullptr;
-	GDMonoField *field_NodePath_ptr = nullptr;
-	GDMonoField *field_Image_ptr = nullptr;
-	GDMonoField *field_RID_ptr = nullptr;
 
 	GDMonoMethodThunk<MonoObject *> methodthunk_GodotObject_Dispose;
-	GDMonoMethodThunkR<Array *, MonoObject *> methodthunk_Array_GetPtr;
-	GDMonoMethodThunkR<Dictionary *, MonoObject *> methodthunk_Dictionary_GetPtr;
 	GDMonoMethodThunk<MonoObject *, MonoArray *> methodthunk_SignalAwaiter_SignalCallback;
 	GDMonoMethodThunk<MonoObject *> methodthunk_GodotTaskScheduler_Activate;
 
 	GDMonoMethodThunkR<MonoBoolean, MonoObject *, MonoObject *> methodthunk_Delegate_Equals;
 
+	GDMonoMethodThunkR<MonoBoolean, void *, MonoObject *> methodthunk_DelegateUtils_TrySerializeDelegateWithGCHandle;
+	GDMonoMethodThunkR<MonoBoolean, MonoObject *, void **> methodthunk_DelegateUtils_TryDeserializeDelegateWithGCHandle;
+
 	GDMonoMethodThunkR<MonoBoolean, MonoDelegate *, MonoObject *> methodthunk_DelegateUtils_TrySerializeDelegate;
 	GDMonoMethodThunkR<MonoBoolean, MonoObject *, MonoDelegate **> methodthunk_DelegateUtils_TryDeserializeDelegate;
 
-	// Start of MarshalUtils methods
-
-	GDMonoMethodThunkR<MonoBoolean, MonoReflectionType *> methodthunk_MarshalUtils_TypeIsGenericArray;
-	GDMonoMethodThunkR<MonoBoolean, MonoReflectionType *> methodthunk_MarshalUtils_TypeIsGenericDictionary;
-	GDMonoMethodThunkR<MonoBoolean, MonoReflectionType *> methodthunk_MarshalUtils_TypeIsSystemGenericList;
-	GDMonoMethodThunkR<MonoBoolean, MonoReflectionType *> methodthunk_MarshalUtils_TypeIsSystemGenericDictionary;
-	GDMonoMethodThunkR<MonoBoolean, MonoReflectionType *> methodthunk_MarshalUtils_TypeIsGenericIEnumerable;
-	GDMonoMethodThunkR<MonoBoolean, MonoReflectionType *> methodthunk_MarshalUtils_TypeIsGenericICollection;
-	GDMonoMethodThunkR<MonoBoolean, MonoReflectionType *> methodthunk_MarshalUtils_TypeIsGenericIDictionary;
-	GDMonoMethodThunkR<MonoBoolean, MonoReflectionType *> methodthunk_MarshalUtils_TypeHasFlagsAttribute;
-
-	GDMonoMethodThunk<MonoReflectionType *, MonoReflectionType **> methodthunk_MarshalUtils_GetGenericTypeDefinition;
+	GDMonoMethodThunk<void *, const Variant **, uint32_t, const Variant *> methodthunk_DelegateUtils_InvokeWithVariantArgs;
+	GDMonoMethodThunkR<MonoBoolean, void *, void *> methodthunk_DelegateUtils_DelegateEquals;
+	GDMonoMethodThunk<void *> methodthunk_DelegateUtils_FreeGCHandle;
 
-	GDMonoMethodThunk<MonoReflectionType *, MonoReflectionType **> methodthunk_MarshalUtils_ArrayGetElementType;
-	GDMonoMethodThunk<MonoReflectionType *, MonoReflectionType **, MonoReflectionType **> methodthunk_MarshalUtils_DictionaryGetKeyValueTypes;
+	GDMonoMethodThunkR<int32_t, MonoReflectionType *, MonoBoolean *> methodthunk_Marshaling_managed_to_variant_type;
+	GDMonoMethodThunkR<MonoBoolean, MonoReflectionType *, MonoReflectionType **> methodthunk_Marshaling_try_get_array_element_type;
+	GDMonoMethodThunkR<MonoObject *, const Variant *, MonoReflectionType *> methodthunk_Marshaling_variant_to_mono_object_of_type;
+	GDMonoMethodThunkR<MonoObject *, const Variant *> methodthunk_Marshaling_variant_to_mono_object;
+	GDMonoMethodThunk<MonoObject *, MonoBoolean, Variant *> methodthunk_Marshaling_mono_object_to_variant_out;
 
-	GDMonoMethodThunkR<MonoReflectionType *, MonoReflectionType *> methodthunk_MarshalUtils_MakeGenericArrayType;
-	GDMonoMethodThunkR<MonoReflectionType *, MonoReflectionType *, MonoReflectionType *> methodthunk_MarshalUtils_MakeGenericDictionaryType;
+	GDMonoMethodThunk<MonoReflectionField *, MonoObject *, const Variant *> methodthunk_Marshaling_SetFieldValue;
 
-	// End of MarshalUtils methods
+	GDMonoMethodThunkR<MonoBoolean, MonoReflectionType *> methodthunk_MarshalUtils_TypeHasFlagsAttribute;
 
 	Ref<MonoGCHandleRef> task_scheduler_handle;
 
@@ -184,10 +133,6 @@ extern CachedData cached_data;
 void update_corlib_cache();
 void update_godot_api_cache();
 
-inline void clear_corlib_cache() {
-	cached_data.clear_corlib_cache();
-}
-
 inline void clear_godot_api_cache() {
 	cached_data.clear_godot_api_cache();
 }
@@ -195,7 +140,6 @@ inline void clear_godot_api_cache() {
 
 #define CACHED_CLASS(m_class) (GDMonoCache::cached_data.class_##m_class)
 #define CACHED_CLASS_RAW(m_class) (GDMonoCache::cached_data.class_##m_class->get_mono_ptr())
-#define CACHED_RAW_MONO_CLASS(m_class) (GDMonoCache::cached_data.rawclass_##m_class)
 #define CACHED_FIELD(m_class, m_field) (GDMonoCache::cached_data.field_##m_class##_##m_field)
 #define CACHED_METHOD(m_class, m_method) (GDMonoCache::cached_data.method_##m_class##_##m_method)
 #define CACHED_METHOD_THUNK(m_class, m_method) (GDMonoCache::cached_data.methodthunk_##m_class##_##m_method)
diff --git a/modules/mono/mono_gd/gd_mono_class.cpp b/modules/mono/mono_gd/gd_mono_class.cpp
index 51c5aa3542..24b46d2ce8 100644
--- a/modules/mono/mono_gd/gd_mono_class.cpp
+++ b/modules/mono/mono_gd/gd_mono_class.cpp
@@ -462,18 +462,11 @@ const Vector<GDMonoClass *> &GDMonoClass::get_all_delegates() {
 		return delegates_list;
 	}
 
-	// If the class is generic we must use the generic type definition.
-	MonoClass *klass = mono_class;
-	if (mono_type_get_type(get_mono_type()) == MONO_TYPE_GENERICINST) {
-		MonoReflectionType *reftype = mono_type_get_object(mono_domain_get(), get_mono_type());
-		GDMonoUtils::Marshal::get_generic_type_definition(reftype, &reftype);
-		MonoType *type = mono_reflection_type_get_type(reftype);
-		klass = mono_class_from_mono_type(type);
-	}
+	// NOTE: Temporarily reverted d28be4d5808947606b8189ae1b2900b8fd2925cf, while we move code to C#
 
 	void *iter = nullptr;
 	MonoClass *raw_class = nullptr;
-	while ((raw_class = mono_class_get_nested_types(klass, &iter)) != nullptr) {
+	while ((raw_class = mono_class_get_nested_types(mono_class, &iter)) != nullptr) {
 		if (mono_class_is_delegate(raw_class)) {
 			StringName name = String::utf8(mono_class_get_name(raw_class));
 
diff --git a/modules/mono/mono_gd/gd_mono_field.cpp b/modules/mono/mono_gd/gd_mono_field.cpp
index cb025fc67a..6beeca79c3 100644
--- a/modules/mono/mono_gd/gd_mono_field.cpp
+++ b/modules/mono/mono_gd/gd_mono_field.cpp
@@ -46,421 +46,14 @@ void GDMonoField::set_value_raw(MonoObject *p_object, void *p_ptr) {
 }
 
 void GDMonoField::set_value_from_variant(MonoObject *p_object, const Variant &p_value) {
-	switch (type.type_encoding) {
-		case MONO_TYPE_BOOLEAN: {
-			MonoBoolean val = p_value.operator bool();
-			mono_field_set_value(p_object, mono_field, &val);
-		} break;
-		case MONO_TYPE_CHAR: {
-			int16_t val = p_value.operator unsigned short();
-			mono_field_set_value(p_object, mono_field, &val);
-		} break;
-		case MONO_TYPE_I1: {
-			int8_t val = p_value.operator signed char();
-			mono_field_set_value(p_object, mono_field, &val);
-		} break;
-		case MONO_TYPE_I2: {
-			int16_t val = p_value.operator signed short();
-			mono_field_set_value(p_object, mono_field, &val);
-		} break;
-		case MONO_TYPE_I4: {
-			int32_t val = p_value.operator signed int();
-			mono_field_set_value(p_object, mono_field, &val);
-		} break;
-		case MONO_TYPE_I8: {
-			int64_t val = p_value.operator int64_t();
-			mono_field_set_value(p_object, mono_field, &val);
-		} break;
-		case MONO_TYPE_U1: {
-			uint8_t val = p_value.operator unsigned char();
-			mono_field_set_value(p_object, mono_field, &val);
-		} break;
-		case MONO_TYPE_U2: {
-			uint16_t val = p_value.operator unsigned short();
-			mono_field_set_value(p_object, mono_field, &val);
-		} break;
-		case MONO_TYPE_U4: {
-			uint32_t val = p_value.operator unsigned int();
-			mono_field_set_value(p_object, mono_field, &val);
-		} break;
-		case MONO_TYPE_U8: {
-			uint64_t val = p_value.operator uint64_t();
-			mono_field_set_value(p_object, mono_field, &val);
-		} break;
-		case MONO_TYPE_R4: {
-			float val = p_value.operator float();
-			mono_field_set_value(p_object, mono_field, &val);
-		} break;
-		case MONO_TYPE_R8: {
-			double val = p_value.operator double();
-			mono_field_set_value(p_object, mono_field, &val);
-		} break;
-		case MONO_TYPE_VALUETYPE: {
-			GDMonoClass *tclass = type.type_class;
+	MonoReflectionField *reflfield = mono_field_get_object(mono_domain_get(), owner->get_mono_ptr(), mono_field);
 
-			if (tclass == CACHED_CLASS(Vector2)) {
-				GDMonoMarshal::M_Vector2 from = MARSHALLED_OUT(Vector2, p_value.operator ::Vector2());
-				mono_field_set_value(p_object, mono_field, &from);
-				break;
-			}
+	MonoException *exc = nullptr;
+	CACHED_METHOD_THUNK(Marshaling, SetFieldValue)
+			.invoke(reflfield, p_object, &p_value, &exc);
 
-			if (tclass == CACHED_CLASS(Vector2i)) {
-				GDMonoMarshal::M_Vector2i from = MARSHALLED_OUT(Vector2i, p_value.operator ::Vector2i());
-				mono_field_set_value(p_object, mono_field, &from);
-				break;
-			}
-
-			if (tclass == CACHED_CLASS(Rect2)) {
-				GDMonoMarshal::M_Rect2 from = MARSHALLED_OUT(Rect2, p_value.operator ::Rect2());
-				mono_field_set_value(p_object, mono_field, &from);
-				break;
-			}
-
-			if (tclass == CACHED_CLASS(Rect2i)) {
-				GDMonoMarshal::M_Rect2i from = MARSHALLED_OUT(Rect2i, p_value.operator ::Rect2i());
-				mono_field_set_value(p_object, mono_field, &from);
-				break;
-			}
-
-			if (tclass == CACHED_CLASS(Transform2D)) {
-				GDMonoMarshal::M_Transform2D from = MARSHALLED_OUT(Transform2D, p_value.operator ::Transform2D());
-				mono_field_set_value(p_object, mono_field, &from);
-				break;
-			}
-
-			if (tclass == CACHED_CLASS(Vector3)) {
-				GDMonoMarshal::M_Vector3 from = MARSHALLED_OUT(Vector3, p_value.operator ::Vector3());
-				mono_field_set_value(p_object, mono_field, &from);
-				break;
-			}
-
-			if (tclass == CACHED_CLASS(Vector3i)) {
-				GDMonoMarshal::M_Vector3i from = MARSHALLED_OUT(Vector3i, p_value.operator ::Vector3i());
-				mono_field_set_value(p_object, mono_field, &from);
-				break;
-			}
-
-			if (tclass == CACHED_CLASS(Vector4)) {
-				GDMonoMarshal::M_Vector4 from = MARSHALLED_OUT(Vector4, p_value.operator ::Vector4());
-				mono_field_set_value(p_object, mono_field, &from);
-				break;
-			}
-
-			if (tclass == CACHED_CLASS(Vector4i)) {
-				GDMonoMarshal::M_Vector4i from = MARSHALLED_OUT(Vector4i, p_value.operator ::Vector4i());
-				mono_field_set_value(p_object, mono_field, &from);
-				break;
-			}
-
-			if (tclass == CACHED_CLASS(Basis)) {
-				GDMonoMarshal::M_Basis from = MARSHALLED_OUT(Basis, p_value.operator ::Basis());
-				mono_field_set_value(p_object, mono_field, &from);
-				break;
-			}
-
-			if (tclass == CACHED_CLASS(Quaternion)) {
-				GDMonoMarshal::M_Quaternion from = MARSHALLED_OUT(Quaternion, p_value.operator ::Quaternion());
-				mono_field_set_value(p_object, mono_field, &from);
-				break;
-			}
-
-			if (tclass == CACHED_CLASS(Transform3D)) {
-				GDMonoMarshal::M_Transform3D from = MARSHALLED_OUT(Transform3D, p_value.operator ::Transform3D());
-				mono_field_set_value(p_object, mono_field, &from);
-				break;
-			}
-
-			if (tclass == CACHED_CLASS(Projection)) {
-				GDMonoMarshal::M_Projection from = MARSHALLED_OUT(Projection, p_value.operator ::Projection());
-				mono_field_set_value(p_object, mono_field, &from);
-				break;
-			}
-
-			if (tclass == CACHED_CLASS(AABB)) {
-				GDMonoMarshal::M_AABB from = MARSHALLED_OUT(AABB, p_value.operator ::AABB());
-				mono_field_set_value(p_object, mono_field, &from);
-				break;
-			}
-
-			if (tclass == CACHED_CLASS(Color)) {
-				GDMonoMarshal::M_Color from = MARSHALLED_OUT(Color, p_value.operator ::Color());
-				mono_field_set_value(p_object, mono_field, &from);
-				break;
-			}
-
-			if (tclass == CACHED_CLASS(Plane)) {
-				GDMonoMarshal::M_Plane from = MARSHALLED_OUT(Plane, p_value.operator ::Plane());
-				mono_field_set_value(p_object, mono_field, &from);
-				break;
-			}
-
-			if (tclass == CACHED_CLASS(Callable)) {
-				GDMonoMarshal::M_Callable val = GDMonoMarshal::callable_to_managed(p_value.operator Callable());
-				mono_field_set_value(p_object, mono_field, &val);
-				break;
-			}
-
-			if (tclass == CACHED_CLASS(SignalInfo)) {
-				GDMonoMarshal::M_SignalInfo val = GDMonoMarshal::signal_info_to_managed(p_value.operator Signal());
-				mono_field_set_value(p_object, mono_field, &val);
-				break;
-			}
-
-			if (mono_class_is_enum(tclass->get_mono_ptr())) {
-				MonoType *enum_basetype = mono_class_enum_basetype(tclass->get_mono_ptr());
-				switch (mono_type_get_type(enum_basetype)) {
-					case MONO_TYPE_BOOLEAN: {
-						MonoBoolean val = p_value.operator bool();
-						mono_field_set_value(p_object, mono_field, &val);
-						break;
-					}
-					case MONO_TYPE_CHAR: {
-						uint16_t val = p_value.operator unsigned short();
-						mono_field_set_value(p_object, mono_field, &val);
-						break;
-					}
-					case MONO_TYPE_I1: {
-						int8_t val = p_value.operator signed char();
-						mono_field_set_value(p_object, mono_field, &val);
-						break;
-					}
-					case MONO_TYPE_I2: {
-						int16_t val = p_value.operator signed short();
-						mono_field_set_value(p_object, mono_field, &val);
-						break;
-					}
-					case MONO_TYPE_I4: {
-						int32_t val = p_value.operator signed int();
-						mono_field_set_value(p_object, mono_field, &val);
-						break;
-					}
-					case MONO_TYPE_I8: {
-						int64_t val = p_value.operator int64_t();
-						mono_field_set_value(p_object, mono_field, &val);
-						break;
-					}
-					case MONO_TYPE_U1: {
-						uint8_t val = p_value.operator unsigned char();
-						mono_field_set_value(p_object, mono_field, &val);
-						break;
-					}
-					case MONO_TYPE_U2: {
-						uint16_t val = p_value.operator unsigned short();
-						mono_field_set_value(p_object, mono_field, &val);
-						break;
-					}
-					case MONO_TYPE_U4: {
-						uint32_t val = p_value.operator unsigned int();
-						mono_field_set_value(p_object, mono_field, &val);
-						break;
-					}
-					case MONO_TYPE_U8: {
-						uint64_t val = p_value.operator uint64_t();
-						mono_field_set_value(p_object, mono_field, &val);
-						break;
-					}
-					default: {
-						ERR_FAIL_MSG("Attempted to convert Variant to a managed enum value of unmarshallable base type.");
-					}
-				}
-
-				break;
-			}
-
-			ERR_FAIL_MSG("Attempted to set the value of a field of unmarshallable type: '" + tclass->get_name() + "'.");
-		} break;
-		case MONO_TYPE_STRING: {
-			if (p_value.get_type() == Variant::NIL) {
-				// Otherwise, Variant -> String would return the string "Null"
-				MonoString *mono_string = nullptr;
-				mono_field_set_value(p_object, mono_field, mono_string);
-			} else {
-				MonoString *mono_string = GDMonoMarshal::mono_string_from_godot(p_value);
-				mono_field_set_value(p_object, mono_field, mono_string);
-			}
-		} break;
-		case MONO_TYPE_ARRAY:
-		case MONO_TYPE_SZARRAY: {
-			MonoArray *managed = GDMonoMarshal::variant_to_mono_array(p_value, type.type_class);
-			if (likely(managed != nullptr)) {
-				mono_field_set_value(p_object, mono_field, managed);
-			}
-		} break;
-		case MONO_TYPE_CLASS: {
-			MonoObject *managed = GDMonoMarshal::variant_to_mono_object_of_class(p_value, type.type_class);
-			if (likely(managed != nullptr)) {
-				mono_field_set_value(p_object, mono_field, managed);
-			}
-		} break;
-		case MONO_TYPE_GENERICINST: {
-			MonoObject *managed = GDMonoMarshal::variant_to_mono_object_of_genericinst(p_value, type.type_class);
-			if (likely(managed != nullptr)) {
-				mono_field_set_value(p_object, mono_field, managed);
-			}
-		} break;
-		case MONO_TYPE_OBJECT: {
-			// Variant
-			switch (p_value.get_type()) {
-				case Variant::BOOL: {
-					MonoBoolean val = p_value.operator bool();
-					mono_field_set_value(p_object, mono_field, &val);
-				} break;
-				case Variant::INT: {
-					int32_t val = p_value.operator signed int();
-					mono_field_set_value(p_object, mono_field, &val);
-				} break;
-				case Variant::FLOAT: {
-#ifdef REAL_T_IS_DOUBLE
-					double val = p_value.operator double();
-					mono_field_set_value(p_object, mono_field, &val);
-#else
-					float val = p_value.operator float();
-					mono_field_set_value(p_object, mono_field, &val);
-#endif
-				} break;
-				case Variant::STRING: {
-					MonoString *mono_string = GDMonoMarshal::mono_string_from_godot(p_value);
-					mono_field_set_value(p_object, mono_field, mono_string);
-				} break;
-				case Variant::VECTOR2: {
-					GDMonoMarshal::M_Vector2 from = MARSHALLED_OUT(Vector2, p_value.operator ::Vector2());
-					mono_field_set_value(p_object, mono_field, &from);
-				} break;
-				case Variant::VECTOR2I: {
-					GDMonoMarshal::M_Vector2i from = MARSHALLED_OUT(Vector2i, p_value.operator ::Vector2i());
-					mono_field_set_value(p_object, mono_field, &from);
-				} break;
-				case Variant::RECT2: {
-					GDMonoMarshal::M_Rect2 from = MARSHALLED_OUT(Rect2, p_value.operator ::Rect2());
-					mono_field_set_value(p_object, mono_field, &from);
-				} break;
-				case Variant::RECT2I: {
-					GDMonoMarshal::M_Rect2i from = MARSHALLED_OUT(Rect2i, p_value.operator ::Rect2i());
-					mono_field_set_value(p_object, mono_field, &from);
-				} break;
-				case Variant::VECTOR3: {
-					GDMonoMarshal::M_Vector3 from = MARSHALLED_OUT(Vector3, p_value.operator ::Vector3());
-					mono_field_set_value(p_object, mono_field, &from);
-				} break;
-				case Variant::VECTOR3I: {
-					GDMonoMarshal::M_Vector3i from = MARSHALLED_OUT(Vector3i, p_value.operator ::Vector3i());
-					mono_field_set_value(p_object, mono_field, &from);
-				} break;
-				case Variant::VECTOR4: {
-					GDMonoMarshal::M_Vector4 from = MARSHALLED_OUT(Vector4, p_value.operator ::Vector4());
-					mono_field_set_value(p_object, mono_field, &from);
-				} break;
-				case Variant::VECTOR4I: {
-					GDMonoMarshal::M_Vector4i from = MARSHALLED_OUT(Vector4i, p_value.operator ::Vector4i());
-					mono_field_set_value(p_object, mono_field, &from);
-				} break;
-				case Variant::TRANSFORM2D: {
-					GDMonoMarshal::M_Transform2D from = MARSHALLED_OUT(Transform2D, p_value.operator ::Transform2D());
-					mono_field_set_value(p_object, mono_field, &from);
-				} break;
-				case Variant::PLANE: {
-					GDMonoMarshal::M_Plane from = MARSHALLED_OUT(Plane, p_value.operator ::Plane());
-					mono_field_set_value(p_object, mono_field, &from);
-				} break;
-				case Variant::QUATERNION: {
-					GDMonoMarshal::M_Quaternion from = MARSHALLED_OUT(Quaternion, p_value.operator ::Quaternion());
-					mono_field_set_value(p_object, mono_field, &from);
-				} break;
-				case Variant::AABB: {
-					GDMonoMarshal::M_AABB from = MARSHALLED_OUT(AABB, p_value.operator ::AABB());
-					mono_field_set_value(p_object, mono_field, &from);
-				} break;
-				case Variant::BASIS: {
-					GDMonoMarshal::M_Basis from = MARSHALLED_OUT(Basis, p_value.operator ::Basis());
-					mono_field_set_value(p_object, mono_field, &from);
-				} break;
-				case Variant::TRANSFORM3D: {
-					GDMonoMarshal::M_Transform3D from = MARSHALLED_OUT(Transform3D, p_value.operator ::Transform3D());
-					mono_field_set_value(p_object, mono_field, &from);
-				} break;
-				case Variant::PROJECTION: {
-					GDMonoMarshal::M_Projection from = MARSHALLED_OUT(Projection, p_value.operator ::Projection());
-					mono_field_set_value(p_object, mono_field, &from);
-				} break;
-				case Variant::COLOR: {
-					GDMonoMarshal::M_Color from = MARSHALLED_OUT(Color, p_value.operator ::Color());
-					mono_field_set_value(p_object, mono_field, &from);
-				} break;
-				case Variant::STRING_NAME: {
-					MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator StringName());
-					mono_field_set_value(p_object, mono_field, managed);
-				} break;
-				case Variant::NODE_PATH: {
-					MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator NodePath());
-					mono_field_set_value(p_object, mono_field, managed);
-				} break;
-				case Variant::RID: {
-					MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator ::RID());
-					mono_field_set_value(p_object, mono_field, managed);
-				} break;
-				case Variant::OBJECT: {
-					MonoObject *managed = GDMonoUtils::unmanaged_get_managed(p_value.operator Object *());
-					mono_field_set_value(p_object, mono_field, managed);
-				} break;
-				case Variant::CALLABLE: {
-					GDMonoMarshal::M_Callable val = GDMonoMarshal::callable_to_managed(p_value.operator Callable());
-					mono_field_set_value(p_object, mono_field, &val);
-				} break;
-				case Variant::SIGNAL: {
-					GDMonoMarshal::M_SignalInfo val = GDMonoMarshal::signal_info_to_managed(p_value.operator Signal());
-					mono_field_set_value(p_object, mono_field, &val);
-				} break;
-				case Variant::DICTIONARY: {
-					MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator Dictionary(), CACHED_CLASS(Dictionary));
-					mono_field_set_value(p_object, mono_field, managed);
-				} break;
-				case Variant::ARRAY: {
-					MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator Array(), CACHED_CLASS(Array));
-					mono_field_set_value(p_object, mono_field, managed);
-				} break;
-				case Variant::PACKED_BYTE_ARRAY: {
-					MonoArray *managed = GDMonoMarshal::PackedByteArray_to_mono_array(p_value.operator ::PackedByteArray());
-					mono_field_set_value(p_object, mono_field, managed);
-				} break;
-				case Variant::PACKED_INT32_ARRAY: {
-					MonoArray *managed = GDMonoMarshal::PackedInt32Array_to_mono_array(p_value.operator ::PackedInt32Array());
-					mono_field_set_value(p_object, mono_field, managed);
-				} break;
-				case Variant::PACKED_INT64_ARRAY: {
-					MonoArray *managed = GDMonoMarshal::PackedInt64Array_to_mono_array(p_value.operator ::PackedInt64Array());
-					mono_field_set_value(p_object, mono_field, managed);
-				} break;
-				case Variant::PACKED_FLOAT32_ARRAY: {
-					MonoArray *managed = GDMonoMarshal::PackedFloat32Array_to_mono_array(p_value.operator ::PackedFloat32Array());
-					mono_field_set_value(p_object, mono_field, managed);
-				} break;
-				case Variant::PACKED_FLOAT64_ARRAY: {
-					MonoArray *managed = GDMonoMarshal::PackedFloat64Array_to_mono_array(p_value.operator ::PackedFloat64Array());
-					mono_field_set_value(p_object, mono_field, managed);
-				} break;
-				case Variant::PACKED_STRING_ARRAY: {
-					MonoArray *managed = GDMonoMarshal::PackedStringArray_to_mono_array(p_value.operator ::PackedStringArray());
-					mono_field_set_value(p_object, mono_field, managed);
-				} break;
-				case Variant::PACKED_VECTOR2_ARRAY: {
-					MonoArray *managed = GDMonoMarshal::PackedVector2Array_to_mono_array(p_value.operator ::PackedVector2Array());
-					mono_field_set_value(p_object, mono_field, managed);
-				} break;
-				case Variant::PACKED_VECTOR3_ARRAY: {
-					MonoArray *managed = GDMonoMarshal::PackedVector3Array_to_mono_array(p_value.operator ::PackedVector3Array());
-					mono_field_set_value(p_object, mono_field, managed);
-				} break;
-				case Variant::PACKED_COLOR_ARRAY: {
-					MonoArray *managed = GDMonoMarshal::PackedColorArray_to_mono_array(p_value.operator ::PackedColorArray());
-					mono_field_set_value(p_object, mono_field, managed);
-				} break;
-				default:
-					break;
-			}
-		} break;
-		default: {
-			ERR_PRINT("Attempted to set the value of a field of unexpected type encoding: " + itos(type.type_encoding) + ".");
-		} break;
+	if (exc) {
+		GDMonoUtils::debug_print_unhandled_exception(exc);
 	}
 }
 
diff --git a/modules/mono/mono_gd/gd_mono_marshal.cpp b/modules/mono/mono_gd/gd_mono_marshal.cpp
index a860442764..ef6a008a25 100644
--- a/modules/mono/mono_gd/gd_mono_marshal.cpp
+++ b/modules/mono/mono_gd/gd_mono_marshal.cpp
@@ -5,8 +5,8 @@
 /*                           GODOT ENGINE                                */
 /*                      https://godotengine.org                          */
 /*************************************************************************/
-/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2021 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       */
@@ -37,1282 +37,104 @@
 
 namespace GDMonoMarshal {
 
-Variant::Type managed_to_variant_type(const ManagedType &p_type, bool *r_nil_is_variant) {
-	switch (p_type.type_encoding) {
-		case MONO_TYPE_BOOLEAN:
-			return Variant::BOOL;
-
-		case MONO_TYPE_I1:
-			return Variant::INT;
-		case MONO_TYPE_I2:
-			return Variant::INT;
-		case MONO_TYPE_I4:
-			return Variant::INT;
-		case MONO_TYPE_I8:
-			return Variant::INT;
-
-		case MONO_TYPE_U1:
-			return Variant::INT;
-		case MONO_TYPE_U2:
-			return Variant::INT;
-		case MONO_TYPE_U4:
-			return Variant::INT;
-		case MONO_TYPE_U8:
-			return Variant::INT;
-
-		case MONO_TYPE_R4:
-			return Variant::FLOAT;
-		case MONO_TYPE_R8:
-			return Variant::FLOAT;
-
-		case MONO_TYPE_STRING: {
-			return Variant::STRING;
-		} break;
-
-		case MONO_TYPE_VALUETYPE: {
-			GDMonoClass *vtclass = p_type.type_class;
-
-			if (vtclass == CACHED_CLASS(Vector2)) {
-				return Variant::VECTOR2;
-			}
-
-			if (vtclass == CACHED_CLASS(Vector2i)) {
-				return Variant::VECTOR2I;
-			}
-
-			if (vtclass == CACHED_CLASS(Rect2)) {
-				return Variant::RECT2;
-			}
-
-			if (vtclass == CACHED_CLASS(Rect2i)) {
-				return Variant::RECT2I;
-			}
-
-			if (vtclass == CACHED_CLASS(Transform2D)) {
-				return Variant::TRANSFORM2D;
-			}
-
-			if (vtclass == CACHED_CLASS(Vector3)) {
-				return Variant::VECTOR3;
-			}
-
-			if (vtclass == CACHED_CLASS(Vector3i)) {
-				return Variant::VECTOR3I;
-			}
-			if (vtclass == CACHED_CLASS(Vector4)) {
-				return Variant::VECTOR4;
-			}
-
-			if (vtclass == CACHED_CLASS(Vector4i)) {
-				return Variant::VECTOR4I;
-			}
-
-			if (vtclass == CACHED_CLASS(Basis)) {
-				return Variant::BASIS;
-			}
-
-			if (vtclass == CACHED_CLASS(Quaternion)) {
-				return Variant::QUATERNION;
-			}
-
-			if (vtclass == CACHED_CLASS(Transform3D)) {
-				return Variant::TRANSFORM3D;
-			}
-			if (vtclass == CACHED_CLASS(Projection)) {
-				return Variant::PROJECTION;
-			}
-			if (vtclass == CACHED_CLASS(AABB)) {
-				return Variant::AABB;
-			}
-
-			if (vtclass == CACHED_CLASS(Color)) {
-				return Variant::COLOR;
-			}
-
-			if (vtclass == CACHED_CLASS(Plane)) {
-				return Variant::PLANE;
-			}
-
-			if (vtclass == CACHED_CLASS(Callable)) {
-				return Variant::CALLABLE;
-			}
-
-			if (vtclass == CACHED_CLASS(SignalInfo)) {
-				return Variant::SIGNAL;
-			}
-
-			if (mono_class_is_enum(vtclass->get_mono_ptr())) {
-				return Variant::INT;
-			}
-		} break;
-
-		case MONO_TYPE_ARRAY:
-		case MONO_TYPE_SZARRAY: {
-			MonoClass *elem_class = mono_class_get_element_class(p_type.type_class->get_mono_ptr());
-
-			if (elem_class == CACHED_CLASS_RAW(MonoObject)) {
-				return Variant::ARRAY;
-			}
-
-			if (elem_class == CACHED_CLASS_RAW(uint8_t)) {
-				return Variant::PACKED_BYTE_ARRAY;
-			}
-
-			if (elem_class == CACHED_CLASS_RAW(int32_t)) {
-				return Variant::PACKED_INT32_ARRAY;
-			}
-
-			if (elem_class == CACHED_CLASS_RAW(int64_t)) {
-				return Variant::PACKED_INT64_ARRAY;
-			}
-
-			if (elem_class == CACHED_CLASS_RAW(float)) {
-				return Variant::PACKED_FLOAT32_ARRAY;
-			}
-
-			if (elem_class == CACHED_CLASS_RAW(double)) {
-				return Variant::PACKED_FLOAT64_ARRAY;
-			}
-
-			if (elem_class == CACHED_CLASS_RAW(String)) {
-				return Variant::PACKED_STRING_ARRAY;
-			}
-
-			if (elem_class == CACHED_CLASS_RAW(Vector2)) {
-				return Variant::PACKED_VECTOR2_ARRAY;
-			}
-
-			if (elem_class == CACHED_CLASS_RAW(Vector3)) {
-				return Variant::PACKED_VECTOR3_ARRAY;
-			}
-
-			if (elem_class == CACHED_CLASS_RAW(Color)) {
-				return Variant::PACKED_COLOR_ARRAY;
-			}
-
-			if (elem_class == CACHED_CLASS_RAW(StringName)) {
-				return Variant::ARRAY;
-			}
-
-			if (elem_class == CACHED_CLASS_RAW(NodePath)) {
-				return Variant::ARRAY;
-			}
-
-			if (elem_class == CACHED_CLASS_RAW(RID)) {
-				return Variant::ARRAY;
-			}
-
-			if (mono_class_is_enum(elem_class)) {
-				return Variant::ARRAY;
-			}
-
-			GDMonoClass *array_type_class = GDMono::get_singleton()->get_class(elem_class);
-			if (CACHED_CLASS(GodotObject)->is_assignable_from(array_type_class)) {
-				return Variant::ARRAY;
-			}
-		} break;
-
-		case MONO_TYPE_CLASS: {
-			GDMonoClass *type_class = p_type.type_class;
+// TODO: Those are just temporary until the code that needs them is moved to C#
 
-			// GodotObject
-			if (CACHED_CLASS(GodotObject)->is_assignable_from(type_class)) {
-				return Variant::OBJECT;
-			}
-
-			if (CACHED_CLASS(StringName) == type_class) {
-				return Variant::STRING_NAME;
-			}
-
-			if (CACHED_CLASS(NodePath) == type_class) {
-				return Variant::NODE_PATH;
-			}
-
-			if (CACHED_CLASS(RID) == type_class) {
-				return Variant::RID;
-			}
-
-			if (CACHED_CLASS(Dictionary) == type_class) {
-				return Variant::DICTIONARY;
-			}
-
-			if (CACHED_CLASS(Array) == type_class) {
-				return Variant::ARRAY;
-			}
-
-			// IDictionary
-			if (p_type.type_class == CACHED_CLASS(System_Collections_IDictionary)) {
-				return Variant::DICTIONARY;
-			}
-
-			// ICollection or IEnumerable
-			if (p_type.type_class == CACHED_CLASS(System_Collections_ICollection) ||
-					p_type.type_class == CACHED_CLASS(System_Collections_IEnumerable)) {
-				return Variant::ARRAY;
-			}
-		} break;
-
-		case MONO_TYPE_OBJECT: {
-			if (r_nil_is_variant) {
-				*r_nil_is_variant = true;
-			}
-			return Variant::NIL;
-		} break;
-
-		case MONO_TYPE_GENERICINST: {
-			MonoReflectionType *reftype = mono_type_get_object(mono_domain_get(), p_type.type_class->get_mono_type());
-
-			// Godot.Collections.Dictionary<TKey, TValue>
-			if (GDMonoUtils::Marshal::type_is_generic_dictionary(reftype)) {
-				return Variant::DICTIONARY;
-			}
-
-			// Godot.Collections.Array<T>
-			if (GDMonoUtils::Marshal::type_is_generic_array(reftype)) {
-				return Variant::ARRAY;
-			}
-
-			// System.Collections.Generic.Dictionary<TKey, TValue>
-			if (GDMonoUtils::Marshal::type_is_system_generic_dictionary(reftype)) {
-				return Variant::DICTIONARY;
-			}
-
-			// System.Collections.Generic.List<T>
-			if (GDMonoUtils::Marshal::type_is_system_generic_list(reftype)) {
-				return Variant::ARRAY;
-			}
-
-			// IDictionary<TKey, TValue>
-			if (GDMonoUtils::Marshal::type_is_generic_idictionary(reftype)) {
-				return Variant::DICTIONARY;
-			}
+Variant::Type managed_to_variant_type(const ManagedType &p_type, bool *r_nil_is_variant) {
+	if (p_type.type_encoding == MONO_TYPE_VOID) {
+		return Variant::NIL;
+	}
 
-			// ICollection<T> or IEnumerable<T>
-			if (GDMonoUtils::Marshal::type_is_generic_icollection(reftype) || GDMonoUtils::Marshal::type_is_generic_ienumerable(reftype)) {
-				return Variant::ARRAY;
-			}
+	MonoReflectionType *refltype = mono_type_get_object(mono_domain_get(), p_type.type_class->get_mono_type());
+	MonoBoolean nil_is_variant = false;
 
-			// GodotObject
-			GDMonoClass *type_class = p_type.type_class;
-			if (CACHED_CLASS(GodotObject)->is_assignable_from(type_class)) {
-				return Variant::OBJECT;
-			}
-		} break;
+	MonoException *exc = nullptr;
+	int32_t ret = CACHED_METHOD_THUNK(Marshaling, managed_to_variant_type)
+						  .invoke(refltype, &nil_is_variant, &exc);
 
-		default: {
-		} break;
+	if (exc) {
+		GDMonoUtils::debug_print_unhandled_exception(exc);
+		return Variant::NIL;
 	}
 
 	if (r_nil_is_variant) {
-		*r_nil_is_variant = false;
+		*r_nil_is_variant = (bool)nil_is_variant;
 	}
 
-	// Unknown
-	return Variant::NIL;
+	return (Variant::Type)ret;
 }
 
 bool try_get_array_element_type(const ManagedType &p_array_type, ManagedType &r_elem_type) {
-	switch (p_array_type.type_encoding) {
-		case MONO_TYPE_ARRAY:
-		case MONO_TYPE_SZARRAY: {
-			MonoClass *elem_class = mono_class_get_element_class(p_array_type.type_class->get_mono_ptr());
-			r_elem_type = ManagedType::from_class(elem_class);
-			return true;
-		} break;
-		case MONO_TYPE_GENERICINST: {
-			MonoReflectionType *array_reftype = mono_type_get_object(mono_domain_get(), p_array_type.type_class->get_mono_type());
-
-			if (GDMonoUtils::Marshal::type_is_generic_array(array_reftype) ||
-					GDMonoUtils::Marshal::type_is_system_generic_list(array_reftype) ||
-					GDMonoUtils::Marshal::type_is_generic_icollection(array_reftype) ||
-					GDMonoUtils::Marshal::type_is_generic_ienumerable(array_reftype)) {
-				MonoReflectionType *elem_reftype;
-
-				GDMonoUtils::Marshal::array_get_element_type(array_reftype, &elem_reftype);
-
-				r_elem_type = ManagedType::from_reftype(elem_reftype);
-				return true;
-			}
-		} break;
-		default: {
-		} break;
-	}
-
-	return false;
-}
-
-MonoString *variant_to_mono_string(const Variant &p_var) {
-	if (p_var.get_type() == Variant::NIL) {
-		return nullptr; // Otherwise, Variant -> String would return the string "Null"
-	}
-	return mono_string_from_godot(p_var.operator String());
-}
-
-MonoArray *variant_to_mono_array(const Variant &p_var, GDMonoClass *p_type_class) {
-	MonoArrayType *array_type = mono_type_get_array_type(p_type_class->get_mono_type());
-
-	if (array_type->eklass == CACHED_CLASS_RAW(MonoObject)) {
-		return Array_to_mono_array(p_var.operator Array());
-	}
-
-	if (array_type->eklass == CACHED_CLASS_RAW(uint8_t)) {
-		return PackedByteArray_to_mono_array(p_var.operator PackedByteArray());
-	}
-
-	if (array_type->eklass == CACHED_CLASS_RAW(int32_t)) {
-		return PackedInt32Array_to_mono_array(p_var.operator PackedInt32Array());
-	}
-
-	if (array_type->eklass == CACHED_CLASS_RAW(int64_t)) {
-		return PackedInt64Array_to_mono_array(p_var.operator PackedInt64Array());
-	}
-
-	if (array_type->eklass == CACHED_CLASS_RAW(float)) {
-		return PackedFloat32Array_to_mono_array(p_var.operator PackedFloat32Array());
-	}
-
-	if (array_type->eklass == CACHED_CLASS_RAW(double)) {
-		return PackedFloat64Array_to_mono_array(p_var.operator PackedFloat64Array());
-	}
-
-	if (array_type->eklass == CACHED_CLASS_RAW(String)) {
-		return PackedStringArray_to_mono_array(p_var.operator PackedStringArray());
-	}
-
-	if (array_type->eklass == CACHED_CLASS_RAW(Vector2)) {
-		return PackedVector2Array_to_mono_array(p_var.operator PackedVector2Array());
-	}
-
-	if (array_type->eklass == CACHED_CLASS_RAW(Vector3)) {
-		return PackedVector3Array_to_mono_array(p_var.operator PackedVector3Array());
-	}
-
-	if (array_type->eklass == CACHED_CLASS_RAW(Color)) {
-		return PackedColorArray_to_mono_array(p_var.operator PackedColorArray());
-	}
-
-	if (array_type->eklass == CACHED_CLASS_RAW(StringName)) {
-		return Array_to_mono_array(p_var.operator Array());
-	}
-
-	if (array_type->eklass == CACHED_CLASS_RAW(NodePath)) {
-		return Array_to_mono_array(p_var.operator Array());
-	}
-
-	if (array_type->eklass == CACHED_CLASS_RAW(RID)) {
-		return Array_to_mono_array(p_var.operator Array());
-	}
-
-	if (mono_class_is_assignable_from(CACHED_CLASS(GodotObject)->get_mono_ptr(), array_type->eklass)) {
-		return Array_to_mono_array(p_var.operator ::Array(), array_type->eklass);
-	}
+	MonoReflectionType *array_refltype = mono_type_get_object(mono_domain_get(), p_array_type.type_class->get_mono_type());
+	MonoReflectionType *elem_refltype = nullptr;
 
-	ERR_FAIL_V_MSG(nullptr, "Attempted to convert Variant to array of unsupported element type:" + GDMonoClass::get_full_name(array_type->eklass) + "'.");
-}
-
-MonoObject *variant_to_mono_object_of_class(const Variant &p_var, GDMonoClass *p_type_class) {
-	// GodotObject
-	if (CACHED_CLASS(GodotObject)->is_assignable_from(p_type_class)) {
-		return GDMonoUtils::unmanaged_get_managed(p_var.operator Object *());
-	}
-
-	if (CACHED_CLASS(StringName) == p_type_class) {
-		return GDMonoUtils::create_managed_from(p_var.operator StringName());
-	}
-
-	if (CACHED_CLASS(NodePath) == p_type_class) {
-		return GDMonoUtils::create_managed_from(p_var.operator NodePath());
-	}
-
-	if (CACHED_CLASS(RID) == p_type_class) {
-		return GDMonoUtils::create_managed_from(p_var.operator ::RID());
-	}
-
-	// Godot.Collections.Dictionary or IDictionary
-	if (CACHED_CLASS(Dictionary) == p_type_class || CACHED_CLASS(System_Collections_IDictionary) == p_type_class) {
-		return GDMonoUtils::create_managed_from(p_var.operator Dictionary(), CACHED_CLASS(Dictionary));
-	}
+	MonoException *exc = nullptr;
+	MonoBoolean ret = CACHED_METHOD_THUNK(Marshaling, try_get_array_element_type)
+							  .invoke(array_refltype, &elem_refltype, &exc);
 
-	// Godot.Collections.Array or ICollection or IEnumerable
-	if (CACHED_CLASS(Array) == p_type_class ||
-			CACHED_CLASS(System_Collections_ICollection) == p_type_class ||
-			CACHED_CLASS(System_Collections_IEnumerable) == p_type_class) {
-		return GDMonoUtils::create_managed_from(p_var.operator Array(), CACHED_CLASS(Array));
+	if (exc) {
+		GDMonoUtils::debug_print_unhandled_exception(exc);
+		return Variant::NIL;
 	}
 
-	ERR_FAIL_V_MSG(nullptr, "Attempted to convert Variant to unsupported type: '" + p_type_class->get_full_name() + "'.");
+	r_elem_type = ManagedType::from_reftype(elem_refltype);
+	return ret;
 }
 
-MonoObject *variant_to_mono_object_of_genericinst(const Variant &p_var, GDMonoClass *p_type_class) {
-	MonoReflectionType *reftype = mono_type_get_object(mono_domain_get(), p_type_class->get_mono_type());
-
-	// Godot.Collections.Dictionary<TKey, TValue>
-	if (GDMonoUtils::Marshal::type_is_generic_dictionary(reftype)) {
-		return GDMonoUtils::create_managed_from(p_var.operator Dictionary(), p_type_class);
-	}
-
-	// Godot.Collections.Array<T>
-	if (GDMonoUtils::Marshal::type_is_generic_array(reftype)) {
-		return GDMonoUtils::create_managed_from(p_var.operator Array(), p_type_class);
-	}
-
-	// System.Collections.Generic.Dictionary<TKey, TValue>
-	if (GDMonoUtils::Marshal::type_is_system_generic_dictionary(reftype)) {
-		MonoReflectionType *key_reftype = nullptr;
-		MonoReflectionType *value_reftype = nullptr;
-		GDMonoUtils::Marshal::dictionary_get_key_value_types(reftype, &key_reftype, &value_reftype);
-		return Dictionary_to_system_generic_dict(p_var.operator Dictionary(), p_type_class, key_reftype, value_reftype);
-	}
+MonoObject *variant_to_mono_object_of_type(const Variant &p_var, const ManagedType &p_type) {
+	MonoReflectionType *refltype = mono_type_get_object(mono_domain_get(), p_type.type_class->get_mono_type());
 
-	// System.Collections.Generic.List<T>
-	if (GDMonoUtils::Marshal::type_is_system_generic_list(reftype)) {
-		MonoReflectionType *elem_reftype = nullptr;
-		GDMonoUtils::Marshal::array_get_element_type(reftype, &elem_reftype);
-		return Array_to_system_generic_list(p_var.operator Array(), p_type_class, elem_reftype);
-	}
-
-	// IDictionary<TKey, TValue>
-	if (GDMonoUtils::Marshal::type_is_generic_idictionary(reftype)) {
-		MonoReflectionType *key_reftype;
-		MonoReflectionType *value_reftype;
-		GDMonoUtils::Marshal::dictionary_get_key_value_types(reftype, &key_reftype, &value_reftype);
-		GDMonoClass *godot_dict_class = GDMonoUtils::Marshal::make_generic_dictionary_type(key_reftype, value_reftype);
-
-		return GDMonoUtils::create_managed_from(p_var.operator Dictionary(), godot_dict_class);
-	}
-
-	// ICollection<T> or IEnumerable<T>
-	if (GDMonoUtils::Marshal::type_is_generic_icollection(reftype) || GDMonoUtils::Marshal::type_is_generic_ienumerable(reftype)) {
-		MonoReflectionType *elem_reftype;
-		GDMonoUtils::Marshal::array_get_element_type(reftype, &elem_reftype);
-		GDMonoClass *godot_array_class = GDMonoUtils::Marshal::make_generic_array_type(elem_reftype);
-
-		return GDMonoUtils::create_managed_from(p_var.operator Array(), godot_array_class);
-	}
+	MonoException *exc = nullptr;
+	MonoObject *ret = CACHED_METHOD_THUNK(Marshaling, variant_to_mono_object_of_type)
+							  .invoke(&p_var, refltype, &exc);
 
-	// GodotObject
-	if (CACHED_CLASS(GodotObject)->is_assignable_from(p_type_class)) {
-		return GDMonoUtils::unmanaged_get_managed(p_var.operator Object *());
+	if (exc) {
+		GDMonoUtils::debug_print_unhandled_exception(exc);
+		return nullptr;
 	}
 
-	ERR_FAIL_V_MSG(nullptr, "Attempted to convert Variant to unsupported generic type: '" + p_type_class->get_full_name() + "'.");
+	return ret;
 }
 
 MonoObject *variant_to_mono_object(const Variant &p_var) {
-	// Variant
-	switch (p_var.get_type()) {
-		case Variant::BOOL: {
-			MonoBoolean val = p_var.operator bool();
-			return BOX_BOOLEAN(val);
-		}
-		case Variant::INT: {
-			int64_t val = p_var.operator int64_t();
-			return BOX_INT64(val);
-		}
-		case Variant::FLOAT: {
-#ifdef REAL_T_IS_DOUBLE
-			double val = p_var.operator double();
-			return BOX_DOUBLE(val);
-#else
-			float val = p_var.operator float();
-			return BOX_FLOAT(val);
-#endif
-		}
-		case Variant::STRING:
-			return (MonoObject *)mono_string_from_godot(p_var.operator String());
-		case Variant::VECTOR2: {
-			GDMonoMarshal::M_Vector2 from = MARSHALLED_OUT(Vector2, p_var.operator ::Vector2());
-			return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Vector2), &from);
-		}
-		case Variant::VECTOR2I: {
-			GDMonoMarshal::M_Vector2i from = MARSHALLED_OUT(Vector2i, p_var.operator ::Vector2i());
-			return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Vector2i), &from);
-		}
-		case Variant::RECT2: {
-			GDMonoMarshal::M_Rect2 from = MARSHALLED_OUT(Rect2, p_var.operator ::Rect2());
-			return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Rect2), &from);
-		}
-		case Variant::RECT2I: {
-			GDMonoMarshal::M_Rect2i from = MARSHALLED_OUT(Rect2i, p_var.operator ::Rect2i());
-			return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Rect2i), &from);
-		}
-		case Variant::VECTOR3: {
-			GDMonoMarshal::M_Vector3 from = MARSHALLED_OUT(Vector3, p_var.operator ::Vector3());
-			return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Vector3), &from);
-		}
-		case Variant::VECTOR3I: {
-			GDMonoMarshal::M_Vector3i from = MARSHALLED_OUT(Vector3i, p_var.operator ::Vector3i());
-			return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Vector3i), &from);
-		}
-		case Variant::TRANSFORM2D: {
-			GDMonoMarshal::M_Transform2D from = MARSHALLED_OUT(Transform2D, p_var.operator ::Transform2D());
-			return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Transform2D), &from);
-		}
-		case Variant::VECTOR4: {
-			GDMonoMarshal::M_Vector4 from = MARSHALLED_OUT(Vector4, p_var.operator ::Vector4());
-			return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Vector4), &from);
-		}
-		case Variant::VECTOR4I: {
-			GDMonoMarshal::M_Vector4i from = MARSHALLED_OUT(Vector4i, p_var.operator ::Vector4i());
-			return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Vector4i), &from);
-		}
-		case Variant::PLANE: {
-			GDMonoMarshal::M_Plane from = MARSHALLED_OUT(Plane, p_var.operator ::Plane());
-			return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Plane), &from);
-		}
-		case Variant::QUATERNION: {
-			GDMonoMarshal::M_Quaternion from = MARSHALLED_OUT(Quaternion, p_var.operator ::Quaternion());
-			return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Quaternion), &from);
-		}
-		case Variant::AABB: {
-			GDMonoMarshal::M_AABB from = MARSHALLED_OUT(AABB, p_var.operator ::AABB());
-			return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(AABB), &from);
-		}
-		case Variant::BASIS: {
-			GDMonoMarshal::M_Basis from = MARSHALLED_OUT(Basis, p_var.operator ::Basis());
-			return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Basis), &from);
-		}
-		case Variant::TRANSFORM3D: {
-			GDMonoMarshal::M_Transform3D from = MARSHALLED_OUT(Transform3D, p_var.operator ::Transform3D());
-			return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Transform3D), &from);
-		}
-		case Variant::PROJECTION: {
-			GDMonoMarshal::M_Projection from = MARSHALLED_OUT(Projection, p_var.operator ::Projection());
-			return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Projection), &from);
-		}
-		case Variant::COLOR: {
-			GDMonoMarshal::M_Color from = MARSHALLED_OUT(Color, p_var.operator ::Color());
-			return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Color), &from);
-		}
-		case Variant::STRING_NAME:
-			return GDMonoUtils::create_managed_from(p_var.operator StringName());
-		case Variant::NODE_PATH:
-			return GDMonoUtils::create_managed_from(p_var.operator NodePath());
-		case Variant::RID:
-			return GDMonoUtils::create_managed_from(p_var.operator ::RID());
-		case Variant::OBJECT:
-			return GDMonoUtils::unmanaged_get_managed(p_var.operator Object *());
-		case Variant::CALLABLE: {
-			GDMonoMarshal::M_Callable from = GDMonoMarshal::callable_to_managed(p_var.operator Callable());
-			return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Callable), &from);
-		}
-		case Variant::SIGNAL: {
-			GDMonoMarshal::M_SignalInfo from = GDMonoMarshal::signal_info_to_managed(p_var.operator Signal());
-			return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(SignalInfo), &from);
-		}
-		case Variant::DICTIONARY:
-			return GDMonoUtils::create_managed_from(p_var.operator Dictionary(), CACHED_CLASS(Dictionary));
-		case Variant::ARRAY:
-			return GDMonoUtils::create_managed_from(p_var.operator Array(), CACHED_CLASS(Array));
-		case Variant::PACKED_BYTE_ARRAY:
-			return (MonoObject *)PackedByteArray_to_mono_array(p_var.operator PackedByteArray());
-		case Variant::PACKED_INT32_ARRAY:
-			return (MonoObject *)PackedInt32Array_to_mono_array(p_var.operator PackedInt32Array());
-		case Variant::PACKED_INT64_ARRAY:
-			return (MonoObject *)PackedInt64Array_to_mono_array(p_var.operator PackedInt64Array());
-		case Variant::PACKED_FLOAT32_ARRAY:
-			return (MonoObject *)PackedFloat32Array_to_mono_array(p_var.operator PackedFloat32Array());
-		case Variant::PACKED_FLOAT64_ARRAY:
-			return (MonoObject *)PackedFloat64Array_to_mono_array(p_var.operator PackedFloat64Array());
-		case Variant::PACKED_STRING_ARRAY:
-			return (MonoObject *)PackedStringArray_to_mono_array(p_var.operator PackedStringArray());
-		case Variant::PACKED_VECTOR2_ARRAY:
-			return (MonoObject *)PackedVector2Array_to_mono_array(p_var.operator PackedVector2Array());
-		case Variant::PACKED_VECTOR3_ARRAY:
-			return (MonoObject *)PackedVector3Array_to_mono_array(p_var.operator PackedVector3Array());
-		case Variant::PACKED_COLOR_ARRAY:
-			return (MonoObject *)PackedColorArray_to_mono_array(p_var.operator PackedColorArray());
-		default:
-			return nullptr;
-	}
-}
-
-size_t variant_get_managed_unboxed_size(const ManagedType &p_type) {
-	// This method prints no errors for unsupported types. It's called on all methods, not only
-	// those that end up being invoked with Variant parameters.
-
-	// For MonoObject* we return 0, as it doesn't need to be stored.
-	constexpr size_t zero_for_mono_object = 0;
-
-	switch (p_type.type_encoding) {
-		case MONO_TYPE_BOOLEAN:
-			return sizeof(MonoBoolean);
-		case MONO_TYPE_CHAR:
-			return sizeof(uint16_t);
-		case MONO_TYPE_I1:
-			return sizeof(int8_t);
-		case MONO_TYPE_I2:
-			return sizeof(int16_t);
-		case MONO_TYPE_I4:
-			return sizeof(int32_t);
-		case MONO_TYPE_I8:
-			return sizeof(int64_t);
-		case MONO_TYPE_U1:
-			return sizeof(uint8_t);
-		case MONO_TYPE_U2:
-			return sizeof(uint16_t);
-		case MONO_TYPE_U4:
-			return sizeof(uint32_t);
-		case MONO_TYPE_U8:
-			return sizeof(uint64_t);
-		case MONO_TYPE_R4:
-			return sizeof(float);
-		case MONO_TYPE_R8:
-			return sizeof(double);
-		case MONO_TYPE_VALUETYPE: {
-			GDMonoClass *vtclass = p_type.type_class;
-
-#define RETURN_CHECK_FOR_STRUCT(m_struct)    \
-	if (vtclass == CACHED_CLASS(m_struct)) { \
-		return sizeof(M_##m_struct);         \
-	}
-
-			RETURN_CHECK_FOR_STRUCT(Vector2);
-			RETURN_CHECK_FOR_STRUCT(Vector2i);
-			RETURN_CHECK_FOR_STRUCT(Rect2);
-			RETURN_CHECK_FOR_STRUCT(Rect2i);
-			RETURN_CHECK_FOR_STRUCT(Transform2D);
-			RETURN_CHECK_FOR_STRUCT(Vector3);
-			RETURN_CHECK_FOR_STRUCT(Vector3i);
-			RETURN_CHECK_FOR_STRUCT(Basis);
-			RETURN_CHECK_FOR_STRUCT(Quaternion);
-			RETURN_CHECK_FOR_STRUCT(Transform3D);
-			RETURN_CHECK_FOR_STRUCT(AABB);
-			RETURN_CHECK_FOR_STRUCT(Color);
-			RETURN_CHECK_FOR_STRUCT(Plane);
-			RETURN_CHECK_FOR_STRUCT(Callable);
-			RETURN_CHECK_FOR_STRUCT(SignalInfo);
-
-#undef RETURN_CHECK_FOR_STRUCT
-
-			if (mono_class_is_enum(vtclass->get_mono_ptr())) {
-				MonoType *enum_basetype = mono_class_enum_basetype(vtclass->get_mono_ptr());
-				switch (mono_type_get_type(enum_basetype)) {
-					case MONO_TYPE_BOOLEAN:
-						return sizeof(MonoBoolean);
-					case MONO_TYPE_CHAR:
-						return sizeof(uint16_t);
-					case MONO_TYPE_I1:
-						return sizeof(int8_t);
-					case MONO_TYPE_I2:
-						return sizeof(int16_t);
-					case MONO_TYPE_I4:
-						return sizeof(int32_t);
-					case MONO_TYPE_I8:
-						return sizeof(int64_t);
-					case MONO_TYPE_U1:
-						return sizeof(uint8_t);
-					case MONO_TYPE_U2:
-						return sizeof(uint16_t);
-					case MONO_TYPE_U4:
-						return sizeof(uint32_t);
-					case MONO_TYPE_U8:
-						return sizeof(uint64_t);
-					default: {
-						// Enum with unsupported base type. We return nullptr MonoObject* on error.
-						return zero_for_mono_object;
-					}
-				}
-			}
-
-			// Enum with unsupported value type. We return nullptr MonoObject* on error.
-		} break;
-		case MONO_TYPE_STRING:
-			return zero_for_mono_object;
-		case MONO_TYPE_ARRAY:
-		case MONO_TYPE_SZARRAY:
-		case MONO_TYPE_CLASS:
-		case MONO_TYPE_GENERICINST:
-			return zero_for_mono_object;
-		case MONO_TYPE_OBJECT:
-			return zero_for_mono_object;
-	}
-
-	// Unsupported type encoding. We return nullptr MonoObject* on error.
-	return zero_for_mono_object;
-}
-
-void *variant_to_managed_unboxed(const Variant &p_var, const ManagedType &p_type, void *r_buffer, unsigned int &r_offset) {
-#define RETURN_TYPE_VAL(m_type, m_val)             \
-	*reinterpret_cast<m_type *>(r_buffer) = m_val; \
-	r_offset += sizeof(m_type);                    \
-	return r_buffer;
-
-	switch (p_type.type_encoding) {
-		case MONO_TYPE_BOOLEAN:
-			RETURN_TYPE_VAL(MonoBoolean, (MonoBoolean)p_var.operator bool());
-		case MONO_TYPE_CHAR:
-			RETURN_TYPE_VAL(uint16_t, p_var.operator unsigned short());
-		case MONO_TYPE_I1:
-			RETURN_TYPE_VAL(int8_t, p_var.operator signed char());
-		case MONO_TYPE_I2:
-			RETURN_TYPE_VAL(int16_t, p_var.operator signed short());
-		case MONO_TYPE_I4:
-			RETURN_TYPE_VAL(int32_t, p_var.operator signed int());
-		case MONO_TYPE_I8:
-			RETURN_TYPE_VAL(int64_t, p_var.operator int64_t());
-		case MONO_TYPE_U1:
-			RETURN_TYPE_VAL(uint8_t, p_var.operator unsigned char());
-		case MONO_TYPE_U2:
-			RETURN_TYPE_VAL(uint16_t, p_var.operator unsigned short());
-		case MONO_TYPE_U4:
-			RETURN_TYPE_VAL(uint32_t, p_var.operator unsigned int());
-		case MONO_TYPE_U8:
-			RETURN_TYPE_VAL(uint64_t, p_var.operator uint64_t());
-		case MONO_TYPE_R4:
-			RETURN_TYPE_VAL(float, p_var.operator float());
-		case MONO_TYPE_R8:
-			RETURN_TYPE_VAL(double, p_var.operator double());
-		case MONO_TYPE_VALUETYPE: {
-			GDMonoClass *vtclass = p_type.type_class;
-
-#define RETURN_CHECK_FOR_STRUCT(m_struct)                                                         \
-	if (vtclass == CACHED_CLASS(m_struct)) {                                                      \
-		GDMonoMarshal::M_##m_struct from = MARSHALLED_OUT(m_struct, p_var.operator ::m_struct()); \
-		RETURN_TYPE_VAL(M_##m_struct, from);                                                      \
-	}
-
-			RETURN_CHECK_FOR_STRUCT(Vector2);
-			RETURN_CHECK_FOR_STRUCT(Vector2i);
-			RETURN_CHECK_FOR_STRUCT(Rect2);
-			RETURN_CHECK_FOR_STRUCT(Rect2i);
-			RETURN_CHECK_FOR_STRUCT(Transform2D);
-			RETURN_CHECK_FOR_STRUCT(Vector3);
-			RETURN_CHECK_FOR_STRUCT(Vector3i);
-			RETURN_CHECK_FOR_STRUCT(Basis);
-			RETURN_CHECK_FOR_STRUCT(Quaternion);
-			RETURN_CHECK_FOR_STRUCT(Transform3D);
-			RETURN_CHECK_FOR_STRUCT(AABB);
-			RETURN_CHECK_FOR_STRUCT(Color);
-			RETURN_CHECK_FOR_STRUCT(Plane);
-
-#undef RETURN_CHECK_FOR_STRUCT
-
-			if (vtclass == CACHED_CLASS(Callable)) {
-				GDMonoMarshal::M_Callable from = GDMonoMarshal::callable_to_managed(p_var.operator Callable());
-				RETURN_TYPE_VAL(M_Callable, from);
-			}
-
-			if (vtclass == CACHED_CLASS(SignalInfo)) {
-				GDMonoMarshal::M_SignalInfo from = GDMonoMarshal::signal_info_to_managed(p_var.operator Signal());
-				RETURN_TYPE_VAL(M_SignalInfo, from);
-			}
-
-			if (mono_class_is_enum(vtclass->get_mono_ptr())) {
-				MonoType *enum_basetype = mono_class_enum_basetype(vtclass->get_mono_ptr());
-				switch (mono_type_get_type(enum_basetype)) {
-					case MONO_TYPE_BOOLEAN: {
-						MonoBoolean val = p_var.operator bool();
-						RETURN_TYPE_VAL(MonoBoolean, val);
-					}
-					case MONO_TYPE_CHAR: {
-						uint16_t val = p_var.operator unsigned short();
-						RETURN_TYPE_VAL(uint16_t, val);
-					}
-					case MONO_TYPE_I1: {
-						int8_t val = p_var.operator signed char();
-						RETURN_TYPE_VAL(int8_t, val);
-					}
-					case MONO_TYPE_I2: {
-						int16_t val = p_var.operator signed short();
-						RETURN_TYPE_VAL(int16_t, val);
-					}
-					case MONO_TYPE_I4: {
-						int32_t val = p_var.operator signed int();
-						RETURN_TYPE_VAL(int32_t, val);
-					}
-					case MONO_TYPE_I8: {
-						int64_t val = p_var.operator int64_t();
-						RETURN_TYPE_VAL(int64_t, val);
-					}
-					case MONO_TYPE_U1: {
-						uint8_t val = p_var.operator unsigned char();
-						RETURN_TYPE_VAL(uint8_t, val);
-					}
-					case MONO_TYPE_U2: {
-						uint16_t val = p_var.operator unsigned short();
-						RETURN_TYPE_VAL(uint16_t, val);
-					}
-					case MONO_TYPE_U4: {
-						uint32_t val = p_var.operator unsigned int();
-						RETURN_TYPE_VAL(uint32_t, val);
-					}
-					case MONO_TYPE_U8: {
-						uint64_t val = p_var.operator uint64_t();
-						RETURN_TYPE_VAL(uint64_t, val);
-					}
-					default: {
-						ERR_FAIL_V_MSG(nullptr, "Attempted to convert Variant to enum value of unsupported base type: '" + GDMonoClass::get_full_name(mono_class_from_mono_type(enum_basetype)) + "'.");
-					}
-				}
-			}
-
-			ERR_FAIL_V_MSG(nullptr, "Attempted to convert Variant to unsupported value type: '" + p_type.type_class->get_full_name() + "'.");
-		} break;
-#undef RETURN_TYPE_VAL
-		case MONO_TYPE_STRING:
-			return variant_to_mono_string(p_var);
-		case MONO_TYPE_ARRAY:
-		case MONO_TYPE_SZARRAY:
-			return variant_to_mono_array(p_var, p_type.type_class);
-		case MONO_TYPE_CLASS:
-			return variant_to_mono_object_of_class(p_var, p_type.type_class);
-		case MONO_TYPE_GENERICINST:
-			return variant_to_mono_object_of_genericinst(p_var, p_type.type_class);
-		case MONO_TYPE_OBJECT:
-			return variant_to_mono_object(p_var);
-	}
-
-	ERR_FAIL_V_MSG(nullptr, "Attempted to convert Variant to unsupported type with encoding: " + itos(p_type.type_encoding) + ".");
-}
-
-MonoObject *variant_to_mono_object(const Variant &p_var, const ManagedType &p_type) {
-	switch (p_type.type_encoding) {
-		case MONO_TYPE_BOOLEAN: {
-			MonoBoolean val = p_var.operator bool();
-			return BOX_BOOLEAN(val);
-		}
-		case MONO_TYPE_CHAR: {
-			uint16_t val = p_var.operator unsigned short();
-			return BOX_UINT16(val);
-		}
-		case MONO_TYPE_I1: {
-			int8_t val = p_var.operator signed char();
-			return BOX_INT8(val);
-		}
-		case MONO_TYPE_I2: {
-			int16_t val = p_var.operator signed short();
-			return BOX_INT16(val);
-		}
-		case MONO_TYPE_I4: {
-			int32_t val = p_var.operator signed int();
-			return BOX_INT32(val);
-		}
-		case MONO_TYPE_I8: {
-			int64_t val = p_var.operator int64_t();
-			return BOX_INT64(val);
-		}
-		case MONO_TYPE_U1: {
-			uint8_t val = p_var.operator unsigned char();
-			return BOX_UINT8(val);
-		}
-		case MONO_TYPE_U2: {
-			uint16_t val = p_var.operator unsigned short();
-			return BOX_UINT16(val);
-		}
-		case MONO_TYPE_U4: {
-			uint32_t val = p_var.operator unsigned int();
-			return BOX_UINT32(val);
-		}
-		case MONO_TYPE_U8: {
-			uint64_t val = p_var.operator uint64_t();
-			return BOX_UINT64(val);
-		}
-		case MONO_TYPE_R4: {
-			float val = p_var.operator float();
-			return BOX_FLOAT(val);
-		}
-		case MONO_TYPE_R8: {
-			double val = p_var.operator double();
-			return BOX_DOUBLE(val);
-		}
-		case MONO_TYPE_VALUETYPE: {
-			GDMonoClass *vtclass = p_type.type_class;
-
-#define RETURN_CHECK_FOR_STRUCT(m_struct)                                                         \
-	if (vtclass == CACHED_CLASS(m_struct)) {                                                      \
-		GDMonoMarshal::M_##m_struct from = MARSHALLED_OUT(m_struct, p_var.operator ::m_struct()); \
-		return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(m_struct), &from);              \
-	}
-
-			RETURN_CHECK_FOR_STRUCT(Vector2);
-			RETURN_CHECK_FOR_STRUCT(Vector2i);
-			RETURN_CHECK_FOR_STRUCT(Rect2);
-			RETURN_CHECK_FOR_STRUCT(Rect2i);
-			RETURN_CHECK_FOR_STRUCT(Transform2D);
-			RETURN_CHECK_FOR_STRUCT(Vector3);
-			RETURN_CHECK_FOR_STRUCT(Vector3i);
-			RETURN_CHECK_FOR_STRUCT(Basis);
-			RETURN_CHECK_FOR_STRUCT(Quaternion);
-			RETURN_CHECK_FOR_STRUCT(Transform3D);
-			RETURN_CHECK_FOR_STRUCT(AABB);
-			RETURN_CHECK_FOR_STRUCT(Color);
-			RETURN_CHECK_FOR_STRUCT(Plane);
-
-#undef RETURN_CHECK_FOR_STRUCT
-
-			if (vtclass == CACHED_CLASS(Callable)) {
-				GDMonoMarshal::M_Callable from = GDMonoMarshal::callable_to_managed(p_var.operator Callable());
-				return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Callable), &from);
-			}
-
-			if (vtclass == CACHED_CLASS(SignalInfo)) {
-				GDMonoMarshal::M_SignalInfo from = GDMonoMarshal::signal_info_to_managed(p_var.operator Signal());
-				return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(SignalInfo), &from);
-			}
-
-			if (mono_class_is_enum(vtclass->get_mono_ptr())) {
-				MonoType *enum_basetype = mono_class_enum_basetype(vtclass->get_mono_ptr());
-				MonoClass *enum_baseclass = mono_class_from_mono_type(enum_basetype);
-				switch (mono_type_get_type(enum_basetype)) {
-					case MONO_TYPE_BOOLEAN: {
-						MonoBoolean val = p_var.operator bool();
-						return BOX_ENUM(enum_baseclass, val);
-					}
-					case MONO_TYPE_CHAR: {
-						uint16_t val = p_var.operator unsigned short();
-						return BOX_ENUM(enum_baseclass, val);
-					}
-					case MONO_TYPE_I1: {
-						int8_t val = p_var.operator signed char();
-						return BOX_ENUM(enum_baseclass, val);
-					}
-					case MONO_TYPE_I2: {
-						int16_t val = p_var.operator signed short();
-						return BOX_ENUM(enum_baseclass, val);
-					}
-					case MONO_TYPE_I4: {
-						int32_t val = p_var.operator signed int();
-						return BOX_ENUM(enum_baseclass, val);
-					}
-					case MONO_TYPE_I8: {
-						int64_t val = p_var.operator int64_t();
-						return BOX_ENUM(enum_baseclass, val);
-					}
-					case MONO_TYPE_U1: {
-						uint8_t val = p_var.operator unsigned char();
-						return BOX_ENUM(enum_baseclass, val);
-					}
-					case MONO_TYPE_U2: {
-						uint16_t val = p_var.operator unsigned short();
-						return BOX_ENUM(enum_baseclass, val);
-					}
-					case MONO_TYPE_U4: {
-						uint32_t val = p_var.operator unsigned int();
-						return BOX_ENUM(enum_baseclass, val);
-					}
-					case MONO_TYPE_U8: {
-						uint64_t val = p_var.operator uint64_t();
-						return BOX_ENUM(enum_baseclass, val);
-					}
-					default: {
-						ERR_FAIL_V_MSG(nullptr, "Attempted to convert Variant to enum value of unsupported base type: '" + GDMonoClass::get_full_name(enum_baseclass) + "'.");
-					}
-				}
-			}
-
-			ERR_FAIL_V_MSG(nullptr, "Attempted to convert Variant to unsupported value type: '" + p_type.type_class->get_full_name() + "'.");
-		} break;
-		case MONO_TYPE_STRING:
-			return (MonoObject *)variant_to_mono_string(p_var);
-		case MONO_TYPE_ARRAY:
-		case MONO_TYPE_SZARRAY:
-			return (MonoObject *)variant_to_mono_array(p_var, p_type.type_class);
-		case MONO_TYPE_CLASS:
-			return variant_to_mono_object_of_class(p_var, p_type.type_class);
-		case MONO_TYPE_GENERICINST:
-			return variant_to_mono_object_of_genericinst(p_var, p_type.type_class);
-		case MONO_TYPE_OBJECT:
-			return variant_to_mono_object(p_var);
-	}
-
-	ERR_FAIL_V_MSG(nullptr, "Attempted to convert Variant to unsupported type with encoding: " + itos(p_type.type_encoding) + ".");
-}
-
-Variant mono_object_to_variant_impl(MonoObject *p_obj, const ManagedType &p_type, bool p_fail_with_err = true) {
-	ERR_FAIL_COND_V(!p_type.type_class, Variant());
-
-#ifdef DEBUG_ENABLED
-	CRASH_COND_MSG(p_type.type_encoding == MONO_TYPE_OBJECT, "Type of object should be known.");
-#endif
-
-	switch (p_type.type_encoding) {
-		case MONO_TYPE_BOOLEAN:
-			return (bool)unbox<MonoBoolean>(p_obj);
-		case MONO_TYPE_CHAR:
-			return unbox<uint16_t>(p_obj);
-		case MONO_TYPE_I1:
-			return unbox<int8_t>(p_obj);
-		case MONO_TYPE_I2:
-			return unbox<int16_t>(p_obj);
-		case MONO_TYPE_I4:
-			return unbox<int32_t>(p_obj);
-		case MONO_TYPE_I8:
-			return unbox<int64_t>(p_obj);
-		case MONO_TYPE_U1:
-			return unbox<uint8_t>(p_obj);
-		case MONO_TYPE_U2:
-			return unbox<uint16_t>(p_obj);
-		case MONO_TYPE_U4:
-			return unbox<uint32_t>(p_obj);
-		case MONO_TYPE_U8:
-			return unbox<uint64_t>(p_obj);
-		case MONO_TYPE_R4:
-			return unbox<float>(p_obj);
-		case MONO_TYPE_R8:
-			return unbox<double>(p_obj);
-		case MONO_TYPE_VALUETYPE: {
-			GDMonoClass *vtclass = p_type.type_class;
-
-			if (vtclass == CACHED_CLASS(Vector2)) {
-				return MARSHALLED_IN(Vector2, unbox_addr<GDMonoMarshal::M_Vector2>(p_obj));
-			}
-
-			if (vtclass == CACHED_CLASS(Vector2i)) {
-				return MARSHALLED_IN(Vector2i, unbox_addr<GDMonoMarshal::M_Vector2i>(p_obj));
-			}
-
-			if (vtclass == CACHED_CLASS(Rect2)) {
-				return MARSHALLED_IN(Rect2, unbox_addr<GDMonoMarshal::M_Rect2>(p_obj));
-			}
-
-			if (vtclass == CACHED_CLASS(Rect2i)) {
-				return MARSHALLED_IN(Rect2i, unbox_addr<GDMonoMarshal::M_Rect2i>(p_obj));
-			}
-
-			if (vtclass == CACHED_CLASS(Transform2D)) {
-				return MARSHALLED_IN(Transform2D, unbox_addr<GDMonoMarshal::M_Transform2D>(p_obj));
-			}
-
-			if (vtclass == CACHED_CLASS(Vector3)) {
-				return MARSHALLED_IN(Vector3, unbox_addr<GDMonoMarshal::M_Vector3>(p_obj));
-			}
-
-			if (vtclass == CACHED_CLASS(Vector3i)) {
-				return MARSHALLED_IN(Vector3i, unbox_addr<GDMonoMarshal::M_Vector3i>(p_obj));
-			}
-
-			if (vtclass == CACHED_CLASS(Basis)) {
-				return MARSHALLED_IN(Basis, unbox_addr<GDMonoMarshal::M_Basis>(p_obj));
-			}
-
-			if (vtclass == CACHED_CLASS(Quaternion)) {
-				return MARSHALLED_IN(Quaternion, unbox_addr<GDMonoMarshal::M_Quaternion>(p_obj));
-			}
-
-			if (vtclass == CACHED_CLASS(Transform3D)) {
-				return MARSHALLED_IN(Transform3D, unbox_addr<GDMonoMarshal::M_Transform3D>(p_obj));
-			}
-
-			if (vtclass == CACHED_CLASS(AABB)) {
-				return MARSHALLED_IN(AABB, unbox_addr<GDMonoMarshal::M_AABB>(p_obj));
-			}
-
-			if (vtclass == CACHED_CLASS(Color)) {
-				return MARSHALLED_IN(Color, unbox_addr<GDMonoMarshal::M_Color>(p_obj));
-			}
-
-			if (vtclass == CACHED_CLASS(Plane)) {
-				return MARSHALLED_IN(Plane, unbox_addr<GDMonoMarshal::M_Plane>(p_obj));
-			}
-
-			if (vtclass == CACHED_CLASS(Callable)) {
-				return managed_to_callable(unbox<GDMonoMarshal::M_Callable>(p_obj));
-			}
-
-			if (vtclass == CACHED_CLASS(SignalInfo)) {
-				return managed_to_signal_info(unbox<GDMonoMarshal::M_SignalInfo>(p_obj));
-			}
-
-			if (mono_class_is_enum(vtclass->get_mono_ptr())) {
-				return unbox<int32_t>(p_obj);
-			}
-		} break;
-		case MONO_TYPE_STRING: {
-			if (p_obj == nullptr) {
-				return Variant(); // NIL
-			}
-			return mono_string_to_godot_not_null((MonoString *)p_obj);
-		} break;
-		case MONO_TYPE_ARRAY:
-		case MONO_TYPE_SZARRAY: {
-			MonoArrayType *array_type = mono_type_get_array_type(p_type.type_class->get_mono_type());
-
-			if (array_type->eklass == CACHED_CLASS_RAW(MonoObject)) {
-				return mono_array_to_Array((MonoArray *)p_obj);
-			}
-
-			if (array_type->eklass == CACHED_CLASS_RAW(uint8_t)) {
-				return mono_array_to_PackedByteArray((MonoArray *)p_obj);
-			}
-
-			if (array_type->eklass == CACHED_CLASS_RAW(int32_t)) {
-				return mono_array_to_PackedInt32Array((MonoArray *)p_obj);
-			}
-
-			if (array_type->eklass == CACHED_CLASS_RAW(int64_t)) {
-				return mono_array_to_PackedInt64Array((MonoArray *)p_obj);
-			}
-
-			if (array_type->eklass == CACHED_CLASS_RAW(float)) {
-				return mono_array_to_PackedFloat32Array((MonoArray *)p_obj);
-			}
-
-			if (array_type->eklass == CACHED_CLASS_RAW(double)) {
-				return mono_array_to_PackedFloat64Array((MonoArray *)p_obj);
-			}
-
-			if (array_type->eklass == CACHED_CLASS_RAW(String)) {
-				return mono_array_to_PackedStringArray((MonoArray *)p_obj);
-			}
-
-			if (array_type->eklass == CACHED_CLASS_RAW(Vector2)) {
-				return mono_array_to_PackedVector2Array((MonoArray *)p_obj);
-			}
-
-			if (array_type->eklass == CACHED_CLASS_RAW(Vector3)) {
-				return mono_array_to_PackedVector3Array((MonoArray *)p_obj);
-			}
-
-			if (array_type->eklass == CACHED_CLASS_RAW(Color)) {
-				return mono_array_to_PackedColorArray((MonoArray *)p_obj);
-			}
-
-			if (array_type->eklass == CACHED_CLASS_RAW(StringName)) {
-				return mono_array_to_Array((MonoArray *)p_obj);
-			}
-
-			if (array_type->eklass == CACHED_CLASS_RAW(NodePath)) {
-				return mono_array_to_Array((MonoArray *)p_obj);
-			}
-
-			if (array_type->eklass == CACHED_CLASS_RAW(RID)) {
-				return mono_array_to_Array((MonoArray *)p_obj);
-			}
-
-			GDMonoClass *array_type_class = GDMono::get_singleton()->get_class(array_type->eklass);
-			if (CACHED_CLASS(GodotObject)->is_assignable_from(array_type_class)) {
-				return mono_array_to_Array((MonoArray *)p_obj);
-			}
-
-			if (p_fail_with_err) {
-				ERR_FAIL_V_MSG(Variant(), "Attempted to convert a managed array of unmarshallable element type to Variant.");
-			} else {
-				return Variant();
-			}
-		} break;
-		case MONO_TYPE_CLASS: {
-			GDMonoClass *type_class = p_type.type_class;
-
-			// GodotObject
-			if (CACHED_CLASS(GodotObject)->is_assignable_from(type_class)) {
-				Object *ptr = unbox<Object *>(CACHED_FIELD(GodotObject, ptr)->get_value(p_obj));
-				if (ptr != nullptr) {
-					RefCounted *rc = Object::cast_to<RefCounted>(ptr);
-					return rc ? Variant(Ref<RefCounted>(rc)) : Variant(ptr);
-				}
-				return Variant();
-			}
-
-			if (CACHED_CLASS(StringName) == type_class) {
-				StringName *ptr = unbox<StringName *>(CACHED_FIELD(StringName, ptr)->get_value(p_obj));
-				return ptr ? Variant(*ptr) : Variant();
-			}
-
-			if (CACHED_CLASS(NodePath) == type_class) {
-				NodePath *ptr = unbox<NodePath *>(CACHED_FIELD(NodePath, ptr)->get_value(p_obj));
-				return ptr ? Variant(*ptr) : Variant();
-			}
-
-			if (CACHED_CLASS(RID) == type_class) {
-				RID *ptr = unbox<RID *>(CACHED_FIELD(RID, ptr)->get_value(p_obj));
-				return ptr ? Variant(*ptr) : Variant();
-			}
-
-			// Godot.Collections.Dictionary
-			if (CACHED_CLASS(Dictionary) == type_class) {
-				MonoException *exc = nullptr;
-				Dictionary *ptr = CACHED_METHOD_THUNK(Dictionary, GetPtr).invoke(p_obj, &exc);
-				UNHANDLED_EXCEPTION(exc);
-				return ptr ? Variant(*ptr) : Variant();
-			}
-
-			// Godot.Collections.Array
-			if (CACHED_CLASS(Array) == type_class) {
-				MonoException *exc = nullptr;
-				Array *ptr = CACHED_METHOD_THUNK(Array, GetPtr).invoke(p_obj, &exc);
-				UNHANDLED_EXCEPTION(exc);
-				return ptr ? Variant(*ptr) : Variant();
-			}
-		} break;
-		case MONO_TYPE_GENERICINST: {
-			MonoReflectionType *reftype = mono_type_get_object(mono_domain_get(), p_type.type_class->get_mono_type());
-
-			// Godot.Collections.Dictionary<TKey, TValue>
-			if (GDMonoUtils::Marshal::type_is_generic_dictionary(reftype)) {
-				MonoException *exc = nullptr;
-				MonoObject *ret = p_type.type_class->get_method("GetPtr")->invoke(p_obj, &exc);
-				UNHANDLED_EXCEPTION(exc);
-				return *unbox<Dictionary *>(ret);
-			}
-
-			// Godot.Collections.Array<T>
-			if (GDMonoUtils::Marshal::type_is_generic_array(reftype)) {
-				MonoException *exc = nullptr;
-				MonoObject *ret = p_type.type_class->get_method("GetPtr")->invoke(p_obj, &exc);
-				UNHANDLED_EXCEPTION(exc);
-				return *unbox<Array *>(ret);
-			}
-
-			// System.Collections.Generic.Dictionary<TKey, TValue>
-			if (GDMonoUtils::Marshal::type_is_system_generic_dictionary(reftype)) {
-				MonoReflectionType *key_reftype = nullptr;
-				MonoReflectionType *value_reftype = nullptr;
-				GDMonoUtils::Marshal::dictionary_get_key_value_types(reftype, &key_reftype, &value_reftype);
-				return system_generic_dict_to_Dictionary(p_obj, p_type.type_class, key_reftype, value_reftype);
-			}
-
-			// System.Collections.Generic.List<T>
-			if (GDMonoUtils::Marshal::type_is_system_generic_list(reftype)) {
-				MonoReflectionType *elem_reftype = nullptr;
-				GDMonoUtils::Marshal::array_get_element_type(reftype, &elem_reftype);
-				return system_generic_list_to_Array_variant(p_obj, p_type.type_class, elem_reftype);
-			}
+	MonoException *exc = nullptr;
+	MonoObject *ret = CACHED_METHOD_THUNK(Marshaling, variant_to_mono_object)
+							  .invoke(&p_var, &exc);
 
-			// GodotObject
-			GDMonoClass *type_class = p_type.type_class;
-			if (CACHED_CLASS(GodotObject)->is_assignable_from(type_class)) {
-				Object *ptr = unbox<Object *>(CACHED_FIELD(GodotObject, ptr)->get_value(p_obj));
-				if (ptr != nullptr) {
-					RefCounted *rc = Object::cast_to<RefCounted>(ptr);
-					return rc ? Variant(Ref<RefCounted>(rc)) : Variant(ptr);
-				}
-				return Variant();
-			}
-		} break;
+	if (exc) {
+		GDMonoUtils::debug_print_unhandled_exception(exc);
+		return nullptr;
 	}
 
-	if (p_fail_with_err) {
-		ERR_FAIL_V_MSG(Variant(), "Attempted to convert an unmarshallable managed type to Variant. Name: '" + p_type.type_class->get_name() + "' Encoding: " + itos(p_type.type_encoding) + ".");
-	} else {
-		return Variant();
-	}
+	return ret;
 }
 
-Variant mono_object_to_variant(MonoObject *p_obj) {
+static Variant mono_object_to_variant_impl(MonoObject *p_obj, bool p_fail_with_err) {
 	if (!p_obj) {
 		return Variant();
 	}
 
-	ManagedType type = ManagedType::from_class(mono_object_get_class(p_obj));
+	MonoBoolean fail_with_error = p_fail_with_err;
 
-	return mono_object_to_variant_impl(p_obj, type);
-}
+	Variant ret;
 
-Variant mono_object_to_variant(MonoObject *p_obj, const ManagedType &p_type) {
-	if (!p_obj) {
+	MonoException *exc = nullptr;
+	CACHED_METHOD_THUNK(Marshaling, mono_object_to_variant_out)
+			.invoke(p_obj, fail_with_error, &ret, &exc);
+
+	if (exc) {
+		GDMonoUtils::debug_print_unhandled_exception(exc);
 		return Variant();
 	}
 
-	return mono_object_to_variant_impl(p_obj, p_type);
+	return ret;
 }
 
-Variant mono_object_to_variant_no_err(MonoObject *p_obj, const ManagedType &p_type) {
-	if (!p_obj) {
-		return Variant();
-	}
+Variant mono_object_to_variant(MonoObject *p_obj) {
+	return mono_object_to_variant_impl(p_obj, /* fail_with_err: */ true);
+}
 
-	return mono_object_to_variant_impl(p_obj, p_type, /* fail_with_err: */ false);
+Variant mono_object_to_variant_no_err(MonoObject *p_obj) {
+	return mono_object_to_variant_impl(p_obj, /* fail_with_err: */ false);
 }
 
 String mono_object_to_variant_string(MonoObject *p_obj, MonoException **r_exc) {
@@ -1320,8 +142,7 @@ String mono_object_to_variant_string(MonoObject *p_obj, MonoException **r_exc) {
 		return String("null");
 	}
 
-	ManagedType type = ManagedType::from_class(mono_object_get_class(p_obj));
-	Variant var = GDMonoMarshal::mono_object_to_variant_no_err(p_obj, type);
+	Variant var = GDMonoMarshal::mono_object_to_variant_no_err(p_obj);
 
 	if (var.get_type() == Variant::NIL) { // `&& p_obj != nullptr` but omitted because always true
 		// Cannot convert MonoObject* to Variant; fallback to 'ToString()'.
@@ -1341,90 +162,6 @@ String mono_object_to_variant_string(MonoObject *p_obj, MonoException **r_exc) {
 	}
 }
 
-MonoObject *Dictionary_to_system_generic_dict(const Dictionary &p_dict, GDMonoClass *p_class, MonoReflectionType *p_key_reftype, MonoReflectionType *p_value_reftype) {
-	String ctor_desc = ":.ctor(System.Collections.Generic.IDictionary`2<" + GDMonoUtils::get_type_desc(p_key_reftype) +
-			", " + GDMonoUtils::get_type_desc(p_value_reftype) + ">)";
-	GDMonoMethod *ctor = p_class->get_method_with_desc(ctor_desc, true);
-	CRASH_COND(ctor == nullptr);
-
-	MonoObject *mono_object = mono_object_new(mono_domain_get(), p_class->get_mono_ptr());
-	ERR_FAIL_NULL_V(mono_object, nullptr);
-
-	GDMonoClass *godot_dict_class = GDMonoUtils::Marshal::make_generic_dictionary_type(p_key_reftype, p_value_reftype);
-	MonoObject *godot_dict = GDMonoUtils::create_managed_from(p_dict, godot_dict_class);
-
-	void *ctor_args[1] = { godot_dict };
-
-	MonoException *exc = nullptr;
-	ctor->invoke_raw(mono_object, ctor_args, &exc);
-	UNHANDLED_EXCEPTION(exc);
-
-	return mono_object;
-}
-
-Dictionary system_generic_dict_to_Dictionary(MonoObject *p_obj, [[maybe_unused]] GDMonoClass *p_class, MonoReflectionType *p_key_reftype, MonoReflectionType *p_value_reftype) {
-	GDMonoClass *godot_dict_class = GDMonoUtils::Marshal::make_generic_dictionary_type(p_key_reftype, p_value_reftype);
-	String ctor_desc = ":.ctor(System.Collections.Generic.IDictionary`2<" + GDMonoUtils::get_type_desc(p_key_reftype) +
-			", " + GDMonoUtils::get_type_desc(p_value_reftype) + ">)";
-	GDMonoMethod *godot_dict_ctor = godot_dict_class->get_method_with_desc(ctor_desc, true);
-	CRASH_COND(godot_dict_ctor == nullptr);
-
-	MonoObject *godot_dict = mono_object_new(mono_domain_get(), godot_dict_class->get_mono_ptr());
-	ERR_FAIL_NULL_V(godot_dict, Dictionary());
-
-	void *ctor_args[1] = { p_obj };
-
-	MonoException *exc = nullptr;
-	godot_dict_ctor->invoke_raw(godot_dict, ctor_args, &exc);
-	UNHANDLED_EXCEPTION(exc);
-
-	exc = nullptr;
-	MonoObject *ret = godot_dict_class->get_method("GetPtr")->invoke(godot_dict, &exc);
-	UNHANDLED_EXCEPTION(exc);
-
-	return *unbox<Dictionary *>(ret);
-}
-
-MonoObject *Array_to_system_generic_list(const Array &p_array, GDMonoClass *p_class, MonoReflectionType *p_elem_reftype) {
-	MonoType *elem_type = mono_reflection_type_get_type(p_elem_reftype);
-
-	String ctor_desc = ":.ctor(System.Collections.Generic.IEnumerable`1<" + GDMonoUtils::get_type_desc(elem_type) + ">)";
-	GDMonoMethod *ctor = p_class->get_method_with_desc(ctor_desc, true);
-	CRASH_COND(ctor == nullptr);
-
-	MonoObject *mono_object = mono_object_new(mono_domain_get(), p_class->get_mono_ptr());
-	ERR_FAIL_NULL_V(mono_object, nullptr);
-
-	GDMonoClass *godot_array_class = GDMonoUtils::Marshal::make_generic_array_type(p_elem_reftype);
-	MonoObject *godot_array = GDMonoUtils::create_managed_from(p_array, godot_array_class);
-
-	void *ctor_args[1] = { godot_array };
-
-	MonoException *exc = nullptr;
-	ctor->invoke_raw(mono_object, ctor_args, &exc);
-	UNHANDLED_EXCEPTION(exc);
-
-	return mono_object;
-}
-
-Variant system_generic_list_to_Array_variant(MonoObject *p_obj, GDMonoClass *p_class, [[maybe_unused]] MonoReflectionType *p_elem_reftype) {
-	GDMonoMethod *to_array = p_class->get_method("ToArray", 0);
-	CRASH_COND(to_array == nullptr);
-
-	MonoException *exc = nullptr;
-	MonoObject *array = to_array->invoke_raw(p_obj, nullptr, &exc);
-	UNHANDLED_EXCEPTION(exc);
-
-	ERR_FAIL_NULL_V(array, Variant());
-
-	ManagedType type = ManagedType::from_class(mono_object_get_class(array));
-
-	bool result_is_array = type.type_encoding != MONO_TYPE_SZARRAY && type.type_encoding != MONO_TYPE_ARRAY;
-	ERR_FAIL_COND_V(result_is_array, Variant());
-
-	return mono_object_to_variant(array, type);
-}
-
 MonoArray *Array_to_mono_array(const Array &p_array) {
 	int length = p_array.size();
 	MonoArray *ret = mono_array_new(mono_domain_get(), CACHED_CLASS_RAW(MonoObject), length);
@@ -1437,18 +174,6 @@ MonoArray *Array_to_mono_array(const Array &p_array) {
 	return ret;
 }
 
-MonoArray *Array_to_mono_array(const Array &p_array, MonoClass *p_array_type_class) {
-	int length = p_array.size();
-	MonoArray *ret = mono_array_new(mono_domain_get(), p_array_type_class, length);
-
-	for (int i = 0; i < length; i++) {
-		MonoObject *boxed = variant_to_mono_object(p_array[i]);
-		mono_array_setref(ret, i, boxed);
-	}
-
-	return ret;
-}
-
 Array mono_array_to_Array(MonoArray *p_array) {
 	Array ret;
 	if (!p_array) {
@@ -1465,141 +190,6 @@ Array mono_array_to_Array(MonoArray *p_array) {
 	return ret;
 }
 
-MonoArray *PackedInt32Array_to_mono_array(const PackedInt32Array &p_array) {
-	const int32_t *src = p_array.ptr();
-	int length = p_array.size();
-
-	MonoArray *ret = mono_array_new(mono_domain_get(), CACHED_CLASS_RAW(int32_t), length);
-
-	int32_t *dst = mono_array_addr(ret, int32_t, 0);
-	memcpy(dst, src, length * sizeof(int32_t));
-
-	return ret;
-}
-
-PackedInt32Array mono_array_to_PackedInt32Array(MonoArray *p_array) {
-	PackedInt32Array ret;
-	if (!p_array) {
-		return ret;
-	}
-	int length = mono_array_length(p_array);
-	ret.resize(length);
-	int32_t *dst = ret.ptrw();
-
-	const int32_t *src = mono_array_addr(p_array, int32_t, 0);
-	memcpy(dst, src, length * sizeof(int32_t));
-
-	return ret;
-}
-
-MonoArray *PackedInt64Array_to_mono_array(const PackedInt64Array &p_array) {
-	const int64_t *src = p_array.ptr();
-	int length = p_array.size();
-
-	MonoArray *ret = mono_array_new(mono_domain_get(), CACHED_CLASS_RAW(int64_t), length);
-
-	int64_t *dst = mono_array_addr(ret, int64_t, 0);
-	memcpy(dst, src, length * sizeof(int64_t));
-
-	return ret;
-}
-
-PackedInt64Array mono_array_to_PackedInt64Array(MonoArray *p_array) {
-	PackedInt64Array ret;
-	if (!p_array) {
-		return ret;
-	}
-	int length = mono_array_length(p_array);
-	ret.resize(length);
-	int64_t *dst = ret.ptrw();
-
-	const int64_t *src = mono_array_addr(p_array, int64_t, 0);
-	memcpy(dst, src, length * sizeof(int64_t));
-
-	return ret;
-}
-
-MonoArray *PackedByteArray_to_mono_array(const PackedByteArray &p_array) {
-	const uint8_t *src = p_array.ptr();
-	int length = p_array.size();
-
-	MonoArray *ret = mono_array_new(mono_domain_get(), CACHED_CLASS_RAW(uint8_t), length);
-
-	uint8_t *dst = mono_array_addr(ret, uint8_t, 0);
-	memcpy(dst, src, length * sizeof(uint8_t));
-
-	return ret;
-}
-
-PackedByteArray mono_array_to_PackedByteArray(MonoArray *p_array) {
-	PackedByteArray ret;
-	if (!p_array) {
-		return ret;
-	}
-	int length = mono_array_length(p_array);
-	ret.resize(length);
-	uint8_t *dst = ret.ptrw();
-
-	const uint8_t *src = mono_array_addr(p_array, uint8_t, 0);
-	memcpy(dst, src, length * sizeof(uint8_t));
-
-	return ret;
-}
-
-MonoArray *PackedFloat32Array_to_mono_array(const PackedFloat32Array &p_array) {
-	const float *src = p_array.ptr();
-	int length = p_array.size();
-
-	MonoArray *ret = mono_array_new(mono_domain_get(), CACHED_CLASS_RAW(float), length);
-
-	float *dst = mono_array_addr(ret, float, 0);
-	memcpy(dst, src, length * sizeof(float));
-
-	return ret;
-}
-
-PackedFloat32Array mono_array_to_PackedFloat32Array(MonoArray *p_array) {
-	PackedFloat32Array ret;
-	if (!p_array) {
-		return ret;
-	}
-	int length = mono_array_length(p_array);
-	ret.resize(length);
-	float *dst = ret.ptrw();
-
-	const float *src = mono_array_addr(p_array, float, 0);
-	memcpy(dst, src, length * sizeof(float));
-
-	return ret;
-}
-
-MonoArray *PackedFloat64Array_to_mono_array(const PackedFloat64Array &p_array) {
-	const double *src = p_array.ptr();
-	int length = p_array.size();
-
-	MonoArray *ret = mono_array_new(mono_domain_get(), CACHED_CLASS_RAW(double), length);
-
-	double *dst = mono_array_addr(ret, double, 0);
-	memcpy(dst, src, length * sizeof(double));
-
-	return ret;
-}
-
-PackedFloat64Array mono_array_to_PackedFloat64Array(MonoArray *p_array) {
-	PackedFloat64Array ret;
-	if (!p_array) {
-		return ret;
-	}
-	int length = mono_array_length(p_array);
-	ret.resize(length);
-	double *dst = ret.ptrw();
-
-	const double *src = mono_array_addr(p_array, double, 0);
-	memcpy(dst, src, length * sizeof(double));
-
-	return ret;
-}
-
 MonoArray *PackedStringArray_to_mono_array(const PackedStringArray &p_array) {
 	const String *r = p_array.ptr();
 	int length = p_array.size();
@@ -1613,212 +203,4 @@ MonoArray *PackedStringArray_to_mono_array(const PackedStringArray &p_array) {
 
 	return ret;
 }
-
-PackedStringArray mono_array_to_PackedStringArray(MonoArray *p_array) {
-	PackedStringArray ret;
-	if (!p_array) {
-		return ret;
-	}
-	int length = mono_array_length(p_array);
-	ret.resize(length);
-	String *w = ret.ptrw();
-
-	for (int i = 0; i < length; i++) {
-		MonoString *elem = mono_array_get(p_array, MonoString *, i);
-		w[i] = mono_string_to_godot(elem);
-	}
-
-	return ret;
-}
-
-MonoArray *PackedColorArray_to_mono_array(const PackedColorArray &p_array) {
-	const Color *src = p_array.ptr();
-	int length = p_array.size();
-
-	MonoArray *ret = mono_array_new(mono_domain_get(), CACHED_CLASS_RAW(Color), length);
-
-	if constexpr (InteropLayout::MATCHES_Color) {
-		Color *dst = mono_array_addr(ret, Color, 0);
-		memcpy(dst, src, length * sizeof(Color));
-	} else {
-		for (int i = 0; i < length; i++) {
-			M_Color *raw = (M_Color *)mono_array_addr_with_size(ret, sizeof(M_Color), i);
-			*raw = MARSHALLED_OUT(Color, src[i]);
-		}
-	}
-
-	return ret;
-}
-
-PackedColorArray mono_array_to_PackedColorArray(MonoArray *p_array) {
-	PackedColorArray ret;
-	if (!p_array) {
-		return ret;
-	}
-	int length = mono_array_length(p_array);
-	ret.resize(length);
-	Color *dst = ret.ptrw();
-
-	if constexpr (InteropLayout::MATCHES_Color) {
-		const Color *src = mono_array_addr(p_array, Color, 0);
-		memcpy(dst, src, length * sizeof(Color));
-	} else {
-		for (int i = 0; i < length; i++) {
-			dst[i] = MARSHALLED_IN(Color, (M_Color *)mono_array_addr_with_size(p_array, sizeof(M_Color), i));
-		}
-	}
-
-	return ret;
-}
-
-MonoArray *PackedVector2Array_to_mono_array(const PackedVector2Array &p_array) {
-	const Vector2 *src = p_array.ptr();
-	int length = p_array.size();
-
-	MonoArray *ret = mono_array_new(mono_domain_get(), CACHED_CLASS_RAW(Vector2), length);
-
-	if constexpr (InteropLayout::MATCHES_Vector2) {
-		Vector2 *dst = mono_array_addr(ret, Vector2, 0);
-		memcpy(dst, src, length * sizeof(Vector2));
-	} else {
-		for (int i = 0; i < length; i++) {
-			M_Vector2 *raw = (M_Vector2 *)mono_array_addr_with_size(ret, sizeof(M_Vector2), i);
-			*raw = MARSHALLED_OUT(Vector2, src[i]);
-		}
-	}
-
-	return ret;
-}
-
-PackedVector2Array mono_array_to_PackedVector2Array(MonoArray *p_array) {
-	PackedVector2Array ret;
-	if (!p_array) {
-		return ret;
-	}
-	int length = mono_array_length(p_array);
-	ret.resize(length);
-	Vector2 *dst = ret.ptrw();
-
-	if constexpr (InteropLayout::MATCHES_Vector2) {
-		const Vector2 *src = mono_array_addr(p_array, Vector2, 0);
-		memcpy(dst, src, length * sizeof(Vector2));
-	} else {
-		for (int i = 0; i < length; i++) {
-			dst[i] = MARSHALLED_IN(Vector2, (M_Vector2 *)mono_array_addr_with_size(p_array, sizeof(M_Vector2), i));
-		}
-	}
-
-	return ret;
-}
-
-MonoArray *PackedVector3Array_to_mono_array(const PackedVector3Array &p_array) {
-	const Vector3 *src = p_array.ptr();
-	int length = p_array.size();
-
-	MonoArray *ret = mono_array_new(mono_domain_get(), CACHED_CLASS_RAW(Vector3), length);
-
-	if constexpr (InteropLayout::MATCHES_Vector3) {
-		Vector3 *dst = mono_array_addr(ret, Vector3, 0);
-		memcpy(dst, src, length * sizeof(Vector3));
-	} else {
-		for (int i = 0; i < length; i++) {
-			M_Vector3 *raw = (M_Vector3 *)mono_array_addr_with_size(ret, sizeof(M_Vector3), i);
-			*raw = MARSHALLED_OUT(Vector3, src[i]);
-		}
-	}
-
-	return ret;
-}
-
-PackedVector3Array mono_array_to_PackedVector3Array(MonoArray *p_array) {
-	PackedVector3Array ret;
-	if (!p_array) {
-		return ret;
-	}
-	int length = mono_array_length(p_array);
-	ret.resize(length);
-	Vector3 *dst = ret.ptrw();
-
-	if constexpr (InteropLayout::MATCHES_Vector3) {
-		const Vector3 *src = mono_array_addr(p_array, Vector3, 0);
-		memcpy(dst, src, length * sizeof(Vector3));
-	} else {
-		for (int i = 0; i < length; i++) {
-			dst[i] = MARSHALLED_IN(Vector3, (M_Vector3 *)mono_array_addr_with_size(p_array, sizeof(M_Vector3), i));
-		}
-	}
-
-	return ret;
-}
-
-Callable managed_to_callable(const M_Callable &p_managed_callable) {
-	if (p_managed_callable.delegate) {
-		// TODO: Use pooling for ManagedCallable instances.
-		CallableCustom *managed_callable = memnew(ManagedCallable(p_managed_callable.delegate));
-		return Callable(managed_callable);
-	} else {
-		Object *target = p_managed_callable.target
-				? unbox<Object *>(CACHED_FIELD(GodotObject, ptr)->get_value(p_managed_callable.target))
-				: nullptr;
-		StringName *method_ptr = p_managed_callable.method_string_name
-				? unbox<StringName *>(CACHED_FIELD(StringName, ptr)->get_value(p_managed_callable.method_string_name))
-				: nullptr;
-		StringName method = method_ptr ? *method_ptr : StringName();
-		return Callable(target, method);
-	}
-}
-
-M_Callable callable_to_managed(const Callable &p_callable) {
-	if (p_callable.is_custom()) {
-		CallableCustom *custom = p_callable.get_custom();
-		CallableCustom::CompareEqualFunc compare_equal_func = custom->get_compare_equal_func();
-
-		if (compare_equal_func == ManagedCallable::compare_equal_func_ptr) {
-			ManagedCallable *managed_callable = static_cast<ManagedCallable *>(custom);
-			return {
-				nullptr, nullptr,
-				managed_callable->get_delegate()
-			};
-		} else if (compare_equal_func == SignalAwaiterCallable::compare_equal_func_ptr) {
-			SignalAwaiterCallable *signal_awaiter_callable = static_cast<SignalAwaiterCallable *>(custom);
-			return {
-				GDMonoUtils::unmanaged_get_managed(ObjectDB::get_instance(signal_awaiter_callable->get_object())),
-				GDMonoUtils::create_managed_from(signal_awaiter_callable->get_signal()),
-				nullptr
-			};
-		} else if (compare_equal_func == EventSignalCallable::compare_equal_func_ptr) {
-			EventSignalCallable *event_signal_callable = static_cast<EventSignalCallable *>(custom);
-			return {
-				GDMonoUtils::unmanaged_get_managed(ObjectDB::get_instance(event_signal_callable->get_object())),
-				GDMonoUtils::create_managed_from(event_signal_callable->get_signal()),
-				nullptr
-			};
-		}
-
-		// Some other CallableCustom. We only support ManagedCallable.
-		return { nullptr, nullptr, nullptr };
-	} else {
-		MonoObject *target_managed = GDMonoUtils::unmanaged_get_managed(p_callable.get_object());
-		MonoObject *method_string_name_managed = GDMonoUtils::create_managed_from(p_callable.get_method());
-		return { target_managed, method_string_name_managed, nullptr };
-	}
-}
-
-Signal managed_to_signal_info(const M_SignalInfo &p_managed_signal) {
-	Object *owner = p_managed_signal.owner
-			? unbox<Object *>(CACHED_FIELD(GodotObject, ptr)->get_value(p_managed_signal.owner))
-			: nullptr;
-	StringName *name_ptr = p_managed_signal.name_string_name
-			? unbox<StringName *>(CACHED_FIELD(StringName, ptr)->get_value(p_managed_signal.name_string_name))
-			: nullptr;
-	StringName name = name_ptr ? *name_ptr : StringName();
-	return Signal(owner, name);
-}
-
-M_SignalInfo signal_info_to_managed(const Signal &p_signal) {
-	Object *owner = p_signal.get_object();
-	MonoObject *owner_managed = GDMonoUtils::unmanaged_get_managed(owner);
-	MonoObject *name_string_name_managed = GDMonoUtils::create_managed_from(p_signal.get_name());
-	return { owner_managed, name_string_name_managed };
-}
 } // namespace GDMonoMarshal
diff --git a/modules/mono/mono_gd/gd_mono_marshal.h b/modules/mono/mono_gd/gd_mono_marshal.h
index 51f11ab18a..16683de51a 100644
--- a/modules/mono/mono_gd/gd_mono_marshal.h
+++ b/modules/mono/mono_gd/gd_mono_marshal.h
@@ -5,8 +5,8 @@
 /*                           GODOT ENGINE                                */
 /*                      https://godotengine.org                          */
 /*************************************************************************/
-/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2021 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       */
@@ -33,7 +33,6 @@
 
 #include "core/variant/variant.h"
 
-#include "../managed_callable.h"
 #include "gd_mono.h"
 #include "gd_mono_utils.h"
 
@@ -44,25 +43,6 @@ T unbox(MonoObject *p_obj) {
 	return *(T *)mono_object_unbox(p_obj);
 }
 
-template <typename T>
-T *unbox_addr(MonoObject *p_obj) {
-	return (T *)mono_object_unbox(p_obj);
-}
-
-#define BOX_DOUBLE(x) mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(double), &x)
-#define BOX_FLOAT(x) mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(float), &x)
-#define BOX_INT64(x) mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(int64_t), &x)
-#define BOX_INT32(x) mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(int32_t), &x)
-#define BOX_INT16(x) mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(int16_t), &x)
-#define BOX_INT8(x) mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(int8_t), &x)
-#define BOX_UINT64(x) mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(uint64_t), &x)
-#define BOX_UINT32(x) mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(uint32_t), &x)
-#define BOX_UINT16(x) mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(uint16_t), &x)
-#define BOX_UINT8(x) mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(uint8_t), &x)
-#define BOX_BOOLEAN(x) mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(bool), &x)
-#define BOX_PTR(x) mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(IntPtr), x)
-#define BOX_ENUM(m_enum_class, x) mono_value_box(mono_domain_get(), m_enum_class, &x)
-
 Variant::Type managed_to_variant_type(const ManagedType &p_type, bool *r_nil_is_variant = nullptr);
 
 bool try_get_array_element_type(const ManagedType &p_array_type, ManagedType &r_elem_type);
@@ -90,516 +70,37 @@ _FORCE_INLINE_ MonoString *mono_string_from_godot(const String &p_string) {
 
 // Variant
 
-size_t variant_get_managed_unboxed_size(const ManagedType &p_type);
-void *variant_to_managed_unboxed(const Variant &p_var, const ManagedType &p_type, void *r_buffer, unsigned int &r_offset);
-MonoObject *variant_to_mono_object(const Variant &p_var, const ManagedType &p_type);
+MonoObject *variant_to_mono_object_of_type(const Variant &p_var, const ManagedType &p_type);
 
 MonoObject *variant_to_mono_object(const Variant &p_var);
-MonoArray *variant_to_mono_array(const Variant &p_var, GDMonoClass *p_type_class);
-MonoObject *variant_to_mono_object_of_class(const Variant &p_var, GDMonoClass *p_type_class);
-MonoObject *variant_to_mono_object_of_genericinst(const Variant &p_var, GDMonoClass *p_type_class);
-MonoString *variant_to_mono_string(const Variant &p_var);
 
 // These overloads were added to avoid passing a `const Variant *` to the `const Variant &`
 // parameter. That would result in the `Variant(bool)` copy constructor being called as
 // pointers are implicitly converted to bool. Implicit conversions are f-ing evil.
 
-_FORCE_INLINE_ void *variant_to_managed_unboxed(const Variant *p_var, const ManagedType &p_type, void *r_buffer, unsigned int &r_offset) {
-	return variant_to_managed_unboxed(*p_var, p_type, r_buffer, r_offset);
-}
-_FORCE_INLINE_ MonoObject *variant_to_mono_object(const Variant *p_var, const ManagedType &p_type) {
-	return variant_to_mono_object(*p_var, p_type);
+_FORCE_INLINE_ MonoObject *variant_to_mono_object_of_type(const Variant *p_var, const ManagedType &p_type) {
+	return variant_to_mono_object_of_type(*p_var, p_type);
 }
 _FORCE_INLINE_ MonoObject *variant_to_mono_object(const Variant *p_var) {
 	return variant_to_mono_object(*p_var);
 }
-_FORCE_INLINE_ MonoArray *variant_to_mono_array(const Variant *p_var, GDMonoClass *p_type_class) {
-	return variant_to_mono_array(*p_var, p_type_class);
-}
-_FORCE_INLINE_ MonoObject *variant_to_mono_object_of_class(const Variant *p_var, GDMonoClass *p_type_class) {
-	return variant_to_mono_object_of_class(*p_var, p_type_class);
-}
-_FORCE_INLINE_ MonoObject *variant_to_mono_object_of_genericinst(const Variant *p_var, GDMonoClass *p_type_class) {
-	return variant_to_mono_object_of_genericinst(*p_var, p_type_class);
-}
-_FORCE_INLINE_ MonoString *variant_to_mono_string(const Variant *p_var) {
-	return variant_to_mono_string(*p_var);
-}
 
 Variant mono_object_to_variant(MonoObject *p_obj);
-Variant mono_object_to_variant(MonoObject *p_obj, const ManagedType &p_type);
-Variant mono_object_to_variant_no_err(MonoObject *p_obj, const ManagedType &p_type);
+Variant mono_object_to_variant_no_err(MonoObject *p_obj);
 
 /// Tries to convert the MonoObject* to Variant and then convert the Variant to String.
 /// If the MonoObject* cannot be converted to Variant, then 'ToString()' is called instead.
 String mono_object_to_variant_string(MonoObject *p_obj, MonoException **r_exc);
 
-// System.Collections.Generic
-
-MonoObject *Dictionary_to_system_generic_dict(const Dictionary &p_dict, GDMonoClass *p_class, MonoReflectionType *p_key_reftype, MonoReflectionType *p_value_reftype);
-Dictionary system_generic_dict_to_Dictionary(MonoObject *p_obj, GDMonoClass *p_class, MonoReflectionType *p_key_reftype, MonoReflectionType *p_value_reftype);
-
-MonoObject *Array_to_system_generic_list(const Array &p_array, GDMonoClass *p_class, MonoReflectionType *p_elem_reftype);
-Variant system_generic_list_to_Array_variant(MonoObject *p_obj, GDMonoClass *p_class, MonoReflectionType *p_elem_reftype);
-
 // Array
 
 MonoArray *Array_to_mono_array(const Array &p_array);
-MonoArray *Array_to_mono_array(const Array &p_array, MonoClass *p_array_type_class);
 Array mono_array_to_Array(MonoArray *p_array);
 
-// PackedInt32Array
-
-MonoArray *PackedInt32Array_to_mono_array(const PackedInt32Array &p_array);
-PackedInt32Array mono_array_to_PackedInt32Array(MonoArray *p_array);
-
-// PackedInt64Array
-
-MonoArray *PackedInt64Array_to_mono_array(const PackedInt64Array &p_array);
-PackedInt64Array mono_array_to_PackedInt64Array(MonoArray *p_array);
-
-// PackedByteArray
-
-MonoArray *PackedByteArray_to_mono_array(const PackedByteArray &p_array);
-PackedByteArray mono_array_to_PackedByteArray(MonoArray *p_array);
-
-// PackedFloat32Array
-
-MonoArray *PackedFloat32Array_to_mono_array(const PackedFloat32Array &p_array);
-PackedFloat32Array mono_array_to_PackedFloat32Array(MonoArray *p_array);
-
-// PackedFloat64Array
-
-MonoArray *PackedFloat64Array_to_mono_array(const PackedFloat64Array &p_array);
-PackedFloat64Array mono_array_to_PackedFloat64Array(MonoArray *p_array);
-
 // PackedStringArray
 
 MonoArray *PackedStringArray_to_mono_array(const PackedStringArray &p_array);
-PackedStringArray mono_array_to_PackedStringArray(MonoArray *p_array);
-
-// PackedColorArray
-
-MonoArray *PackedColorArray_to_mono_array(const PackedColorArray &p_array);
-PackedColorArray mono_array_to_PackedColorArray(MonoArray *p_array);
-
-// PackedVector2Array
-
-MonoArray *PackedVector2Array_to_mono_array(const PackedVector2Array &p_array);
-PackedVector2Array mono_array_to_PackedVector2Array(MonoArray *p_array);
-
-// PackedVector3Array
-
-MonoArray *PackedVector3Array_to_mono_array(const PackedVector3Array &p_array);
-PackedVector3Array mono_array_to_PackedVector3Array(MonoArray *p_array);
-
-#pragma pack(push, 1)
-
-struct M_Callable {
-	MonoObject *target = nullptr;
-	MonoObject *method_string_name = nullptr;
-	MonoDelegate *delegate = nullptr;
-};
-
-struct M_SignalInfo {
-	MonoObject *owner = nullptr;
-	MonoObject *name_string_name = nullptr;
-};
-
-#pragma pack(pop)
-
-// Callable
-Callable managed_to_callable(const M_Callable &p_managed_callable);
-M_Callable callable_to_managed(const Callable &p_callable);
-
-// SignalInfo
-Signal managed_to_signal_info(const M_SignalInfo &p_managed_signal);
-M_SignalInfo signal_info_to_managed(const Signal &p_signal);
-
-// Structures
-
-namespace InteropLayout {
-
-enum {
-	MATCHES_int = (sizeof(int32_t) == sizeof(uint32_t)),
-
-	MATCHES_float = (sizeof(float) == sizeof(uint32_t)),
-
-	MATCHES_double = (sizeof(double) == sizeof(uint64_t)),
-
-#ifdef REAL_T_IS_DOUBLE
-	MATCHES_real_t = (sizeof(real_t) == sizeof(uint64_t)),
-#else
-	MATCHES_real_t = (sizeof(real_t) == sizeof(uint32_t)),
-#endif
-
-	MATCHES_Vector2 = (MATCHES_real_t && (sizeof(Vector2) == (sizeof(real_t) * 2)) &&
-			offsetof(Vector2, x) == (sizeof(real_t) * 0) &&
-			offsetof(Vector2, y) == (sizeof(real_t) * 1)),
-
-	MATCHES_Vector2i = (MATCHES_int && (sizeof(Vector2i) == (sizeof(int32_t) * 2)) &&
-			offsetof(Vector2i, x) == (sizeof(int32_t) * 0) &&
-			offsetof(Vector2i, y) == (sizeof(int32_t) * 1)),
-
-	MATCHES_Rect2 = (MATCHES_Vector2 && (sizeof(Rect2) == (sizeof(Vector2) * 2)) &&
-			offsetof(Rect2, position) == (sizeof(Vector2) * 0) &&
-			offsetof(Rect2, size) == (sizeof(Vector2) * 1)),
-
-	MATCHES_Rect2i = (MATCHES_Vector2i && (sizeof(Rect2i) == (sizeof(Vector2i) * 2)) &&
-			offsetof(Rect2i, position) == (sizeof(Vector2i) * 0) &&
-			offsetof(Rect2i, size) == (sizeof(Vector2i) * 1)),
-
-	MATCHES_Transform2D = (MATCHES_Vector2 && (sizeof(Transform2D) == (sizeof(Vector2) * 3))), // No field offset required, it stores an array
-
-	MATCHES_Vector3 = (MATCHES_real_t && (sizeof(Vector3) == (sizeof(real_t) * 3)) &&
-			offsetof(Vector3, x) == (sizeof(real_t) * 0) &&
-			offsetof(Vector3, y) == (sizeof(real_t) * 1) &&
-			offsetof(Vector3, z) == (sizeof(real_t) * 2)),
-
-	MATCHES_Vector4 = (MATCHES_real_t && (sizeof(Vector4) == (sizeof(real_t) * 4)) &&
-			offsetof(Vector4, x) == (sizeof(real_t) * 0) &&
-			offsetof(Vector4, y) == (sizeof(real_t) * 1) &&
-			offsetof(Vector4, z) == (sizeof(real_t) * 2) &&
-			offsetof(Vector4, w) == (sizeof(real_t) * 3)),
-
-	MATCHES_Vector4i = (MATCHES_int && (sizeof(Vector4i) == (sizeof(int32_t) * 4)) &&
-			offsetof(Vector4i, x) == (sizeof(int32_t) * 0) &&
-			offsetof(Vector4i, y) == (sizeof(int32_t) * 1) &&
-			offsetof(Vector4i, z) == (sizeof(int32_t) * 2) &&
-			offsetof(Vector4i, w) == (sizeof(int32_t) * 3)),
-
-	MATCHES_Vector3i = (MATCHES_int && (sizeof(Vector3i) == (sizeof(int32_t) * 3)) &&
-			offsetof(Vector3i, x) == (sizeof(int32_t) * 0) &&
-			offsetof(Vector3i, y) == (sizeof(int32_t) * 1) &&
-			offsetof(Vector3i, z) == (sizeof(int32_t) * 2)),
-
-	MATCHES_Basis = (MATCHES_Vector3 && (sizeof(Basis) == (sizeof(Vector3) * 3))), // No field offset required, it stores an array
-
-	MATCHES_Quaternion = (MATCHES_real_t && (sizeof(Quaternion) == (sizeof(real_t) * 4)) &&
-			offsetof(Quaternion, x) == (sizeof(real_t) * 0) &&
-			offsetof(Quaternion, y) == (sizeof(real_t) * 1) &&
-			offsetof(Quaternion, z) == (sizeof(real_t) * 2) &&
-			offsetof(Quaternion, w) == (sizeof(real_t) * 3)),
-
-	MATCHES_Transform3D = (MATCHES_Basis && MATCHES_Vector3 && (sizeof(Transform3D) == (sizeof(Basis) + sizeof(Vector3))) &&
-			offsetof(Transform3D, basis) == 0 &&
-			offsetof(Transform3D, origin) == sizeof(Basis)),
-
-	MATCHES_Projection = (MATCHES_Vector4 && (sizeof(Projection) == (sizeof(Vector4) * 4))),
-
-	MATCHES_AABB = (MATCHES_Vector3 && (sizeof(AABB) == (sizeof(Vector3) * 2)) &&
-			offsetof(AABB, position) == (sizeof(Vector3) * 0) &&
-			offsetof(AABB, size) == (sizeof(Vector3) * 1)),
-
-	MATCHES_Color = (MATCHES_float && (sizeof(Color) == (sizeof(float) * 4)) &&
-			offsetof(Color, r) == (sizeof(float) * 0) &&
-			offsetof(Color, g) == (sizeof(float) * 1) &&
-			offsetof(Color, b) == (sizeof(float) * 2) &&
-			offsetof(Color, a) == (sizeof(float) * 3)),
-
-	MATCHES_Plane = (MATCHES_Vector3 && MATCHES_real_t && (sizeof(Plane) == (sizeof(Vector3) + sizeof(real_t))) &&
-			offsetof(Plane, normal) == 0 &&
-			offsetof(Plane, d) == sizeof(Vector3))
-};
-
-// In the future we may force this if we want to ref return these structs
-#ifdef GD_MONO_FORCE_INTEROP_STRUCT_COPY
-/* clang-format off */
-static_assert(MATCHES_Vector2 && MATCHES_Rect2 && MATCHES_Transform2D && MATCHES_Vector3 && MATCHES_Vector4 &&
-				MATCHES_Basis && MATCHES_Quaternion && MATCHES_Transform3D && MATCHES_Projection && MATCHES_AABB && MATCHES_Color &&
-				MATCHES_Plane && MATCHES_Vector2i && MATCHES_Rect2i && MATCHES_Vector3i && MATCHES_Vector4i);
-/* clang-format on */
-#endif
-} // namespace InteropLayout
-
-#pragma pack(push, 1)
-
-struct M_Vector2 {
-	real_t x, y;
-
-	static _FORCE_INLINE_ Vector2 convert_to(const M_Vector2 &p_from) {
-		return Vector2(p_from.x, p_from.y);
-	}
-
-	static _FORCE_INLINE_ M_Vector2 convert_from(const Vector2 &p_from) {
-		M_Vector2 ret = { p_from.x, p_from.y };
-		return ret;
-	}
-};
-
-struct M_Vector2i {
-	int32_t x, y;
-
-	static _FORCE_INLINE_ Vector2i convert_to(const M_Vector2i &p_from) {
-		return Vector2i(p_from.x, p_from.y);
-	}
-
-	static _FORCE_INLINE_ M_Vector2i convert_from(const Vector2i &p_from) {
-		M_Vector2i ret = { p_from.x, p_from.y };
-		return ret;
-	}
-};
-
-struct M_Rect2 {
-	M_Vector2 position;
-	M_Vector2 size;
-
-	static _FORCE_INLINE_ Rect2 convert_to(const M_Rect2 &p_from) {
-		return Rect2(M_Vector2::convert_to(p_from.position),
-				M_Vector2::convert_to(p_from.size));
-	}
-
-	static _FORCE_INLINE_ M_Rect2 convert_from(const Rect2 &p_from) {
-		M_Rect2 ret = { M_Vector2::convert_from(p_from.position), M_Vector2::convert_from(p_from.size) };
-		return ret;
-	}
-};
-
-struct M_Rect2i {
-	M_Vector2i position;
-	M_Vector2i size;
-
-	static _FORCE_INLINE_ Rect2i convert_to(const M_Rect2i &p_from) {
-		return Rect2i(M_Vector2i::convert_to(p_from.position),
-				M_Vector2i::convert_to(p_from.size));
-	}
-
-	static _FORCE_INLINE_ M_Rect2i convert_from(const Rect2i &p_from) {
-		M_Rect2i ret = { M_Vector2i::convert_from(p_from.position), M_Vector2i::convert_from(p_from.size) };
-		return ret;
-	}
-};
-
-struct M_Transform2D {
-	M_Vector2 elements[3];
-
-	static _FORCE_INLINE_ Transform2D convert_to(const M_Transform2D &p_from) {
-		return Transform2D(p_from.elements[0].x, p_from.elements[0].y,
-				p_from.elements[1].x, p_from.elements[1].y,
-				p_from.elements[2].x, p_from.elements[2].y);
-	}
-
-	static _FORCE_INLINE_ M_Transform2D convert_from(const Transform2D &p_from) {
-		M_Transform2D ret = {
-			M_Vector2::convert_from(p_from.columns[0]),
-			M_Vector2::convert_from(p_from.columns[1]),
-			M_Vector2::convert_from(p_from.columns[2])
-		};
-		return ret;
-	}
-};
-
-struct M_Vector3 {
-	real_t x, y, z;
-
-	static _FORCE_INLINE_ Vector3 convert_to(const M_Vector3 &p_from) {
-		return Vector3(p_from.x, p_from.y, p_from.z);
-	}
-
-	static _FORCE_INLINE_ M_Vector3 convert_from(const Vector3 &p_from) {
-		M_Vector3 ret = { p_from.x, p_from.y, p_from.z };
-		return ret;
-	}
-};
-
-struct M_Vector3i {
-	int32_t x, y, z;
-
-	static _FORCE_INLINE_ Vector3i convert_to(const M_Vector3i &p_from) {
-		return Vector3i(p_from.x, p_from.y, p_from.z);
-	}
-
-	static _FORCE_INLINE_ M_Vector3i convert_from(const Vector3i &p_from) {
-		M_Vector3i ret = { p_from.x, p_from.y, p_from.z };
-		return ret;
-	}
-};
-
-struct M_Vector4 {
-	real_t x, y, z, w;
-
-	static _FORCE_INLINE_ Vector4 convert_to(const M_Vector4 &p_from) {
-		return Vector4(p_from.x, p_from.y, p_from.z, p_from.w);
-	}
-
-	static _FORCE_INLINE_ M_Vector4 convert_from(const Vector4 &p_from) {
-		M_Vector4 ret = { p_from.x, p_from.y, p_from.z, p_from.w };
-		return ret;
-	}
-};
-
-struct M_Vector4i {
-	int32_t x, y, z, w;
-
-	static _FORCE_INLINE_ Vector4i convert_to(const M_Vector4i &p_from) {
-		return Vector4i(p_from.x, p_from.y, p_from.z, p_from.w);
-	}
-
-	static _FORCE_INLINE_ M_Vector4i convert_from(const Vector4i &p_from) {
-		M_Vector4i ret = { p_from.x, p_from.y, p_from.z, p_from.w };
-		return ret;
-	}
-};
-
-struct M_Basis {
-	M_Vector3 elements[3];
-
-	static _FORCE_INLINE_ Basis convert_to(const M_Basis &p_from) {
-		return Basis(M_Vector3::convert_to(p_from.elements[0]),
-				M_Vector3::convert_to(p_from.elements[1]),
-				M_Vector3::convert_to(p_from.elements[2]));
-	}
-
-	static _FORCE_INLINE_ M_Basis convert_from(const Basis &p_from) {
-		M_Basis ret = {
-			M_Vector3::convert_from(p_from.rows[0]),
-			M_Vector3::convert_from(p_from.rows[1]),
-			M_Vector3::convert_from(p_from.rows[2])
-		};
-		return ret;
-	}
-};
-
-struct M_Quaternion {
-	real_t x, y, z, w;
-
-	static _FORCE_INLINE_ Quaternion convert_to(const M_Quaternion &p_from) {
-		return Quaternion(p_from.x, p_from.y, p_from.z, p_from.w);
-	}
-
-	static _FORCE_INLINE_ M_Quaternion convert_from(const Quaternion &p_from) {
-		M_Quaternion ret = { p_from.x, p_from.y, p_from.z, p_from.w };
-		return ret;
-	}
-};
-
-struct M_Transform3D {
-	M_Basis basis;
-	M_Vector3 origin;
-
-	static _FORCE_INLINE_ Transform3D convert_to(const M_Transform3D &p_from) {
-		return Transform3D(M_Basis::convert_to(p_from.basis), M_Vector3::convert_to(p_from.origin));
-	}
-
-	static _FORCE_INLINE_ M_Transform3D convert_from(const Transform3D &p_from) {
-		M_Transform3D ret = { M_Basis::convert_from(p_from.basis), M_Vector3::convert_from(p_from.origin) };
-		return ret;
-	}
-};
-
-struct M_Projection {
-	M_Vector4 vec1;
-	M_Vector4 vec2;
-	M_Vector4 vec3;
-	M_Vector4 vec4;
-
-	static _FORCE_INLINE_ Projection convert_to(const M_Projection &p_from) {
-		return Projection(M_Vector4::convert_to(p_from.vec1), M_Vector4::convert_to(p_from.vec2), M_Vector4::convert_to(p_from.vec3), M_Vector4::convert_to(p_from.vec4));
-	}
-
-	static _FORCE_INLINE_ M_Projection convert_from(const Projection &p_from) {
-		M_Projection ret = { M_Vector4::convert_from(p_from.matrix[0]), M_Vector4::convert_from(p_from.matrix[1]), M_Vector4::convert_from(p_from.matrix[2]), M_Vector4::convert_from(p_from.matrix[3]) };
-		return ret;
-	}
-};
-
-struct M_AABB {
-	M_Vector3 position;
-	M_Vector3 size;
-
-	static _FORCE_INLINE_ AABB convert_to(const M_AABB &p_from) {
-		return AABB(M_Vector3::convert_to(p_from.position), M_Vector3::convert_to(p_from.size));
-	}
-
-	static _FORCE_INLINE_ M_AABB convert_from(const AABB &p_from) {
-		M_AABB ret = { M_Vector3::convert_from(p_from.position), M_Vector3::convert_from(p_from.size) };
-		return ret;
-	}
-};
-
-struct M_Color {
-	float r, g, b, a;
-
-	static _FORCE_INLINE_ Color convert_to(const M_Color &p_from) {
-		return Color(p_from.r, p_from.g, p_from.b, p_from.a);
-	}
-
-	static _FORCE_INLINE_ M_Color convert_from(const Color &p_from) {
-		M_Color ret = { p_from.r, p_from.g, p_from.b, p_from.a };
-		return ret;
-	}
-};
-
-struct M_Plane {
-	M_Vector3 normal;
-	real_t d;
-
-	static _FORCE_INLINE_ Plane convert_to(const M_Plane &p_from) {
-		return Plane(M_Vector3::convert_to(p_from.normal), p_from.d);
-	}
-
-	static _FORCE_INLINE_ M_Plane convert_from(const Plane &p_from) {
-		M_Plane ret = { M_Vector3::convert_from(p_from.normal), p_from.d };
-		return ret;
-	}
-};
-
-#pragma pack(pop)
-
-#define DECL_TYPE_MARSHAL_TEMPLATES(m_type)                                             \
-	template <int>                                                                      \
-	_FORCE_INLINE_ m_type marshalled_in_##m_type##_impl(const M_##m_type *p_from);      \
-                                                                                        \
-	template <>                                                                         \
-	_FORCE_INLINE_ m_type marshalled_in_##m_type##_impl<0>(const M_##m_type *p_from) {  \
-		return M_##m_type::convert_to(*p_from);                                         \
-	}                                                                                   \
-                                                                                        \
-	template <>                                                                         \
-	_FORCE_INLINE_ m_type marshalled_in_##m_type##_impl<1>(const M_##m_type *p_from) {  \
-		return *reinterpret_cast<const m_type *>(p_from);                               \
-	}                                                                                   \
-                                                                                        \
-	_FORCE_INLINE_ m_type marshalled_in_##m_type(const M_##m_type *p_from) {            \
-		return marshalled_in_##m_type##_impl<InteropLayout::MATCHES_##m_type>(p_from);  \
-	}                                                                                   \
-                                                                                        \
-	template <int>                                                                      \
-	_FORCE_INLINE_ M_##m_type marshalled_out_##m_type##_impl(const m_type &p_from);     \
-                                                                                        \
-	template <>                                                                         \
-	_FORCE_INLINE_ M_##m_type marshalled_out_##m_type##_impl<0>(const m_type &p_from) { \
-		return M_##m_type::convert_from(p_from);                                        \
-	}                                                                                   \
-                                                                                        \
-	template <>                                                                         \
-	_FORCE_INLINE_ M_##m_type marshalled_out_##m_type##_impl<1>(const m_type &p_from) { \
-		return *reinterpret_cast<const M_##m_type *>(&p_from);                          \
-	}                                                                                   \
-                                                                                        \
-	_FORCE_INLINE_ M_##m_type marshalled_out_##m_type(const m_type &p_from) {           \
-		return marshalled_out_##m_type##_impl<InteropLayout::MATCHES_##m_type>(p_from); \
-	}
-
-DECL_TYPE_MARSHAL_TEMPLATES(Vector2)
-DECL_TYPE_MARSHAL_TEMPLATES(Vector2i)
-DECL_TYPE_MARSHAL_TEMPLATES(Rect2)
-DECL_TYPE_MARSHAL_TEMPLATES(Rect2i)
-DECL_TYPE_MARSHAL_TEMPLATES(Transform2D)
-DECL_TYPE_MARSHAL_TEMPLATES(Vector3)
-DECL_TYPE_MARSHAL_TEMPLATES(Vector3i)
-DECL_TYPE_MARSHAL_TEMPLATES(Basis)
-DECL_TYPE_MARSHAL_TEMPLATES(Vector4)
-DECL_TYPE_MARSHAL_TEMPLATES(Vector4i)
-DECL_TYPE_MARSHAL_TEMPLATES(Quaternion)
-DECL_TYPE_MARSHAL_TEMPLATES(Transform3D)
-DECL_TYPE_MARSHAL_TEMPLATES(Projection)
-DECL_TYPE_MARSHAL_TEMPLATES(AABB)
-DECL_TYPE_MARSHAL_TEMPLATES(Color)
-DECL_TYPE_MARSHAL_TEMPLATES(Plane)
 
-#define MARSHALLED_IN(m_type, m_from_ptr) (GDMonoMarshal::marshalled_in_##m_type(m_from_ptr))
-#define MARSHALLED_OUT(m_type, m_from) (GDMonoMarshal::marshalled_out_##m_type(m_from))
 } // namespace GDMonoMarshal
 
 #endif // GD_MONO_MARSHAL_H
diff --git a/modules/mono/mono_gd/gd_mono_method.cpp b/modules/mono/mono_gd/gd_mono_method.cpp
index 6734b44783..04f6005338 100644
--- a/modules/mono/mono_gd/gd_mono_method.cpp
+++ b/modules/mono/mono_gd/gd_mono_method.cpp
@@ -75,10 +75,6 @@ void GDMonoMethod::_update_signature(MonoMethodSignature *p_method_sig) {
 	// clear the cache
 	method_info_fetched = false;
 	method_info = MethodInfo();
-
-	for (int i = 0; i < params_count; i++) {
-		params_buffer_size += GDMonoMarshal::variant_get_managed_unboxed_size(param_types[i]);
-	}
 }
 
 GDMonoClass *GDMonoMethod::get_enclosing_class() const {
@@ -111,15 +107,14 @@ MonoObject *GDMonoMethod::invoke(MonoObject *p_object, const Variant **p_params,
 	MonoObject *ret;
 
 	if (params_count > 0) {
-		void **params = (void **)alloca(params_count * sizeof(void *));
-		uint8_t *buffer = (uint8_t *)alloca(params_buffer_size);
-		unsigned int offset = 0;
+		MonoArray *params = mono_array_new(mono_domain_get(), CACHED_CLASS_RAW(MonoObject), get_parameters_count());
 
 		for (int i = 0; i < params_count; i++) {
-			params[i] = GDMonoMarshal::variant_to_managed_unboxed(p_params[i], param_types[i], buffer + offset, offset);
+			MonoObject *boxed_param = GDMonoMarshal::variant_to_mono_object_of_type(p_params[i], param_types[i]);
+			mono_array_setref(params, i, boxed_param);
 		}
 
-		ret = GDMonoUtils::runtime_invoke(mono_method, p_object, params, &exc);
+		ret = GDMonoUtils::runtime_invoke_array(mono_method, p_object, params, &exc);
 	} else {
 		ret = GDMonoUtils::runtime_invoke(mono_method, p_object, nullptr, &exc);
 	}
diff --git a/modules/mono/mono_gd/gd_mono_method.h b/modules/mono/mono_gd/gd_mono_method.h
index be11ef5bfe..5398f34103 100644
--- a/modules/mono/mono_gd/gd_mono_method.h
+++ b/modules/mono/mono_gd/gd_mono_method.h
@@ -39,7 +39,6 @@ class GDMonoMethod : public IMonoClassMember {
 	StringName name;
 
 	uint16_t params_count;
-	unsigned int params_buffer_size = 0;
 	ManagedType return_type;
 	Vector<ManagedType> param_types;
 
diff --git a/modules/mono/mono_gd/gd_mono_property.cpp b/modules/mono/mono_gd/gd_mono_property.cpp
index c9775ae9cb..7cbf5be151 100644
--- a/modules/mono/mono_gd/gd_mono_property.cpp
+++ b/modules/mono/mono_gd/gd_mono_property.cpp
@@ -65,8 +65,6 @@ GDMonoProperty::GDMonoProperty(MonoProperty *p_mono_property, GDMonoClass *p_own
 		type.type_class = GDMono::get_singleton()->get_class(param_type_class);
 	}
 
-	param_buffer_size = GDMonoMarshal::variant_get_managed_unboxed_size(type);
-
 	attrs_fetched = false;
 	attributes = nullptr;
 }
@@ -150,19 +148,16 @@ bool GDMonoProperty::has_setter() {
 }
 
 void GDMonoProperty::set_value_from_variant(MonoObject *p_object, const Variant &p_value, MonoException **r_exc) {
-	uint8_t *buffer = (uint8_t *)alloca(param_buffer_size);
-	unsigned int offset = 0;
-
-	void *params[1] = {
-		GDMonoMarshal::variant_to_managed_unboxed(p_value, type, buffer, offset)
-	};
+	MonoMethod *set_method = mono_property_get_set_method(mono_property);
+	ERR_FAIL_COND(set_method == nullptr);
 
-#ifdef DEBUG_ENABLED
-	CRASH_COND(offset != param_buffer_size);
-#endif
+	// Temporary solution, while moving code to C#
+	MonoArray *params = mono_array_new(mono_domain_get(), CACHED_CLASS_RAW(MonoObject), 1);
+	MonoObject *boxed_param = GDMonoMarshal::variant_to_mono_object_of_type(p_value, type);
+	mono_array_setref(params, 0, boxed_param);
 
 	MonoException *exc = nullptr;
-	GDMonoUtils::property_set_value(mono_property, p_object, params, &exc);
+	GDMonoUtils::runtime_invoke_array(set_method, p_object, params, &exc);
 	if (exc) {
 		if (r_exc) {
 			*r_exc = exc;
diff --git a/modules/mono/mono_gd/gd_mono_property.h b/modules/mono/mono_gd/gd_mono_property.h
index 6fc681aeb5..885ea8f011 100644
--- a/modules/mono/mono_gd/gd_mono_property.h
+++ b/modules/mono/mono_gd/gd_mono_property.h
@@ -45,8 +45,6 @@ class GDMonoProperty : public IMonoClassMember {
 	bool attrs_fetched;
 	MonoCustomAttrInfo *attributes = nullptr;
 
-	unsigned int param_buffer_size;
-
 public:
 	virtual GDMonoClass *get_enclosing_class() const final { return owner; }
 
diff --git a/modules/mono/mono_gd/gd_mono_utils.cpp b/modules/mono/mono_gd/gd_mono_utils.cpp
index 1983d6ebe2..e240381112 100644
--- a/modules/mono/mono_gd/gd_mono_utils.cpp
+++ b/modules/mono/mono_gd/gd_mono_utils.cpp
@@ -5,8 +5,8 @@
 /*                           GODOT ENGINE                                */
 /*                      https://godotengine.org                          */
 /*************************************************************************/
-/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2021 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       */
@@ -170,13 +170,6 @@ void runtime_object_init(MonoObject *p_this_obj, GDMonoClass *p_class, MonoExcep
 	ctor->invoke_raw(p_this_obj, nullptr, r_exc);
 }
 
-bool mono_delegate_equal(MonoDelegate *p_a, MonoDelegate *p_b) {
-	MonoException *exc = nullptr;
-	MonoBoolean res = CACHED_METHOD_THUNK(Delegate, Equals).invoke((MonoObject *)p_a, (MonoObject *)p_b, &exc);
-	UNHANDLED_EXCEPTION(exc);
-	return (bool)res;
-}
-
 GDMonoClass *get_object_class(MonoObject *p_object) {
 	return GDMono::get_singleton()->get_class(mono_object_get_class(p_object));
 }
@@ -239,102 +232,6 @@ MonoObject *create_managed_for_godot_object(GDMonoClass *p_class, const StringNa
 	return mono_object;
 }
 
-MonoObject *create_managed_from(const StringName &p_from) {
-	MonoObject *mono_object = mono_object_new(mono_domain_get(), CACHED_CLASS_RAW(StringName));
-	ERR_FAIL_NULL_V(mono_object, nullptr);
-
-	// Construct
-	GDMonoUtils::runtime_object_init(mono_object, CACHED_CLASS(StringName));
-
-	CACHED_FIELD(StringName, ptr)->set_value_raw(mono_object, memnew(StringName(p_from)));
-
-	return mono_object;
-}
-
-MonoObject *create_managed_from(const NodePath &p_from) {
-	MonoObject *mono_object = mono_object_new(mono_domain_get(), CACHED_CLASS_RAW(NodePath));
-	ERR_FAIL_NULL_V(mono_object, nullptr);
-
-	// Construct
-	GDMonoUtils::runtime_object_init(mono_object, CACHED_CLASS(NodePath));
-
-	CACHED_FIELD(NodePath, ptr)->set_value_raw(mono_object, memnew(NodePath(p_from)));
-
-	return mono_object;
-}
-
-MonoObject *create_managed_from(const RID &p_from) {
-	MonoObject *mono_object = mono_object_new(mono_domain_get(), CACHED_CLASS_RAW(RID));
-	ERR_FAIL_NULL_V(mono_object, nullptr);
-
-	// Construct
-	GDMonoUtils::runtime_object_init(mono_object, CACHED_CLASS(RID));
-
-	CACHED_FIELD(RID, ptr)->set_value_raw(mono_object, memnew(RID(p_from)));
-
-	return mono_object;
-}
-
-MonoObject *create_managed_from(const Array &p_from, GDMonoClass *p_class) {
-	MonoObject *mono_object = mono_object_new(mono_domain_get(), p_class->get_mono_ptr());
-	ERR_FAIL_NULL_V(mono_object, nullptr);
-
-	// Search constructor that takes a pointer as parameter
-	MonoMethod *m;
-	void *iter = nullptr;
-	while ((m = mono_class_get_methods(p_class->get_mono_ptr(), &iter))) {
-		if (strcmp(mono_method_get_name(m), ".ctor") == 0) {
-			MonoMethodSignature *sig = mono_method_signature(m);
-			void *front = nullptr;
-			if (mono_signature_get_param_count(sig) == 1 &&
-					mono_class_from_mono_type(mono_signature_get_params(sig, &front)) == CACHED_CLASS(IntPtr)->get_mono_ptr()) {
-				break;
-			}
-		}
-	}
-
-	CRASH_COND(m == nullptr);
-
-	Array *new_array = memnew(Array(p_from));
-	void *args[1] = { &new_array };
-
-	MonoException *exc = nullptr;
-	GDMonoUtils::runtime_invoke(m, mono_object, args, &exc);
-	UNHANDLED_EXCEPTION(exc);
-
-	return mono_object;
-}
-
-MonoObject *create_managed_from(const Dictionary &p_from, GDMonoClass *p_class) {
-	MonoObject *mono_object = mono_object_new(mono_domain_get(), p_class->get_mono_ptr());
-	ERR_FAIL_NULL_V(mono_object, nullptr);
-
-	// Search constructor that takes a pointer as parameter
-	MonoMethod *m;
-	void *iter = nullptr;
-	while ((m = mono_class_get_methods(p_class->get_mono_ptr(), &iter))) {
-		if (strcmp(mono_method_get_name(m), ".ctor") == 0) {
-			MonoMethodSignature *sig = mono_method_signature(m);
-			void *front = nullptr;
-			if (mono_signature_get_param_count(sig) == 1 &&
-					mono_class_from_mono_type(mono_signature_get_params(sig, &front)) == CACHED_CLASS(IntPtr)->get_mono_ptr()) {
-				break;
-			}
-		}
-	}
-
-	CRASH_COND(m == nullptr);
-
-	Dictionary *new_dict = memnew(Dictionary(p_from));
-	void *args[1] = { &new_dict };
-
-	MonoException *exc = nullptr;
-	GDMonoUtils::runtime_invoke(m, mono_object, args, &exc);
-	UNHANDLED_EXCEPTION(exc);
-
-	return mono_object;
-}
-
 MonoDomain *create_domain(const String &p_friendly_name) {
 	print_verbose("Mono: Creating domain '" + p_friendly_name + "'...");
 
@@ -487,6 +384,13 @@ MonoObject *runtime_invoke(MonoMethod *p_method, void *p_obj, void **p_params, M
 	return ret;
 }
 
+MonoObject *runtime_invoke_array(MonoMethod *p_method, void *p_obj, MonoArray *p_params, MonoException **r_exc) {
+	GD_MONO_BEGIN_RUNTIME_INVOKE;
+	MonoObject *ret = mono_runtime_invoke_array(p_method, p_obj, p_params, (MonoObject **)r_exc);
+	GD_MONO_END_RUNTIME_INVOKE;
+	return ret;
+}
+
 MonoString *object_to_string(MonoObject *p_obj, MonoException **r_exc) {
 	GD_MONO_BEGIN_RUNTIME_INVOKE;
 	MonoString *ret = mono_object_to_string(p_obj, (MonoObject **)r_exc);
@@ -558,62 +462,6 @@ namespace Marshal {
 	{ return m_ret; }
 #endif
 
-bool type_is_generic_array(MonoReflectionType *p_reftype) {
-	NO_GLUE_RET(false);
-	MonoException *exc = nullptr;
-	MonoBoolean res = CACHED_METHOD_THUNK(MarshalUtils, TypeIsGenericArray).invoke(p_reftype, &exc);
-	UNHANDLED_EXCEPTION(exc);
-	return (bool)res;
-}
-
-bool type_is_generic_dictionary(MonoReflectionType *p_reftype) {
-	NO_GLUE_RET(false);
-	MonoException *exc = nullptr;
-	MonoBoolean res = CACHED_METHOD_THUNK(MarshalUtils, TypeIsGenericDictionary).invoke(p_reftype, &exc);
-	UNHANDLED_EXCEPTION(exc);
-	return (bool)res;
-}
-
-bool type_is_system_generic_list(MonoReflectionType *p_reftype) {
-	NO_GLUE_RET(false);
-	MonoException *exc = nullptr;
-	MonoBoolean res = CACHED_METHOD_THUNK(MarshalUtils, TypeIsSystemGenericList).invoke(p_reftype, &exc);
-	UNHANDLED_EXCEPTION(exc);
-	return (bool)res;
-}
-
-bool type_is_system_generic_dictionary(MonoReflectionType *p_reftype) {
-	NO_GLUE_RET(false);
-	MonoException *exc = nullptr;
-	MonoBoolean res = CACHED_METHOD_THUNK(MarshalUtils, TypeIsSystemGenericDictionary).invoke(p_reftype, &exc);
-	UNHANDLED_EXCEPTION(exc);
-	return (bool)res;
-}
-
-bool type_is_generic_ienumerable(MonoReflectionType *p_reftype) {
-	NO_GLUE_RET(false);
-	MonoException *exc = nullptr;
-	MonoBoolean res = CACHED_METHOD_THUNK(MarshalUtils, TypeIsGenericIEnumerable).invoke(p_reftype, &exc);
-	UNHANDLED_EXCEPTION(exc);
-	return (bool)res;
-}
-
-bool type_is_generic_icollection(MonoReflectionType *p_reftype) {
-	NO_GLUE_RET(false);
-	MonoException *exc = nullptr;
-	MonoBoolean res = CACHED_METHOD_THUNK(MarshalUtils, TypeIsGenericICollection).invoke(p_reftype, &exc);
-	UNHANDLED_EXCEPTION(exc);
-	return (bool)res;
-}
-
-bool type_is_generic_idictionary(MonoReflectionType *p_reftype) {
-	NO_GLUE_RET(false);
-	MonoException *exc = nullptr;
-	MonoBoolean res = CACHED_METHOD_THUNK(MarshalUtils, TypeIsGenericIDictionary).invoke(p_reftype, &exc);
-	UNHANDLED_EXCEPTION(exc);
-	return (bool)res;
-}
-
 bool type_has_flags_attribute(MonoReflectionType *p_reftype) {
 	NO_GLUE_RET(false);
 	MonoException *exc = nullptr;
@@ -622,39 +470,6 @@ bool type_has_flags_attribute(MonoReflectionType *p_reftype) {
 	return (bool)res;
 }
 
-void get_generic_type_definition(MonoReflectionType *p_reftype, MonoReflectionType **r_generic_reftype) {
-	MonoException *exc = nullptr;
-	CACHED_METHOD_THUNK(MarshalUtils, GetGenericTypeDefinition).invoke(p_reftype, r_generic_reftype, &exc);
-	UNHANDLED_EXCEPTION(exc);
-}
-
-void array_get_element_type(MonoReflectionType *p_array_reftype, MonoReflectionType **r_elem_reftype) {
-	MonoException *exc = nullptr;
-	CACHED_METHOD_THUNK(MarshalUtils, ArrayGetElementType).invoke(p_array_reftype, r_elem_reftype, &exc);
-	UNHANDLED_EXCEPTION(exc);
-}
-
-void dictionary_get_key_value_types(MonoReflectionType *p_dict_reftype, MonoReflectionType **r_key_reftype, MonoReflectionType **r_value_reftype) {
-	MonoException *exc = nullptr;
-	CACHED_METHOD_THUNK(MarshalUtils, DictionaryGetKeyValueTypes).invoke(p_dict_reftype, r_key_reftype, r_value_reftype, &exc);
-	UNHANDLED_EXCEPTION(exc);
-}
-
-GDMonoClass *make_generic_array_type(MonoReflectionType *p_elem_reftype) {
-	NO_GLUE_RET(nullptr);
-	MonoException *exc = nullptr;
-	MonoReflectionType *reftype = CACHED_METHOD_THUNK(MarshalUtils, MakeGenericArrayType).invoke(p_elem_reftype, &exc);
-	UNHANDLED_EXCEPTION(exc);
-	return GDMono::get_singleton()->get_class(mono_class_from_mono_type(mono_reflection_type_get_type(reftype)));
-}
-
-GDMonoClass *make_generic_dictionary_type(MonoReflectionType *p_key_reftype, MonoReflectionType *p_value_reftype) {
-	NO_GLUE_RET(nullptr);
-	MonoException *exc = nullptr;
-	MonoReflectionType *reftype = CACHED_METHOD_THUNK(MarshalUtils, MakeGenericDictionaryType).invoke(p_key_reftype, p_value_reftype, &exc);
-	UNHANDLED_EXCEPTION(exc);
-	return GDMono::get_singleton()->get_class(mono_class_from_mono_type(mono_reflection_type_get_type(reftype)));
-}
 } // namespace Marshal
 
 ScopeThreadAttach::ScopeThreadAttach() {
@@ -671,7 +486,6 @@ ScopeThreadAttach::~ScopeThreadAttach() {
 
 StringName get_native_godot_class_name(GDMonoClass *p_class) {
 	MonoObject *native_name_obj = p_class->get_field(BINDINGS_NATIVE_NAME_FIELD)->get_value(nullptr);
-	StringName *ptr = GDMonoMarshal::unbox<StringName *>(CACHED_FIELD(StringName, ptr)->get_value(native_name_obj));
-	return ptr ? *ptr : StringName();
+	return (StringName)GDMonoMarshal::mono_object_to_variant(native_name_obj);
 }
 } // namespace GDMonoUtils
diff --git a/modules/mono/mono_gd/gd_mono_utils.h b/modules/mono/mono_gd/gd_mono_utils.h
index 300cacfa4b..ee1be979e7 100644
--- a/modules/mono/mono_gd/gd_mono_utils.h
+++ b/modules/mono/mono_gd/gd_mono_utils.h
@@ -5,8 +5,8 @@
 /*                           GODOT ENGINE                                */
 /*                      https://godotengine.org                          */
 /*************************************************************************/
-/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2021 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       */
@@ -53,23 +53,7 @@
 namespace GDMonoUtils {
 
 namespace Marshal {
-
-bool type_is_generic_array(MonoReflectionType *p_reftype);
-bool type_is_generic_dictionary(MonoReflectionType *p_reftype);
-bool type_is_system_generic_list(MonoReflectionType *p_reftype);
-bool type_is_system_generic_dictionary(MonoReflectionType *p_reftype);
-bool type_is_generic_ienumerable(MonoReflectionType *p_reftype);
-bool type_is_generic_icollection(MonoReflectionType *p_reftype);
-bool type_is_generic_idictionary(MonoReflectionType *p_reftype);
 bool type_has_flags_attribute(MonoReflectionType *p_reftype);
-
-void get_generic_type_definition(MonoReflectionType *p_reftype, MonoReflectionType **r_generic_reftype);
-
-void array_get_element_type(MonoReflectionType *p_array_reftype, MonoReflectionType **r_elem_reftype);
-void dictionary_get_key_value_types(MonoReflectionType *p_dict_reftype, MonoReflectionType **r_key_reftype, MonoReflectionType **r_value_reftype);
-
-GDMonoClass *make_generic_array_type(MonoReflectionType *p_elem_reftype);
-GDMonoClass *make_generic_dictionary_type(MonoReflectionType *p_key_reftype, MonoReflectionType *p_value_reftype);
 } // namespace Marshal
 
 _FORCE_INLINE_ void hash_combine(uint32_t &p_hash, const uint32_t &p_with_hash) {
@@ -97,20 +81,12 @@ void free_gchandle(uint32_t p_gchandle);
 
 void runtime_object_init(MonoObject *p_this_obj, GDMonoClass *p_class, MonoException **r_exc = nullptr);
 
-bool mono_delegate_equal(MonoDelegate *p_a, MonoDelegate *p_b);
-
 GDMonoClass *get_object_class(MonoObject *p_object);
 GDMonoClass *type_get_proxy_class(const StringName &p_type);
 GDMonoClass *get_class_native_base(GDMonoClass *p_class);
 
 MonoObject *create_managed_for_godot_object(GDMonoClass *p_class, const StringName &p_native, Object *p_object);
 
-MonoObject *create_managed_from(const StringName &p_from);
-MonoObject *create_managed_from(const NodePath &p_from);
-MonoObject *create_managed_from(const RID &p_from);
-MonoObject *create_managed_from(const Array &p_from, GDMonoClass *p_class);
-MonoObject *create_managed_from(const Dictionary &p_from, GDMonoClass *p_class);
-
 MonoDomain *create_domain(const String &p_friendly_name);
 
 String get_type_desc(MonoType *p_type);
@@ -141,6 +117,7 @@ _FORCE_INLINE_ int &get_runtime_invoke_count_ref() {
 }
 
 MonoObject *runtime_invoke(MonoMethod *p_method, void *p_obj, void **p_params, MonoException **r_exc);
+MonoObject *runtime_invoke_array(MonoMethod *p_method, void *p_obj, MonoArray *p_params, MonoException **r_exc);
 
 MonoString *object_to_string(MonoObject *p_obj, MonoException **r_exc);