Merge #615

615: Made Instance::new use NativeScript::new instead r=toasteater a=toasteater

Unlike `Object::set_script`, this will also work in editors even if the script isn't registered as a tool script.

Also modified CI to run tests in editor mode as well.

Close #614

Co-authored-by: toasteater <[email protected]>

Author: bors[bot]

.travis.yml

@@ -153,4 +153,5 @@ script:
       mkdir ./project/lib;
       cp ../target/debug/libgdnative_test.so ./project/lib/;
       "Godot_v${GODOT_VER}-${GODOT_REL}_linux_headless.64" --path ./project/;
+      "Godot_v${GODOT_VER}-${GODOT_REL}_linux_headless.64" -e --path ./project/ --run-editor-tests;
     fi

bindings_generator/src/api.rs

@@ -137,10 +137,10 @@ impl GodotClass {
 
     pub fn is_singleton_thread_safe(&self) -> bool {
         assert!(self.singleton, "class is not a singleton");
-        match self.name.as_str() {
-            "VisualServer" | "PhysicsServer" | "Physics3DServer" | "Physics2DServer" => false,
-            _ => true,
-        }
+        !matches!(
+            self.name.as_str(),
+            "VisualServer" | "PhysicsServer" | "Physics3DServer" | "Physics2DServer"
+        )
     }
 
     /// Returns the base class from `api` if `base_class` is not empty. Returns `None` otherwise.

gdnative-core/src/nativescript/class.rs

@@ -178,15 +178,26 @@ impl<T: NativeClass> Instance<T, Unique> {
             let gd_api = get_api();
             let nativescript_methods = crate::private::NativeScriptMethodTable::get(gd_api);
 
+            assert_ne!(
+                std::ptr::null(),
+                nativescript_methods.set_class_name,
+                "NativeScript::set_class_name must be available"
+            );
+            assert_ne!(
+                std::ptr::null(),
+                nativescript_methods.set_library,
+                "NativeScript::set_library must be available"
+            );
+            assert_ne!(
+                std::ptr::null(),
+                nativescript_methods.new,
+                "NativeScript::new must be available"
+            );
+
             // The API functions take NUL-terminated C strings. &CStr is not used for its runtime cost.
             let class_name = b"NativeScript\0".as_ptr() as *const libc::c_char;
             let ctor = (gd_api.godot_get_class_constructor)(class_name).unwrap();
 
-            let set_class_name = nativescript_methods.set_class_name;
-            let set_library = nativescript_methods.set_library;
-
-            let object_set_script = crate::private::ObjectMethodTable::get(gd_api).set_script;
-
             let native_script =
                 NonNull::new(ctor()).expect("NativeScript constructor should not return null");
             let native_script =
@@ -198,43 +209,43 @@ impl<T: NativeClass> Instance<T, Unique> {
             let script_class_name = GodotString::from(T::class_name());
             let mut args: [*const libc::c_void; 1] = [script_class_name.sys() as *const _];
             (gd_api.godot_method_bind_ptrcall)(
-                set_class_name,
+                nativescript_methods.set_class_name,
                 native_script.sys().as_ptr(),
                 args.as_mut_ptr(),
                 std::ptr::null_mut(),
             );
 
             let mut args: [*const libc::c_void; 1] = [crate::private::get_gdnative_library_sys()];
             (gd_api.godot_method_bind_ptrcall)(
-                set_library,
+                nativescript_methods.set_library,
                 native_script.sys().as_ptr(),
                 args.as_mut_ptr(),
                 std::ptr::null_mut(),
             );
 
-            let owner = T::Base::construct();
-
-            assert_ne!(
-                std::ptr::null_mut(),
-                owner.sys(),
-                "base object should not be null"
-            );
-
-            let mut args: [*const libc::c_void; 1] = [native_script.sys().as_ptr()];
-            (gd_api.godot_method_bind_ptrcall)(
-                object_set_script,
-                owner.sys(),
+            let mut args: [*const sys::godot_variant; 0] = [];
+            let variant = (gd_api.godot_method_bind_call)(
+                nativescript_methods.new,
+                native_script.sys().as_ptr(),
                 args.as_mut_ptr(),
+                0,
                 std::ptr::null_mut(),
             );
 
+            let variant = Variant::from_sys(variant);
+
+            let owner = variant
+                .try_to_object::<T::Base>()
+                .expect("base object should be of the correct type (is the script registered?)")
+                .assume_unique();
+
             let script_ptr =
                 (gd_api.godot_nativescript_get_userdata)(owner.sys()) as *const libc::c_void;
 
             assert_ne!(
                 std::ptr::null(),
                 script_ptr,
-                "script instance should not be null"
+                "script instance should not be null (did the constructor fail?)"
             );
 
             let script = T::UserData::clone_from_user_data_unchecked(script_ptr);

gdnative-core/src/private.rs

@@ -209,7 +209,6 @@ macro_rules! make_method_table {
 }
 
 make_method_table!(struct ObjectMethodTable for Object {
-    set_script,
     get_class,
     is_class,
 });
@@ -226,4 +225,5 @@ make_method_table!(struct ReferenceMethodTable for Reference {
 make_method_table!(struct NativeScriptMethodTable for NativeScript {
     set_class_name,
     set_library,
+    new,
 });

gdnative-derive/src/methods.rs

@@ -209,12 +209,7 @@ fn impl_gdnative_expose(ast: ItemImpl) -> (ItemImpl, ClassMethodExport) {
 
                 // only allow the "outer" style, aka #[thing] item.
                 method.attrs.retain(|attr| {
-                    let correct_style = match attr.style {
-                        syn::AttrStyle::Outer => true,
-                        _ => false,
-                    };
-
-                    if correct_style {
+                    if matches!(attr.style, syn::AttrStyle::Outer) {
                         let last_seg = attr
                             .path
                             .segments

test/project/addons/editor_test_runner/plugin.cfg

@@ -0,0 +1,7 @@
+[plugin]
+
+name="editor_test_runner"
+description=""
+author=""
+version=""
+script="plugin.gd"

test/project/addons/editor_test_runner/plugin.gd

@@ -0,0 +1,39 @@
+tool
+extends EditorPlugin
+
+var gdn
+
+func _enter_tree():
+	var run_tests = false
+	for arg in OS.get_cmdline_args():
+		if arg == "--run-editor-tests":
+			run_tests = true
+			break
+	if run_tests:
+		_run_tests()
+	else:
+		print("Opening editor normally for the test project. To run tests, pass `--run-editor-tests` to the executable.")
+
+func _run_tests():
+	print(" -- Rust gdnative test suite:")
+	gdn = GDNative.new()
+	var status = false;
+
+	gdn.library = load("res://gdnative.gdnlib")
+
+	if gdn.initialize():
+		status = gdn.call_native("standard_varcall", "run_tests", [])
+
+		gdn.terminate()
+	else:
+		print(" -- Could not load the gdnative library.")
+
+	if status:
+		print(" -- Test run completed successfully.")
+	else:
+		print(" -- Test run completed with errors.")
+		OS.exit_code = 1
+
+	print(" -- exiting.")
+	get_tree().quit()
+

test/project/project.godot

@@ -6,11 +6,18 @@
 ;   [section] ; section goes between []
 ;   param=value ; assign values to parameters
 
-config_version=3
+config_version=4
+
+_global_script_classes=[  ]
+_global_script_class_icons={
+
+}
 
 [application]
 
 config/name="GodotRustTests"
 run/main_scene="res://Scene.tscn"
 
-[rendering]
+[editor_plugins]
+
+enabled=PoolStringArray( "editor_test_runner" )