10 files changed, 549 insertions, 122 deletions

diff --git a/modules/mono/mono_gd/gd_mono.cpp b/modules/mono/mono_gd/gd_mono.cpp
index f5febd415b..0646580eaa 100644
--- a/modules/mono/mono_gd/gd_mono.cpp
+++ b/modules/mono/mono_gd/gd_mono.cpp
@@ -42,11 +42,15 @@
 #include "project_settings.h"
 
 #include "../csharp_script.h"
+#include "../godotsharp_dirs.h"
 #include "../utils/path_utils.h"
+#include "gd_mono_class.h"
+#include "gd_mono_marshal.h"
 #include "gd_mono_utils.h"
 
 #ifdef TOOLS_ENABLED
 #include "../editor/godotsharp_editor.h"
+#include "main/main.h"
 #endif
 
 void gdmono_unhandled_exception_hook(MonoObject *exc, void *user_data) {
@@ -70,7 +74,31 @@ void gdmono_MonoPrintCallback(const char *string, mono_bool is_stdout) {
 
 GDMono *GDMono::singleton = NULL;
 
+namespace {
+
+void setup_runtime_main_args() {
+	CharString execpath = OS::get_singleton()->get_executable_path().utf8();
+
+	List<String> cmdline_args = OS::get_singleton()->get_cmdline_args();
+
+	List<CharString> cmdline_args_utf8;
+	Vector<char *> main_args;
+	main_args.resize(cmdline_args.size() + 1);
+
+	main_args[0] = execpath.ptrw();
+
+	int i = 1;
+	for (List<String>::Element *E = cmdline_args.front(); E; E = E->next()) {
+		CharString &stored = cmdline_args_utf8.push_back(E->get().utf8())->get();
+		main_args[i] = stored.ptrw();
+		i++;
+	}
+
+	mono_runtime_set_main_args(main_args.size(), main_args.ptrw());
+}
+
 #ifdef DEBUG_ENABLED
+
 static bool _wait_for_debugger_msecs(uint32_t p_msecs) {
 
 	do {
@@ -92,24 +120,7 @@ static bool _wait_for_debugger_msecs(uint32_t p_msecs) {
 
 	return mono_is_debugger_attached();
 }
-#endif
-
-#ifdef TOOLS_ENABLED
-// temporary workaround. should be provided from Main::setup/setup2 instead
-bool _is_project_manager_requested() {
-
-	List<String> cmdline_args = OS::get_singleton()->get_cmdline_args();
-	for (List<String>::Element *E = cmdline_args.front(); E; E = E->next()) {
-		const String &arg = E->get();
-		if (arg == "-p" || arg == "--project-manager")
-			return true;
-	}
-
-	return false;
-}
-#endif
 
-#ifdef DEBUG_ENABLED
 void gdmono_debug_init() {
 
 	mono_debug_init(MONO_DEBUG_FORMAT_MONO);
@@ -121,7 +132,7 @@ void gdmono_debug_init() {
 #ifdef TOOLS_ENABLED
 	if (Engine::get_singleton()->is_editor_hint() ||
 			ProjectSettings::get_singleton()->get_resource_path().empty() ||
-			_is_project_manager_requested()) {
+			Main::is_project_manager()) {
 		return;
 	}
 #endif
@@ -136,8 +147,11 @@ void gdmono_debug_init() {
 	};
 	mono_jit_parse_options(2, (char **)options);
 }
+
 #endif
 
+} // namespace
+
 void GDMono::initialize() {
 
 	ERR_FAIL_NULL(Engine::get_singleton());
@@ -190,6 +204,8 @@ void GDMono::initialize() {
 
 	GDMonoUtils::set_main_thread(GDMonoUtils::get_current_thread());
 
+	setup_runtime_main_args(); // Required for System.Environment.GetCommandLineArgs
+
 	runtime_initialized = true;
 
 	OS::get_singleton()->print("Mono: Runtime initialized\n");
@@ -222,7 +238,46 @@ void GDMono::initialize() {
 	_register_internal_calls();
 
 	// The following assemblies are not required at initialization
-	_load_all_script_assemblies();
+#ifndef MONO_GLUE_DISABLED
+	if (_load_api_assemblies()) {
+		if (!core_api_assembly_out_of_sync && !editor_api_assembly_out_of_sync && GDMonoUtils::mono_cache.godot_api_cache_updated) {
+			// Everything is fine with the api assemblies, load the project assembly
+			_load_project_assembly();
+		} else {
+#ifdef TOOLS_ENABLED
+			// The assembly was successfuly loaded, but the full api could not be cached.
+			// This is most likely an outdated assembly loaded because of an invalid version in the metadata,
+			// so we invalidate the version in the metadata and unload the script domain.
+
+			if (core_api_assembly_out_of_sync) {
+				ERR_PRINT("The loaded Core API assembly is out of sync");
+				metadata_set_api_assembly_invalidated(APIAssembly::API_CORE, true);
+			} else if (!GDMonoUtils::mono_cache.godot_api_cache_updated) {
+				ERR_PRINT("The loaded Core API assembly is in sync, but the cache update failed");
+				metadata_set_api_assembly_invalidated(APIAssembly::API_CORE, true);
+			}
+
+			if (editor_api_assembly_out_of_sync) {
+				ERR_PRINT("The loaded Editor API assembly is out of sync");
+				metadata_set_api_assembly_invalidated(APIAssembly::API_EDITOR, true);
+			}
+
+			OS::get_singleton()->print("Mono: Proceeding to unload scripts domain because of invalid API assemblies\n");
+
+			Error err = _unload_scripts_domain();
+			if (err != OK) {
+				WARN_PRINT("Mono: Failed to unload scripts domain");
+			}
+#else
+			ERR_PRINT("The loaded API assembly is invalid");
+			CRASH_NOW();
+#endif
+		}
+	}
+#else
+	if (OS::get_singleton()->is_stdout_verbose())
+		OS::get_singleton()->print("Mono: Glue disabled, ignoring script assemblies\n");
+#endif
 
 	mono_install_unhandled_exception_hook(gdmono_unhandled_exception_hook, NULL);
 
@@ -233,7 +288,11 @@ void GDMono::initialize() {
 namespace GodotSharpBindings {
 
 uint64_t get_core_api_hash();
+#ifdef TOOLS_ENABLED
 uint64_t get_editor_api_hash();
+#endif // TOOLS_ENABLED
+uint32_t get_bindings_version();
+uint32_t get_cs_glue_version();
 
 void register_generated_icalls();
 } // namespace GodotSharpBindings
@@ -285,43 +344,84 @@ GDMonoAssembly **GDMono::get_loaded_assembly(const String &p_name) {
 	return assemblies[domain_id].getptr(p_name);
 }
 
-bool GDMono::_load_assembly(const String &p_name, GDMonoAssembly **r_assembly) {
+bool GDMono::load_assembly(const String &p_name, GDMonoAssembly **r_assembly, bool p_refonly) {
+
+	CRASH_COND(!r_assembly);
+
+	MonoAssemblyName *aname = mono_assembly_name_new(p_name.utf8());
+	bool result = load_assembly(p_name, aname, r_assembly, p_refonly);
+	mono_assembly_name_free(aname);
+	mono_free(aname);
+
+	return result;
+}
+
+bool GDMono::load_assembly(const String &p_name, MonoAssemblyName *p_aname, GDMonoAssembly **r_assembly, bool p_refonly) {
 
 	CRASH_COND(!r_assembly);
 
 	if (OS::get_singleton()->is_stdout_verbose())
-		OS::get_singleton()->print((String() + "Mono: Loading assembly " + p_name + "...\n").utf8());
+		OS::get_singleton()->print((String() + "Mono: Loading assembly " + p_name + (p_refonly ? " (refonly)" : "") + "...\n").utf8());
 
 	MonoImageOpenStatus status = MONO_IMAGE_OK;
-	MonoAssemblyName *aname = mono_assembly_name_new(p_name.utf8());
-	MonoAssembly *assembly = mono_assembly_load_full(aname, NULL, &status, false);
-	mono_assembly_name_free(aname);
+	MonoAssembly *assembly = mono_assembly_load_full(p_aname, NULL, &status, p_refonly);
 
 	if (!assembly)
 		return false;
 
+	ERR_FAIL_COND_V(status != MONO_IMAGE_OK, false);
+
 	uint32_t domain_id = mono_domain_get_id(mono_domain_get());
 
 	GDMonoAssembly **stored_assembly = assemblies[domain_id].getptr(p_name);
 
-	ERR_FAIL_COND_V(status != MONO_IMAGE_OK, false);
 	ERR_FAIL_COND_V(stored_assembly == NULL, false);
-
 	ERR_FAIL_COND_V((*stored_assembly)->get_assembly() != assembly, false);
+
 	*r_assembly = *stored_assembly;
 
 	if (OS::get_singleton()->is_stdout_verbose())
-		OS::get_singleton()->print(String("Mono: Assembly " + p_name + " loaded from path: " + (*r_assembly)->get_path() + "\n").utf8());
+		OS::get_singleton()->print(String("Mono: Assembly " + p_name + (p_refonly ? " (refonly)" : "") + " loaded from path: " + (*r_assembly)->get_path() + "\n").utf8());
 
 	return true;
 }
 
+APIAssembly::Version APIAssembly::Version::get_from_loaded_assembly(GDMonoAssembly *p_api_assembly, APIAssembly::Type p_api_type) {
+	APIAssembly::Version api_assembly_version;
+
+	const char *nativecalls_name = p_api_type == APIAssembly::API_CORE ?
+										   BINDINGS_CLASS_NATIVECALLS :
+										   BINDINGS_CLASS_NATIVECALLS_EDITOR;
+
+	GDMonoClass *nativecalls_klass = p_api_assembly->get_class(BINDINGS_NAMESPACE, nativecalls_name);
+
+	if (nativecalls_klass) {
+		GDMonoField *api_hash_field = nativecalls_klass->get_field("godot_api_hash");
+		if (api_hash_field)
+			api_assembly_version.godot_api_hash = GDMonoMarshal::unbox<uint64_t>(api_hash_field->get_value(NULL));
+
+		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(NULL));
+
+		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(NULL));
+	}
+
+	return api_assembly_version;
+}
+
+String APIAssembly::to_string(APIAssembly::Type p_type) {
+	return p_type == APIAssembly::API_CORE ? "API_CORE" : "API_EDITOR";
+}
+
 bool GDMono::_load_corlib_assembly() {
 
 	if (corlib_assembly)
 		return true;
 
-	bool success = _load_assembly("mscorlib", &corlib_assembly);
+	bool success = load_assembly("mscorlib", &corlib_assembly);
 
 	if (success)
 		GDMonoUtils::update_corlib_cache();
@@ -331,13 +431,25 @@ bool GDMono::_load_corlib_assembly() {
 
 bool GDMono::_load_core_api_assembly() {
 
-	if (api_assembly)
+	if (core_api_assembly)
 		return true;
 
-	bool success = _load_assembly(API_ASSEMBLY_NAME, &api_assembly);
+#ifdef TOOLS_ENABLED
+	if (metadata_is_api_assembly_invalidated(APIAssembly::API_CORE))
+		return false;
+#endif
 
-	if (success)
+	bool success = load_assembly(API_ASSEMBLY_NAME, &core_api_assembly);
+
+	if (success) {
+#ifndef MONO_GLUE_DISABLED
+		APIAssembly::Version api_assembly_ver = APIAssembly::Version::get_from_loaded_assembly(core_api_assembly, APIAssembly::API_CORE);
+		core_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;
+#endif
 		GDMonoUtils::update_godot_api_cache();
+	}
 
 	return success;
 }
@@ -348,7 +460,23 @@ bool GDMono::_load_editor_api_assembly() {
 	if (editor_api_assembly)
 		return true;
 
-	return _load_assembly(EDITOR_API_ASSEMBLY_NAME, &editor_api_assembly);
+#ifdef TOOLS_ENABLED
+	if (metadata_is_api_assembly_invalidated(APIAssembly::API_EDITOR))
+		return false;
+#endif
+
+	bool success = load_assembly(EDITOR_API_ASSEMBLY_NAME, &editor_api_assembly);
+
+	if (success) {
+#ifndef MONO_GLUE_DISABLED
+		APIAssembly::Version api_assembly_ver = APIAssembly::Version::get_from_loaded_assembly(editor_api_assembly, APIAssembly::API_EDITOR);
+		editor_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;
+#endif
+	}
+
+	return success;
 }
 #endif
 
@@ -360,7 +488,7 @@ bool GDMono::_load_editor_tools_assembly() {
 
 	_GDMONO_SCOPE_DOMAIN_(tools_domain)
 
-	return _load_assembly(EDITOR_TOOLS_ASSEMBLY_NAME, &editor_tools_assembly);
+	return load_assembly(EDITOR_TOOLS_ASSEMBLY_NAME, &editor_tools_assembly);
 }
 #endif
 
@@ -374,17 +502,20 @@ bool GDMono::_load_project_assembly() {
 		name = "UnnamedProject";
 	}
 
-	bool success = _load_assembly(name, &project_assembly);
+	bool success = load_assembly(name, &project_assembly);
 
-	if (success)
+	if (success) {
 		mono_assembly_set_main(project_assembly->get_assembly());
+	} else {
+		if (OS::get_singleton()->is_stdout_verbose())
+			OS::get_singleton()->printerr("Mono: Failed to load project assembly\n");
+	}
 
 	return success;
 }
 
-bool GDMono::_load_all_script_assemblies() {
+bool GDMono::_load_api_assemblies() {
 
-#ifndef MONO_GLUE_DISABLED
 	if (!_load_core_api_assembly()) {
 		if (OS::get_singleton()->is_stdout_verbose())
 			OS::get_singleton()->printerr("Mono: Failed to load Core API assembly\n");
@@ -399,20 +530,72 @@ bool GDMono::_load_all_script_assemblies() {
 #endif
 	}
 
-	if (!_load_project_assembly()) {
-		if (OS::get_singleton()->is_stdout_verbose())
-			OS::get_singleton()->printerr("Mono: Failed to load project assembly\n");
-		return false;
+	return true;
+}
+
+#ifdef TOOLS_ENABLED
+String GDMono::_get_api_assembly_metadata_path() {
+
+	return GodotSharpDirs::get_res_metadata_dir().plus_file("api_assemblies.cfg");
+}
+
+void GDMono::metadata_set_api_assembly_invalidated(APIAssembly::Type p_api_type, bool p_invalidated) {
+
+	String section = APIAssembly::to_string(p_api_type);
+	String path = _get_api_assembly_metadata_path();
+
+	Ref<ConfigFile> metadata;
+	metadata.instance();
+	metadata->load(path);
+
+	metadata->set_value(section, "invalidated", p_invalidated);
+
+	String assembly_path = GodotSharpDirs::get_res_assemblies_dir()
+								   .plus_file(p_api_type == APIAssembly::API_CORE ?
+													  API_ASSEMBLY_NAME ".dll" :
+													  EDITOR_API_ASSEMBLY_NAME ".dll");
+
+	ERR_FAIL_COND(!FileAccess::exists(assembly_path));
+
+	uint64_t modified_time = FileAccess::get_modified_time(assembly_path);
+
+	metadata->set_value(section, "invalidated_asm_modified_time", String::num_uint64(modified_time));
+
+	String dir = path.get_base_dir();
+	if (!DirAccess::exists(dir)) {
+		DirAccessRef da = DirAccess::create(DirAccess::ACCESS_FILESYSTEM);
+		ERR_FAIL_COND(!da);
+		Error err = da->make_dir_recursive(ProjectSettings::get_singleton()->globalize_path(dir));
+		ERR_FAIL_COND(err != OK);
 	}
 
-	return true;
-#else
-	if (OS::get_singleton()->is_stdout_verbose())
-		OS::get_singleton()->print("Mono: Glue disbled, ignoring script assemblies\n");
+	Error save_err = metadata->save(path);
+	ERR_FAIL_COND(save_err != OK);
+}
 
-	return true;
-#endif
+bool GDMono::metadata_is_api_assembly_invalidated(APIAssembly::Type p_api_type) {
+
+	String section = APIAssembly::to_string(p_api_type);
+
+	Ref<ConfigFile> metadata;
+	metadata.instance();
+	metadata->load(_get_api_assembly_metadata_path());
+
+	String assembly_path = GodotSharpDirs::get_res_assemblies_dir()
+								   .plus_file(p_api_type == APIAssembly::API_CORE ?
+													  API_ASSEMBLY_NAME ".dll" :
+													  EDITOR_API_ASSEMBLY_NAME ".dll");
+
+	if (!FileAccess::exists(assembly_path))
+		return false;
+
+	uint64_t modified_time = FileAccess::get_modified_time(assembly_path);
+
+	uint64_t stored_modified_time = metadata->get_value(section, "invalidated_asm_modified_time", 0);
+
+	return metadata->get_value(section, "invalidated", false) && modified_time <= stored_modified_time;
 }
+#endif
 
 Error GDMono::_load_scripts_domain() {
 
@@ -455,12 +638,15 @@ Error GDMono::_unload_scripts_domain() {
 
 	_domain_assemblies_cleanup(mono_domain_get_id(scripts_domain));
 
-	api_assembly = NULL;
+	core_api_assembly = NULL;
 	project_assembly = NULL;
 #ifdef TOOLS_ENABLED
 	editor_api_assembly = NULL;
 #endif
 
+	core_api_assembly_out_of_sync = false;
+	editor_api_assembly_out_of_sync = false;
+
 	MonoDomain *domain = scripts_domain;
 	scripts_domain = NULL;
 
@@ -515,16 +701,80 @@ Error GDMono::reload_scripts_domain() {
 		return err;
 	}
 
-	if (!_load_all_script_assemblies()) {
-		if (OS::get_singleton()->is_stdout_verbose())
-			OS::get_singleton()->printerr("Mono: Failed to load script assemblies\n");
+#ifndef MONO_GLUE_DISABLED
+	if (!_load_api_assemblies()) {
 		return ERR_CANT_OPEN;
 	}
 
+	if (!core_api_assembly_out_of_sync && !editor_api_assembly_out_of_sync && GDMonoUtils::mono_cache.godot_api_cache_updated) {
+		// Everything is fine with the api assemblies, load the project assembly
+		_load_project_assembly();
+	} else {
+		// The assembly was successfuly loaded, but the full api could not be cached.
+		// This is most likely an outdated assembly loaded because of an invalid version in the metadata,
+		// so we invalidate the version in the metadata and unload the script domain.
+
+		if (core_api_assembly_out_of_sync) {
+			metadata_set_api_assembly_invalidated(APIAssembly::API_CORE, true);
+		} else if (!GDMonoUtils::mono_cache.godot_api_cache_updated) {
+			ERR_PRINT("Core API assembly is in sync, but the cache update failed");
+			metadata_set_api_assembly_invalidated(APIAssembly::API_CORE, true);
+		}
+
+		if (editor_api_assembly_out_of_sync) {
+			metadata_set_api_assembly_invalidated(APIAssembly::API_EDITOR, true);
+		}
+
+		Error err = _unload_scripts_domain();
+		if (err != OK) {
+			WARN_PRINT("Mono: Failed to unload scripts domain");
+		}
+
+		return ERR_CANT_RESOLVE;
+	}
+
+	if (!_load_project_assembly())
+		return ERR_CANT_OPEN;
+#else
+	if (OS::get_singleton()->is_stdout_verbose())
+		OS::get_singleton()->print("Mono: Glue disabled, ignoring script assemblies\n");
+#endif
+
 	return OK;
 }
 #endif
 
+Error GDMono::finalize_and_unload_domain(MonoDomain *p_domain) {
+
+	CRASH_COND(p_domain == NULL);
+
+	String domain_name = mono_domain_get_friendly_name(p_domain);
+
+	if (OS::get_singleton()->is_stdout_verbose()) {
+		OS::get_singleton()->print(String("Mono: Unloading domain `" + domain_name + "`...\n").utf8());
+	}
+
+	if (mono_domain_get() != root_domain)
+		mono_domain_set(root_domain, true);
+
+	mono_gc_collect(mono_gc_max_generation());
+	mono_domain_finalize(p_domain, 2000);
+	mono_gc_collect(mono_gc_max_generation());
+
+	_domain_assemblies_cleanup(mono_domain_get_id(p_domain));
+
+	MonoObject *ex = NULL;
+	mono_domain_try_unload(p_domain, &ex);
+
+	if (ex) {
+		ERR_PRINTS("Exception thrown when unloading domain `" + domain_name + "`:");
+		mono_print_unhandled_exception(ex);
+		return FAILED;
+	}
+
+	return OK;
+}
+
 GDMonoClass *GDMono::get_class(MonoClass *p_raw_class) {
 
 	MonoImage *image = mono_class_get_image(p_raw_class);
@@ -576,8 +826,11 @@ GDMono::GDMono() {
 	tools_domain = NULL;
 #endif
 
+	core_api_assembly_out_of_sync = false;
+	editor_api_assembly_out_of_sync = false;
+
 	corlib_assembly = NULL;
-	api_assembly = NULL;
+	core_api_assembly = NULL;
 	project_assembly = NULL;
 #ifdef TOOLS_ENABLED
 	editor_api_assembly = NULL;
diff --git a/modules/mono/mono_gd/gd_mono.h b/modules/mono/mono_gd/gd_mono.h
index 67251778c6..5e01152870 100644
--- a/modules/mono/mono_gd/gd_mono.h
+++ b/modules/mono/mono_gd/gd_mono.h
@@ -31,6 +31,8 @@
 #ifndef GD_MONO_H
 #define GD_MONO_H
 
+#include "core/io/config_file.h"
+
 #include "../godotsharp_defs.h"
 #include "gd_mono_assembly.h"
 #include "gd_mono_log.h"
@@ -39,6 +41,43 @@
 #include "../utils/mono_reg_utils.h"
 #endif
 
+namespace APIAssembly {
+enum Type {
+	API_CORE,
+	API_EDITOR
+};
+
+struct Version {
+	uint64_t godot_api_hash;
+	uint32_t bindings_version;
+	uint32_t cs_glue_version;
+
+	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;
+	}
+
+	Version() :
+			godot_api_hash(0),
+			bindings_version(0),
+			cs_glue_version(0) {
+	}
+
+	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) {
+	}
+
+	static Version get_from_loaded_assembly(GDMonoAssembly *p_api_assembly, Type p_api_type);
+};
+
+String to_string(Type p_type);
+} // namespace APIAssembly
+
 #define SCRIPTS_DOMAIN GDMono::get_singleton()->get_scripts_domain()
 #ifdef TOOLS_ENABLED
 #define TOOLS_DOMAIN GDMono::get_singleton()->get_tools_domain()
@@ -55,8 +94,11 @@ class GDMono {
 	MonoDomain *tools_domain;
 #endif
 
+	bool core_api_assembly_out_of_sync;
+	bool editor_api_assembly_out_of_sync;
+
 	GDMonoAssembly *corlib_assembly;
-	GDMonoAssembly *api_assembly;
+	GDMonoAssembly *core_api_assembly;
 	GDMonoAssembly *project_assembly;
 #ifdef TOOLS_ENABLED
 	GDMonoAssembly *editor_api_assembly;
@@ -75,7 +117,11 @@ class GDMono {
 #endif
 	bool _load_project_assembly();
 
-	bool _load_all_script_assemblies();
+	bool _load_api_assemblies();
+
+#ifdef TOOLS_ENABLED
+	String _get_api_assembly_metadata_path();
+#endif
 
 	void _register_internal_calls();
 
@@ -94,8 +140,6 @@ class GDMono {
 	void _initialize_and_check_api_hashes();
 #endif
 
-	bool _load_assembly(const String &p_name, GDMonoAssembly **r_assembly);
-
 	GDMonoLog *gdmono_log;
 
 #ifdef WINDOWS_ENABLED
@@ -113,6 +157,11 @@ public:
 #endif
 #endif
 
+#ifdef TOOLS_ENABLED
+	void metadata_set_api_assembly_invalidated(APIAssembly::Type p_api_type, bool p_invalidated);
+	bool metadata_is_api_assembly_invalidated(APIAssembly::Type p_api_type);
+#endif
+
 	static GDMono *get_singleton() { return singleton; }
 
 	// Do not use these, unless you know what you're doing
@@ -128,7 +177,7 @@ public:
 #endif
 
 	_FORCE_INLINE_ GDMonoAssembly *get_corlib_assembly() const { return corlib_assembly; }
-	_FORCE_INLINE_ GDMonoAssembly *get_api_assembly() const { return api_assembly; }
+	_FORCE_INLINE_ GDMonoAssembly *get_core_api_assembly() const { return core_api_assembly; }
 	_FORCE_INLINE_ GDMonoAssembly *get_project_assembly() const { return project_assembly; }
 #ifdef TOOLS_ENABLED
 	_FORCE_INLINE_ GDMonoAssembly *get_editor_api_assembly() const { return editor_api_assembly; }
@@ -145,6 +194,10 @@ public:
 	Error reload_scripts_domain();
 #endif
 
+	bool load_assembly(const String &p_name, GDMonoAssembly **r_assembly, bool p_refonly = false);
+	bool load_assembly(const String &p_name, MonoAssemblyName *p_aname, GDMonoAssembly **r_assembly, bool p_refonly = false);
+	Error finalize_and_unload_domain(MonoDomain *p_domain);
+
 	void initialize();
 
 	GDMono();
diff --git a/modules/mono/mono_gd/gd_mono_assembly.cpp b/modules/mono/mono_gd/gd_mono_assembly.cpp
index ef39b8549d..d062d56dcf 100644
--- a/modules/mono/mono_gd/gd_mono_assembly.cpp
+++ b/modules/mono/mono_gd/gd_mono_assembly.cpp
@@ -43,7 +43,23 @@
 bool GDMonoAssembly::no_search = false;
 Vector<String> GDMonoAssembly::search_dirs;
 
-MonoAssembly *GDMonoAssembly::_search_hook(MonoAssemblyName *aname, void *user_data) {
+MonoAssembly *GDMonoAssembly::assembly_search_hook(MonoAssemblyName *aname, void *user_data) {
+	return GDMonoAssembly::_search_hook(aname, user_data, false);
+}
+
+MonoAssembly *GDMonoAssembly::assembly_refonly_search_hook(MonoAssemblyName *aname, void *user_data) {
+	return GDMonoAssembly::_search_hook(aname, user_data, true);
+}
+
+MonoAssembly *GDMonoAssembly::assembly_preload_hook(MonoAssemblyName *aname, char **assemblies_path, void *user_data) {
+	return GDMonoAssembly::_preload_hook(aname, assemblies_path, user_data, false);
+}
+
+MonoAssembly *GDMonoAssembly::assembly_refonly_preload_hook(MonoAssemblyName *aname, char **assemblies_path, void *user_data) {
+	return GDMonoAssembly::_preload_hook(aname, assemblies_path, user_data, true);
+}
+
+MonoAssembly *GDMonoAssembly::_search_hook(MonoAssemblyName *aname, void *user_data, bool refonly) {
 
 	(void)user_data; // UNUSED
 
@@ -60,7 +76,7 @@ MonoAssembly *GDMonoAssembly::_search_hook(MonoAssemblyName *aname, void *user_d
 	no_search = true; // Avoid the recursion madness
 
 	String path;
-	MonoAssembly *res = NULL;
+	GDMonoAssembly *res = NULL;
 
 	for (int i = 0; i < search_dirs.size(); i++) {
 		const String &search_dir = search_dirs[i];
@@ -68,44 +84,49 @@ MonoAssembly *GDMonoAssembly::_search_hook(MonoAssemblyName *aname, void *user_d
 		if (has_extension) {
 			path = search_dir.plus_file(name);
 			if (FileAccess::exists(path)) {
-				res = _load_assembly_from(name.get_basename(), path);
-				break;
+				res = _load_assembly_from(name.get_basename(), path, refonly);
+				if (res != NULL)
+					break;
 			}
 		} else {
 			path = search_dir.plus_file(name + ".dll");
 			if (FileAccess::exists(path)) {
-				res = _load_assembly_from(name, path);
-				break;
+				res = _load_assembly_from(name, path, refonly);
+				if (res != NULL)
+					break;
 			}
 
 			path = search_dir.plus_file(name + ".exe");
 			if (FileAccess::exists(path)) {
-				res = _load_assembly_from(name, path);
-				break;
+				res = _load_assembly_from(name, path, refonly);
+				if (res != NULL)
+					break;
 			}
 		}
 	}
 
 	no_search = false;
 
-	return res;
+	return res ? res->get_assembly() : NULL;
 }
 
-MonoAssembly *GDMonoAssembly::_preload_hook(MonoAssemblyName *aname, char **assemblies_path, void *user_data) {
+MonoAssembly *GDMonoAssembly::_preload_hook(MonoAssemblyName *aname, char **assemblies_path, void *user_data, bool refonly) {
 
 	(void)user_data; // UNUSED
 
 	if (search_dirs.empty()) {
-#ifdef TOOLS_DOMAIN
 		search_dirs.push_back(GodotSharpDirs::get_res_temp_assemblies_dir());
-#endif
 		search_dirs.push_back(GodotSharpDirs::get_res_assemblies_dir());
 		search_dirs.push_back(OS::get_singleton()->get_resource_dir());
 		search_dirs.push_back(OS::get_singleton()->get_executable_path().get_base_dir());
+#ifdef GD_MONO_EDITOR_ASSEMBLIES_DIR
+		search_dirs.push_back(OS::get_singleton()->get_executable_path().get_base_dir().plus_file(_MKSTR(GD_MONO_EDITOR_ASSEMBLIES_DIR)).simplify_path());
+#endif
 
 		const char *rootdir = mono_assembly_getrootdir();
 		if (rootdir) {
 			search_dirs.push_back(String(rootdir).plus_file("mono").plus_file("4.5"));
+			search_dirs.push_back(String(rootdir).plus_file("mono").plus_file("4.5").plus_file("Facades"));
 		}
 
 		if (assemblies_path) {
@@ -121,10 +142,11 @@ MonoAssembly *GDMonoAssembly::_preload_hook(MonoAssemblyName *aname, char **asse
 
 	if (has_extension ? name == "mscorlib.dll" : name == "mscorlib") {
 		GDMonoAssembly **stored_assembly = GDMono::get_singleton()->get_loaded_assembly(has_extension ? name.get_basename() : name);
-		if (stored_assembly) return (*stored_assembly)->get_assembly();
+		if (stored_assembly)
+			return (*stored_assembly)->get_assembly();
 
 		String path;
-		MonoAssembly *res = NULL;
+		GDMonoAssembly *res = NULL;
 
 		for (int i = 0; i < search_dirs.size(); i++) {
 			const String &search_dir = search_dirs[i];
@@ -132,53 +154,57 @@ MonoAssembly *GDMonoAssembly::_preload_hook(MonoAssemblyName *aname, char **asse
 			if (has_extension) {
 				path = search_dir.plus_file(name);
 				if (FileAccess::exists(path)) {
-					res = _load_assembly_from(name.get_basename(), path);
-					break;
+					res = _load_assembly_from(name.get_basename(), path, refonly);
+					if (res != NULL)
+						break;
 				}
 			} else {
 				path = search_dir.plus_file(name + ".dll");
 				if (FileAccess::exists(path)) {
-					res = _load_assembly_from(name, path);
-					break;
+					res = _load_assembly_from(name, path, refonly);
+					if (res != NULL)
+						break;
 				}
 			}
 		}
 
-		if (res) return res;
+		return res ? res->get_assembly() : NULL;
 	}
 
 	return NULL;
 }
 
-MonoAssembly *GDMonoAssembly::_load_assembly_from(const String &p_name, const String &p_path) {
+GDMonoAssembly *GDMonoAssembly::_load_assembly_from(const String &p_name, const String &p_path, bool p_refonly) {
 
 	GDMonoAssembly *assembly = memnew(GDMonoAssembly(p_name, p_path));
 
-	MonoDomain *domain = mono_domain_get();
-
-	Error err = assembly->load(domain);
+	Error err = assembly->load(p_refonly);
 
 	if (err != OK) {
 		memdelete(assembly);
 		ERR_FAIL_V(NULL);
 	}
 
+	MonoDomain *domain = mono_domain_get();
 	GDMono::get_singleton()->add_assembly(domain ? mono_domain_get_id(domain) : 0, assembly);
 
-	return assembly->get_assembly();
+	return assembly;
 }
 
 void GDMonoAssembly::initialize() {
 
-	// TODO refonly as well?
-	mono_install_assembly_preload_hook(&GDMonoAssembly::_preload_hook, NULL);
-	mono_install_assembly_search_hook(&GDMonoAssembly::_search_hook, NULL);
+	mono_install_assembly_search_hook(&assembly_search_hook, NULL);
+	mono_install_assembly_refonly_search_hook(&assembly_refonly_search_hook, NULL);
+	mono_install_assembly_preload_hook(&assembly_preload_hook, NULL);
+	mono_install_assembly_refonly_preload_hook(&assembly_refonly_preload_hook, NULL);
 }
 
-Error GDMonoAssembly::load(MonoDomain *p_domain) {
+Error GDMonoAssembly::load(bool p_refonly) {
 
 	ERR_FAIL_COND_V(loaded, ERR_FILE_ALREADY_IN_USE);
 
+	refonly = p_refonly;
+
 	uint64_t last_modified_time = FileAccess::get_modified_time(path);
 
 	Vector<uint8_t> data = FileAccess::get_file_as_array(path);
@@ -186,14 +212,15 @@ Error GDMonoAssembly::load(MonoDomain *p_domain) {
 
 	String image_filename(path);
 
-	MonoImageOpenStatus status;
+	MonoImageOpenStatus status = MONO_IMAGE_OK;
 
 	image = mono_image_open_from_data_with_name(
 			(char *)&data[0], data.size(),
-			true, &status, false,
+			true, &status, refonly,
 			image_filename.utf8().get_data());
 
-	ERR_FAIL_COND_V(status != MONO_IMAGE_OK || image == NULL, ERR_FILE_CANT_OPEN);
+	ERR_FAIL_COND_V(status != MONO_IMAGE_OK, ERR_FILE_CANT_OPEN);
+	ERR_FAIL_NULL_V(image, ERR_FILE_CANT_OPEN);
 
 #ifdef DEBUG_ENABLED
 	String pdb_path(path + ".pdb");
@@ -213,15 +240,10 @@ no_pdb:
 
 #endif
 
-	assembly = mono_assembly_load_from_full(image, image_filename.utf8().get_data(), &status, false);
+	assembly = mono_assembly_load_from_full(image, image_filename.utf8().get_data(), &status, refonly);
 
 	ERR_FAIL_COND_V(status != MONO_IMAGE_OK || assembly == NULL, ERR_FILE_CANT_OPEN);
 
-	if (p_domain && mono_image_get_entry_point(image)) {
-		// TODO should this be removed? do we want to call main? what other effects does this have?
-		mono_jit_exec(p_domain, assembly, 0, NULL);
-	}
-
 	loaded = true;
 	modified_time = last_modified_time;
 
@@ -373,12 +395,26 @@ GDMonoClass *GDMonoAssembly::get_object_derived_class(const StringName &p_class)
 	return match;
 }
 
+GDMonoAssembly *GDMonoAssembly::load_from(const String &p_name, const String &p_path, bool p_refonly) {
+
+	GDMonoAssembly **loaded_asm = GDMono::get_singleton()->get_loaded_assembly(p_name);
+	if (loaded_asm)
+		return *loaded_asm;
+
+	no_search = true;
+	GDMonoAssembly *res = _load_assembly_from(p_name, p_path, p_refonly);
+	no_search = false;
+
+	return res;
+}
+
 GDMonoAssembly::GDMonoAssembly(const String &p_name, const String &p_path) {
 
 	loaded = false;
 	gdobject_class_cache_updated = false;
 	name = p_name;
 	path = p_path;
+	refonly = false;
 	modified_time = 0;
 	assembly = NULL;
 	image = NULL;
diff --git a/modules/mono/mono_gd/gd_mono_assembly.h b/modules/mono/mono_gd/gd_mono_assembly.h
index 8a5fa19626..5cf744a5a2 100644
--- a/modules/mono/mono_gd/gd_mono_assembly.h
+++ b/modules/mono/mono_gd/gd_mono_assembly.h
@@ -71,6 +71,7 @@ class GDMonoAssembly {
 	MonoAssembly *assembly;
 	MonoImage *image;
 
+	bool refonly;
 	bool loaded;
 
 	String name;
@@ -90,19 +91,25 @@ class GDMonoAssembly {
 	static bool no_search;
 	static Vector<String> search_dirs;
 
-	static MonoAssembly *_search_hook(MonoAssemblyName *aname, void *user_data);
-	static MonoAssembly *_preload_hook(MonoAssemblyName *aname, char **assemblies_path, void *user_data);
+	static MonoAssembly *assembly_search_hook(MonoAssemblyName *aname, void *user_data);
+	static MonoAssembly *assembly_refonly_search_hook(MonoAssemblyName *aname, void *user_data);
+	static MonoAssembly *assembly_preload_hook(MonoAssemblyName *aname, char **assemblies_path, void *user_data);
+	static MonoAssembly *assembly_refonly_preload_hook(MonoAssemblyName *aname, char **assemblies_path, void *user_data);
 
-	static MonoAssembly *_load_assembly_from(const String &p_name, const String &p_path);
+	static MonoAssembly *_search_hook(MonoAssemblyName *aname, void *user_data, bool refonly);
+	static MonoAssembly *_preload_hook(MonoAssemblyName *aname, char **assemblies_path, void *user_data, bool refonly);
+
+	static GDMonoAssembly *_load_assembly_from(const String &p_name, const String &p_path, bool p_refonly);
 
 	friend class GDMono;
 	static void initialize();
 
 public:
-	Error load(MonoDomain *p_domain);
+	Error load(bool p_refonly);
 	Error wrapper_for_image(MonoImage *p_image);
 	void unload();
 
+	_FORCE_INLINE_ bool is_refonly() const { return refonly; }
 	_FORCE_INLINE_ bool is_loaded() const { return loaded; }
 	_FORCE_INLINE_ MonoImage *get_image() const { return image; }
 	_FORCE_INLINE_ MonoAssembly *get_assembly() const { return assembly; }
@@ -115,6 +122,8 @@ public:
 
 	GDMonoClass *get_object_derived_class(const StringName &p_class);
 
+	static GDMonoAssembly *load_from(const String &p_name, const String &p_path, bool p_refonly);
+
 	GDMonoAssembly(const String &p_name, const String &p_path = String());
 	~GDMonoAssembly();
 };
diff --git a/modules/mono/mono_gd/gd_mono_class.cpp b/modules/mono/mono_gd/gd_mono_class.cpp
index b826352f02..66339d7ae6 100644
--- a/modules/mono/mono_gd/gd_mono_class.cpp
+++ b/modules/mono/mono_gd/gd_mono_class.cpp
@@ -404,6 +404,33 @@ const Vector<GDMonoProperty *> &GDMonoClass::get_all_properties() {
 	return properties_list;
 }
 
+const Vector<GDMonoClass *> &GDMonoClass::get_all_delegates() {
+	if (delegates_fetched)
+		return delegates_list;
+
+	void *iter = NULL;
+	MonoClass *raw_class = NULL;
+	while ((raw_class = mono_class_get_nested_types(mono_class, &iter)) != NULL) {
+		if (mono_class_is_delegate(raw_class)) {
+			StringName name = mono_class_get_name(raw_class);
+
+			Map<StringName, GDMonoClass *>::Element *match = delegates.find(name);
+
+			if (match) {
+				delegates_list.push_back(match->get());
+			} else {
+				GDMonoClass *delegate = memnew(GDMonoClass(mono_class_get_namespace(raw_class), mono_class_get_name(raw_class), raw_class, assembly));
+				delegates.insert(name, delegate);
+				delegates_list.push_back(delegate);
+			}
+		}
+	}
+
+	delegates_fetched = true;
+
+	return delegates_list;
+}
+
 GDMonoClass::GDMonoClass(const StringName &p_namespace, const StringName &p_name, MonoClass *p_class, GDMonoAssembly *p_assembly) {
 
 	namespace_name = p_namespace;
@@ -417,6 +444,7 @@ GDMonoClass::GDMonoClass(const StringName &p_namespace, const StringName &p_name
 	methods_fetched = false;
 	fields_fetched = false;
 	properties_fetched = false;
+	delegates_fetched = false;
 }
 
 GDMonoClass::~GDMonoClass() {
diff --git a/modules/mono/mono_gd/gd_mono_class.h b/modules/mono/mono_gd/gd_mono_class.h
index afccf2fc63..417c138594 100644
--- a/modules/mono/mono_gd/gd_mono_class.h
+++ b/modules/mono/mono_gd/gd_mono_class.h
@@ -90,6 +90,10 @@ class GDMonoClass {
 	Map<StringName, GDMonoProperty *> properties;
 	Vector<GDMonoProperty *> properties_list;
 
+	bool delegates_fetched;
+	Map<StringName, GDMonoClass *> delegates;
+	Vector<GDMonoClass *> delegates_list;
+
 	friend class GDMonoAssembly;
 	GDMonoClass(const StringName &p_namespace, const StringName &p_name, MonoClass *p_class, GDMonoAssembly *p_assembly);
 
@@ -133,6 +137,8 @@ public:
 	GDMonoProperty *get_property(const StringName &p_name);
 	const Vector<GDMonoProperty *> &get_all_properties();
 
+	const Vector<GDMonoClass *> &get_all_delegates();
+
 	~GDMonoClass();
 };
 
diff --git a/modules/mono/mono_gd/gd_mono_method.cpp b/modules/mono/mono_gd/gd_mono_method.cpp
index 1f8e9a1926..ad52904945 100644
--- a/modules/mono/mono_gd/gd_mono_method.cpp
+++ b/modules/mono/mono_gd/gd_mono_method.cpp
@@ -229,6 +229,23 @@ String GDMonoMethod::get_signature_desc(bool p_namespaces) const {
 	return res;
 }
 
+void GDMonoMethod::get_parameter_names(Vector<StringName> &names) const {
+	if (params_count > 0) {
+		const char **_names = memnew_arr(const char *, params_count);
+		mono_method_get_param_names(mono_method, _names);
+		for (int i = 0; i < params_count; ++i) {
+			names.push_back(StringName(_names[i]));
+		}
+		memdelete_arr(_names);
+	}
+}
+
+void GDMonoMethod::get_parameter_types(Vector<ManagedType> &types) const {
+	for (int i = 0; i < param_types.size(); ++i) {
+		types.push_back(param_types[i]);
+	}
+}
+
 GDMonoMethod::GDMonoMethod(StringName p_name, MonoMethod *p_method) {
 	name = p_name;
 
diff --git a/modules/mono/mono_gd/gd_mono_method.h b/modules/mono/mono_gd/gd_mono_method.h
index 14df8dcfb4..a173af83f4 100644
--- a/modules/mono/mono_gd/gd_mono_method.h
+++ b/modules/mono/mono_gd/gd_mono_method.h
@@ -80,6 +80,9 @@ public:
 	String get_ret_type_full_name() const;
 	String get_signature_desc(bool p_namespaces = false) const;
 
+	void get_parameter_names(Vector<StringName> &names) const;
+	void get_parameter_types(Vector<ManagedType> &types) const;
+
 	GDMonoMethod(StringName p_name, MonoMethod *p_method);
 	~GDMonoMethod();
 };
diff --git a/modules/mono/mono_gd/gd_mono_utils.cpp b/modules/mono/mono_gd/gd_mono_utils.cpp
index a2f0819a72..db136a1313 100644
--- a/modules/mono/mono_gd/gd_mono_utils.cpp
+++ b/modules/mono/mono_gd/gd_mono_utils.cpp
@@ -114,6 +114,7 @@ void MonoCache::clear_members() {
 	class_ExportAttribute = NULL;
 	field_ExportAttribute_hint = NULL;
 	field_ExportAttribute_hintString = NULL;
+	class_SignalAttribute = NULL;
 	class_ToolAttribute = NULL;
 	class_RemoteAttribute = NULL;
 	class_SyncAttribute = NULL;
@@ -142,7 +143,7 @@ void MonoCache::cleanup() {
 	godot_api_cache_updated = false;
 }
 
-#define GODOT_API_CLASS(m_class) (GDMono::get_singleton()->get_api_assembly()->get_class(BINDINGS_NAMESPACE, #m_class))
+#define GODOT_API_CLASS(m_class) (GDMono::get_singleton()->get_core_api_assembly()->get_class(BINDINGS_NAMESPACE, #m_class))
 
 void update_corlib_cache() {
 
@@ -201,6 +202,7 @@ void update_godot_api_cache() {
 	CACHE_CLASS_AND_CHECK(ExportAttribute, GODOT_API_CLASS(ExportAttribute));
 	CACHE_FIELD_AND_CHECK(ExportAttribute, hint, CACHED_CLASS(ExportAttribute)->get_field("hint"));
 	CACHE_FIELD_AND_CHECK(ExportAttribute, hintString, CACHED_CLASS(ExportAttribute)->get_field("hintString"));
+	CACHE_CLASS_AND_CHECK(SignalAttribute, GODOT_API_CLASS(SignalAttribute));
 	CACHE_CLASS_AND_CHECK(ToolAttribute, GODOT_API_CLASS(ToolAttribute));
 	CACHE_CLASS_AND_CHECK(RemoteAttribute, GODOT_API_CLASS(RemoteAttribute));
 	CACHE_CLASS_AND_CHECK(SyncAttribute, GODOT_API_CLASS(SyncAttribute));
@@ -243,7 +245,7 @@ void update_godot_api_cache() {
 	mono_runtime_object_init(task_scheduler);
 	mono_cache.task_scheduler_handle = MonoGCHandle::create_strong(task_scheduler);
 
-	mono_cache.corlib_cache_updated = true;
+	mono_cache.godot_api_cache_updated = true;
 }
 
 void clear_cache() {
@@ -303,7 +305,7 @@ GDMonoClass *type_get_proxy_class(const StringName &p_type) {
 	if (class_name[0] == '_')
 		class_name = class_name.substr(1, class_name.length());
 
-	GDMonoClass *klass = GDMono::get_singleton()->get_api_assembly()->get_class(BINDINGS_NAMESPACE, class_name);
+	GDMonoClass *klass = GDMono::get_singleton()->get_core_api_assembly()->get_class(BINDINGS_NAMESPACE, class_name);
 
 #ifdef TOOLS_ENABLED
 	if (!klass) {
@@ -319,7 +321,7 @@ GDMonoClass *get_class_native_base(GDMonoClass *p_class) {
 
 	do {
 		const GDMonoAssembly *assembly = klass->get_assembly();
-		if (assembly == GDMono::get_singleton()->get_api_assembly())
+		if (assembly == GDMono::get_singleton()->get_core_api_assembly())
 			return klass;
 #ifdef TOOLS_ENABLED
 		if (assembly == GDMono::get_singleton()->get_editor_api_assembly())
@@ -418,37 +420,56 @@ void print_unhandled_exception(MonoObject *p_exc, bool p_recursion_caution) {
 	if (!ScriptDebugger::get_singleton())
 		return;
 
-	GDMonoClass *st_klass = CACHED_CLASS(System_Diagnostics_StackTrace);
-	MonoObject *stack_trace = mono_object_new(mono_domain_get(), st_klass->get_mono_ptr());
+	ScriptLanguage::StackInfo separator;
+	separator.file = "";
+	separator.func = "--- " + RTR("End of inner exception stack trace") + " ---";
+	separator.line = 0;
+
+	Vector<ScriptLanguage::StackInfo> si;
+	String exc_msg = "";
+
+	while (p_exc != NULL) {
+		GDMonoClass *st_klass = CACHED_CLASS(System_Diagnostics_StackTrace);
+		MonoObject *stack_trace = mono_object_new(mono_domain_get(), st_klass->get_mono_ptr());
 
-	MonoBoolean need_file_info = true;
-	void *ctor_args[2] = { p_exc, &need_file_info };
+		MonoBoolean need_file_info = true;
+		void *ctor_args[2] = { p_exc, &need_file_info };
 
-	MonoObject *unexpected_exc = NULL;
-	CACHED_METHOD(System_Diagnostics_StackTrace, ctor_Exception_bool)->invoke_raw(stack_trace, ctor_args, &unexpected_exc);
+		MonoObject *unexpected_exc = NULL;
+		CACHED_METHOD(System_Diagnostics_StackTrace, ctor_Exception_bool)->invoke_raw(stack_trace, ctor_args, &unexpected_exc);
 
-	if (unexpected_exc != NULL) {
-		mono_print_unhandled_exception(unexpected_exc);
+		if (unexpected_exc != NULL) {
+			mono_print_unhandled_exception(unexpected_exc);
 
-		if (p_recursion_caution) {
-			// Called from CSharpLanguage::get_current_stack_info,
-			// so printing an error here could result in endless recursion
-			OS::get_singleton()->printerr("Mono: Method GDMonoUtils::print_unhandled_exception failed");
-			return;
-		} else {
-			ERR_FAIL();
+			if (p_recursion_caution) {
+				// Called from CSharpLanguage::get_current_stack_info,
+				// so printing an error here could result in endless recursion
+				OS::get_singleton()->printerr("Mono: Method GDMonoUtils::print_unhandled_exception failed");
+				return;
+			} else {
+				ERR_FAIL();
+			}
 		}
-	}
 
-	Vector<ScriptLanguage::StackInfo> si;
-	if (stack_trace != NULL && !p_recursion_caution)
-		si = CSharpLanguage::get_singleton()->stack_trace_get_info(stack_trace);
+		Vector<ScriptLanguage::StackInfo> _si;
+		if (stack_trace != NULL && !p_recursion_caution) {
+			_si = CSharpLanguage::get_singleton()->stack_trace_get_info(stack_trace);
+			for (int i = _si.size() - 1; i >= 0; i--)
+				si.insert(0, _si[i]);
+		}
+
+		exc_msg += (exc_msg.length() > 0 ? " ---> " : "") + GDMonoUtils::get_exception_name_and_message(p_exc);
+
+		GDMonoProperty *p_prop = GDMono::get_singleton()->get_class(mono_object_get_class(p_exc))->get_property("InnerException");
+		p_exc = p_prop != NULL ? p_prop->get_value(p_exc) : NULL;
+		if (p_exc != NULL)
+			si.insert(0, separator);
+	}
 
 	String file = si.size() ? si[0].file : __FILE__;
 	String func = si.size() ? si[0].func : FUNCTION_STR;
 	int line = si.size() ? si[0].line : __LINE__;
 	String error_msg = "Unhandled exception";
-	String exc_msg = GDMonoUtils::get_exception_name_and_message(p_exc);
 
 	ScriptDebugger::get_singleton()->send_error(func, file, line, error_msg, exc_msg, ERR_HANDLER_ERROR, si);
 #endif
diff --git a/modules/mono/mono_gd/gd_mono_utils.h b/modules/mono/mono_gd/gd_mono_utils.h
index 259da46c31..1a34180d15 100644
--- a/modules/mono/mono_gd/gd_mono_utils.h
+++ b/modules/mono/mono_gd/gd_mono_utils.h
@@ -108,6 +108,7 @@ struct MonoCache {
 	GDMonoClass *class_ExportAttribute;
 	GDMonoField *field_ExportAttribute_hint;
 	GDMonoField *field_ExportAttribute_hintString;
+	GDMonoClass *class_SignalAttribute;
 	GDMonoClass *class_ToolAttribute;
 	GDMonoClass *class_RemoteAttribute;
 	GDMonoClass *class_SyncAttribute;