Merge pull request #17020 from neikeq/cs-api-asm-checks

core/ustring.cpp

@@ -1135,6 +1135,36 @@ String String::num_int64(int64_t p_num, int base, bool capitalize_hex) {
 	return s;
 }
 
+String String::num_uint64(uint64_t p_num, int base, bool capitalize_hex) {
+
+	uint64_t n = p_num;
+
+	int chars = 0;
+	do {
+		n /= base;
+		chars++;
+	} while (n);
+
+	String s;
+	s.resize(chars + 1);
+	CharType *c = s.ptrw();
+	c[chars] = 0;
+	n = p_num;
+	do {
+		int mod = ABS(n % base);
+		if (mod >= 10) {
+			char a = (capitalize_hex ? 'A' : 'a');
+			c[--chars] = a + (mod - 10);
+		} else {
+			c[--chars] = '0' + mod;
+		}
+
+		n /= base;
+	} while (n);
+
+	return s;
+}
+
 String String::num_real(double p_num) {
 
 	String s;

core/ustring.h

@@ -146,6 +146,7 @@ public:
 	static String num_scientific(double p_num);
 	static String num_real(double p_num);
 	static String num_int64(int64_t p_num, int base = 10, bool capitalize_hex = false);
+	static String num_uint64(uint64_t p_num, int base = 10, bool capitalize_hex = false);
 	static String chr(CharType p_char);
 	static String md5(const uint8_t *p_md5);
 	static String hex_encode_buffer(const uint8_t *p_buffer, int p_len);

modules/mono/SCsub

@@ -31,11 +31,18 @@ def make_cs_files_header(src, dst):
                         if i > 0:
                             header.write(', ')
                         header.write(byte_to_str(buf[buf_idx]))
-                    inserted_files += '\tr_files.insert(\"' + file + '\", ' \
+                    inserted_files += '\tr_files.insert("' + file + '", ' \
                                         'CompressedFile(_cs_' + name + '_compressed_size, ' \
                                         '_cs_' + name + '_uncompressed_size, ' \
                                         '_cs_' + name + '_compressed));\n'
                     header.write(' };\n')
+        version_file = os.path.join(src, 'VERSION.txt')
+        with open(version_file, 'r') as content_file:
+            try:
+                glue_version = int(content_file.read()) # make sure the format is valid
+                header.write('\n#define CS_GLUE_VERSION UINT32_C(' + str(glue_version) + ')\n')
+            except ValueError:
+                raise ValueError('Invalid C# glue version in: ' + version_file)
         header.write('\nstruct CompressedFile\n' '{\n'
             '\tint compressed_size;\n' '\tint uncompressed_size;\n' '\tconst unsigned char* data;\n'
             '\n\tCompressedFile(int p_comp_size, int p_uncomp_size, const unsigned char* p_data)\n'
@@ -80,23 +87,23 @@ def find_msbuild_unix(filename):
     import sys
 
     hint_dirs = ['/opt/novell/mono/bin']
-    if sys.platform == "darwin":
+    if sys.platform == 'darwin':
         hint_dirs = ['/Library/Frameworks/Mono.framework/Versions/Current/bin'] + hint_dirs
 
     for hint_dir in hint_dirs:
         hint_path = os.path.join(hint_dir, filename)
         if os.path.isfile(hint_path):
             return hint_path
-        elif os.path.isfile(hint_path + ".exe"):
-            return hint_path + ".exe"
+        elif os.path.isfile(hint_path + '.exe'):
+            return hint_path + '.exe'
 
-    for hint_dir in os.environ["PATH"].split(os.pathsep):
+    for hint_dir in os.environ['PATH'].split(os.pathsep):
         hint_dir = hint_dir.strip('"')
         hint_path = os.path.join(hint_dir, filename)
         if os.path.isfile(hint_path) and os.access(hint_path, os.X_OK):
             return hint_path
-        if os.path.isfile(hint_path + ".exe") and os.access(hint_path + ".exe", os.X_OK):
-            return hint_path + ".exe"
+        if os.path.isfile(hint_path + '.exe') and os.access(hint_path + '.exe', os.X_OK):
+            return hint_path + '.exe'
 
     return None
 
@@ -152,7 +159,7 @@ def mono_build_solution(source, target, env):
             xbuild_fallback = env['xbuild_fallback']
 
             if xbuild_fallback and os.name == 'nt':
-                print("Option 'xbuild_fallback' not supported on Windows")
+                print('Option \'xbuild_fallback\' not supported on Windows')
                 xbuild_fallback = False
 
             if xbuild_fallback:

modules/mono/csharp_script.cpp

@@ -456,7 +456,7 @@ Vector<ScriptLanguage::StackInfo> CSharpLanguage::debug_get_current_stack_info()
 #ifdef DEBUG_ENABLED
 	// Printing an error here will result in endless recursion, so we must be careful
 
-	if (!gdmono->is_runtime_initialized() || !GDMono::get_singleton()->get_api_assembly() || !GDMonoUtils::mono_cache.corlib_cache_updated)
+	if (!gdmono->is_runtime_initialized() || !GDMono::get_singleton()->get_core_api_assembly() || !GDMonoUtils::mono_cache.corlib_cache_updated)
 		return Vector<StackInfo>();
 
 	MonoObject *stack_trace = mono_object_new(mono_domain_get(), CACHED_CLASS(System_Diagnostics_StackTrace)->get_mono_ptr());

modules/mono/editor/bindings_generator.h

@@ -536,6 +536,9 @@ public:
 	Error generate_cs_editor_project(const String &p_output_dir, const String &p_core_dll_path, bool p_verbose_output = true);
 	Error generate_glue(const String &p_output_dir);
 
+	static uint32_t get_version();
+	static uint32_t get_cs_glue_version();
+
 	void initialize();
 
 	_FORCE_INLINE_ static BindingsGenerator *get_singleton() {

modules/mono/editor/godotsharp_builds.cpp

@@ -33,7 +33,6 @@
 #include "main/main.h"
 
 #include "../godotsharp_dirs.h"
-#include "../mono_gd/gd_mono.h"
 #include "../mono_gd/gd_mono_class.h"
 #include "../mono_gd/gd_mono_marshal.h"
 #include "../utils/path_utils.h"
@@ -178,13 +177,15 @@ bool GodotSharpBuilds::build_api_sln(const String &p_name, const String &p_api_s
 	return true;
 }
 
-bool GodotSharpBuilds::copy_api_assembly(const String &p_src_dir, const String &p_dst_dir, const String &p_assembly_name) {
+bool GodotSharpBuilds::copy_api_assembly(const String &p_src_dir, const String &p_dst_dir, const String &p_assembly_name, APIAssembly::Type p_api_type) {
 
 	String assembly_file = p_assembly_name + ".dll";
 	String assembly_src = p_src_dir.plus_file(assembly_file);
 	String assembly_dst = p_dst_dir.plus_file(assembly_file);
 
-	if (!FileAccess::exists(assembly_dst) || FileAccess::get_modified_time(assembly_src) > FileAccess::get_modified_time(assembly_dst)) {
+	if (!FileAccess::exists(assembly_dst) ||
+			FileAccess::get_modified_time(assembly_src) > FileAccess::get_modified_time(assembly_dst) ||
+			GDMono::get_singleton()->metadata_is_api_assembly_invalidated(p_api_type)) {
 		DirAccess *da = DirAccess::create(DirAccess::ACCESS_FILESYSTEM);
 
 		String xml_file = p_assembly_name + ".xml";
@@ -203,33 +204,46 @@ bool GodotSharpBuilds::copy_api_assembly(const String &p_src_dir, const String &
 			show_build_error_dialog("Failed to copy " + assembly_file);
 			return false;
 		}
+
+		GDMono::get_singleton()->metadata_set_api_assembly_invalidated(p_api_type, false);
 	}
 
 	return true;
 }
 
-bool GodotSharpBuilds::make_api_sln(GodotSharpBuilds::APIType p_api_type) {
+String GodotSharpBuilds::_api_folder_name(APIAssembly::Type p_api_type) {
+
+	uint64_t api_hash = p_api_type == APIAssembly::API_CORE ?
+								GDMono::get_singleton()->get_api_core_hash() :
+								GDMono::get_singleton()->get_api_editor_hash();
+	return String::num_uint64(api_hash) +
+		   "_" + String::num_uint64(BindingsGenerator::get_version()) +
+		   "_" + String::num_uint64(BindingsGenerator::get_cs_glue_version());
+}
 
-	String api_name = p_api_type == API_CORE ? API_ASSEMBLY_NAME : EDITOR_API_ASSEMBLY_NAME;
+bool GodotSharpBuilds::make_api_sln(APIAssembly::Type p_api_type) {
+
+	String api_name = p_api_type == APIAssembly::API_CORE ? API_ASSEMBLY_NAME : EDITOR_API_ASSEMBLY_NAME;
 	String api_build_config = "Release";
 
 	EditorProgress pr("mono_build_release_" + api_name, "Building " + api_name + " solution...", 4);
 
 	pr.step("Generating " + api_name + " solution");
 
-	uint64_t core_hash = GDMono::get_singleton()->get_api_core_hash();
-	uint64_t editor_hash = GDMono::get_singleton()->get_api_editor_hash();
-
-	String core_api_sln_dir = GodotSharpDirs::get_mono_solutions_dir().plus_file(API_ASSEMBLY_NAME "_" + itos(core_hash));
-	String editor_api_sln_dir = GodotSharpDirs::get_mono_solutions_dir().plus_file(EDITOR_API_ASSEMBLY_NAME "_" + itos(editor_hash));
+	String core_api_sln_dir = GodotSharpDirs::get_mono_solutions_dir()
+									  .plus_file(_api_folder_name(APIAssembly::API_CORE))
+									  .plus_file(API_ASSEMBLY_NAME);
+	String editor_api_sln_dir = GodotSharpDirs::get_mono_solutions_dir()
+										.plus_file(_api_folder_name(APIAssembly::API_EDITOR))
+										.plus_file(EDITOR_API_ASSEMBLY_NAME);
 
-	String api_sln_dir = p_api_type == API_CORE ? core_api_sln_dir : editor_api_sln_dir;
+	String api_sln_dir = p_api_type == APIAssembly::API_CORE ? core_api_sln_dir : editor_api_sln_dir;
 	String api_sln_file = api_sln_dir.plus_file(api_name + ".sln");
 
 	if (!DirAccess::exists(api_sln_dir) || !FileAccess::exists(api_sln_file)) {
 		String core_api_assembly;
 
-		if (p_api_type == API_EDITOR) {
+		if (p_api_type == APIAssembly::API_EDITOR) {
 			core_api_assembly = core_api_sln_dir.plus_file("bin")
 										.plus_file(api_build_config)
 										.plus_file(API_ASSEMBLY_NAME ".dll");
@@ -242,7 +256,7 @@ bool GodotSharpBuilds::make_api_sln(GodotSharpBuilds::APIType p_api_type) {
 		BindingsGenerator *gen = BindingsGenerator::get_singleton();
 		bool gen_verbose = OS::get_singleton()->is_stdout_verbose();
 
-		Error err = p_api_type == API_CORE ?
+		Error err = p_api_type == APIAssembly::API_CORE ?
 							gen->generate_cs_core_project(api_sln_dir, gen_verbose) :
 							gen->generate_cs_editor_project(api_sln_dir, core_api_assembly, gen_verbose);
 
@@ -275,7 +289,7 @@ bool GodotSharpBuilds::make_api_sln(GodotSharpBuilds::APIType p_api_type) {
 
 	// Copy the built assembly to the assemblies directory
 	String api_assembly_dir = api_sln_dir.plus_file("bin").plus_file(api_build_config);
-	if (!GodotSharpBuilds::copy_api_assembly(api_assembly_dir, res_assemblies_dir, api_name))
+	if (!GodotSharpBuilds::copy_api_assembly(api_assembly_dir, res_assemblies_dir, api_name, p_api_type))
 		return false;
 
 	pr.step("Done");
@@ -288,10 +302,10 @@ bool GodotSharpBuilds::build_project_blocking(const String &p_config) {
 	if (!FileAccess::exists(GodotSharpDirs::get_project_sln_path()))
 		return true; // No solution to build
 
-	if (!GodotSharpBuilds::make_api_sln(GodotSharpBuilds::API_CORE))
+	if (!GodotSharpBuilds::make_api_sln(APIAssembly::API_CORE))
 		return false;
 
-	if (!GodotSharpBuilds::make_api_sln(GodotSharpBuilds::API_EDITOR))
+	if (!GodotSharpBuilds::make_api_sln(APIAssembly::API_EDITOR))
 		return false;
 
 	EditorProgress pr("mono_project_debug_build", "Building project solution...", 2);

modules/mono/editor/godotsharp_builds.h

@@ -31,6 +31,7 @@
 #ifndef GODOTSHARP_BUILDS_H
 #define GODOTSHARP_BUILDS_H
 
+#include "../mono_gd/gd_mono.h"
 #include "mono_bottom_panel.h"
 #include "mono_build_info.h"
 
@@ -56,17 +57,14 @@ private:
 
 	HashMap<MonoBuildInfo, BuildProcess, MonoBuildInfo::Hasher> builds;
 
+	static String _api_folder_name(APIAssembly::Type p_api_type);
+
 	static GodotSharpBuilds *singleton;
 
 	friend class GDMono;
 	static void _register_internal_calls();
 
 public:
-	enum APIType {
-		API_CORE,
-		API_EDITOR
-	};
-
 	enum BuildTool {
 		MSBUILD_MONO,
 #ifdef WINDOWS_ENABLED
@@ -89,9 +87,9 @@ public:
 	bool build_async(const MonoBuildInfo &p_build_info, GodotSharpBuild_ExitCallback p_callback = NULL);
 
 	static bool build_api_sln(const String &p_name, const String &p_api_sln_dir, const String &p_config);
-	static bool copy_api_assembly(const String &p_src_dir, const String &p_dst_dir, const String &p_assembly_name);
+	static bool copy_api_assembly(const String &p_src_dir, const String &p_dst_dir, const String &p_assembly_name, APIAssembly::Type p_api_type);
 
-	static bool make_api_sln(APIType p_api_type);
+	static bool make_api_sln(APIAssembly::Type p_api_type);
 
 	static bool build_project_blocking(const String &p_config);
 

modules/mono/editor/godotsharp_editor.cpp

@@ -85,10 +85,10 @@ bool GodotSharpEditor::_create_project_solution() {
 			return false;
 		}
 
-		if (!GodotSharpBuilds::make_api_sln(GodotSharpBuilds::API_CORE))
+		if (!GodotSharpBuilds::make_api_sln(APIAssembly::API_CORE))
 			return false;
 
-		if (!GodotSharpBuilds::make_api_sln(GodotSharpBuilds::API_EDITOR))
+		if (!GodotSharpBuilds::make_api_sln(APIAssembly::API_EDITOR))
 			return false;
 
 		pr.step(TTR("Done"));

modules/mono/editor/godotsharp_export.cpp

@@ -55,6 +55,9 @@ void GodotSharpExport::_export_begin(const Set<String> &p_features, bool p_debug
 
 	// TODO right now there is no way to stop the export process with an error
 
+	ERR_FAIL_COND(!GDMono::get_singleton()->is_runtime_initialized());
+	ERR_FAIL_NULL(GDMono::get_singleton()->get_tools_domain());
+
 	String build_config = p_debug ? "Debug" : "Release";
 
 	ERR_FAIL_COND(!GodotSharpBuilds::build_project_blocking(build_config));

modules/mono/glue/cs_files/VERSION.txt

+1

modules/mono/godotsharp_defs.h

@@ -39,4 +39,7 @@
 #define EDITOR_API_ASSEMBLY_NAME "GodotSharpEditor"
 #define EDITOR_TOOLS_ASSEMBLY_NAME "GodotSharpTools"
 
+#define BINDINGS_CLASS_NATIVECALLS "NativeCalls"
+#define BINDINGS_CLASS_NATIVECALLS_EDITOR "EditorNativeCalls"
+
 #endif // GODOTSHARP_DEFS_H

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();
 
@@ -111,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
@@ -126,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; }

modules/mono/mono_gd/gd_mono_utils.cpp

@@ -143,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() {
 
@@ -245,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() {
@@ -305,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) {
@@ -321,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())