Merge #682

682: Construct Godot API objects from class names r=toasteater a=toasteater

This adds the `Ref::<T>::by_class_name` constructor that instantiates a sub-class of `T` by its name. If the resulting object cannot be casted to `T`, it is correctly freed depending on whether it is a `Reference`, and `None` is returned. As with `Ref::cast`, there is the caveat that reference-counted classes cannot be casted to `Object`s, since memory management is determined statically.

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

Author: bors[bot]

.github/workflows/ci.yml

@@ -227,13 +227,25 @@ jobs:
           cd test;
           mkdir -p ./project/lib;
           cp ../target/debug/libgdnative_test.so ./project/lib/;
-          "${{ runner.temp }}/godot_bin/Godot_v${GODOT_VER}-${GODOT_REL}_linux_headless.64" --path ./project/;
-          "${{ runner.temp }}/godot_bin/Godot_v${GODOT_VER}-${GODOT_REL}_linux_headless.64" -e --path ./project/ --run-editor-tests;
+          "${{ runner.temp }}/godot_bin/Godot_v${GODOT_VER}-${GODOT_REL}_linux_headless.64" --path ./project/ > >(tee "${{ runner.temp }}/stdout.log");
+          if grep -q "Leaked instance" "${{ runner.temp }}/stdout.log"; then
+            exit 1;
+          fi;
+          "${{ runner.temp }}/godot_bin/Godot_v${GODOT_VER}-${GODOT_REL}_linux_headless.64" -e --path ./project/ --run-editor-tests > >(tee "${{ runner.temp }}/stdout.log");
+          if grep -q "Leaked instance" "${{ runner.temp }}/stdout.log"; then
+            exit 1;
+          fi;
           cargo build --features=type_tag_fallback;
           mkdir -p ./project/lib;
           cp ../target/debug/libgdnative_test.so ./project/lib/;
-          "${{ runner.temp }}/godot_bin/Godot_v${GODOT_VER}-${GODOT_REL}_linux_headless.64" --path ./project/;
-          "${{ runner.temp }}/godot_bin/Godot_v${GODOT_VER}-${GODOT_REL}_linux_headless.64" -e --path ./project/ --run-editor-tests;
+          "${{ runner.temp }}/godot_bin/Godot_v${GODOT_VER}-${GODOT_REL}_linux_headless.64" --path ./project/ > >(tee "${{ runner.temp }}/stdout.log");
+          if grep -q "Leaked instance" "${{ runner.temp }}/stdout.log"; then
+            exit 1;
+          fi;
+          "${{ runner.temp }}/godot_bin/Godot_v${GODOT_VER}-${GODOT_REL}_linux_headless.64" -e --path ./project/ --run-editor-tests > >(tee "${{ runner.temp }}/stdout.log");
+          if grep -q "Leaked instance" "${{ runner.temp }}/stdout.log"; then
+            exit 1;
+          fi;
           
   # This job doesn't actually test anything, but they're used to tell bors the
   # build completed, as there is no practical way to detect when a workflow is

gdnative-core/src/object.rs

@@ -1,11 +1,12 @@
 use std::borrow::Borrow;
+use std::ffi::CString;
 use std::fmt::{self, Debug};
 use std::hash::{Hash, Hasher};
 use std::marker::PhantomData;
 use std::ops::Deref;
 use std::ptr::NonNull;
 
-use crate::private::{get_api, ReferenceCountedClassPlaceholder};
+use crate::private::{get_api, ManuallyManagedClassPlaceholder, ReferenceCountedClassPlaceholder};
 use crate::ref_kind::{ManuallyManaged, RefCounted, RefKind};
 use crate::sys;
 use crate::thread_access::{
@@ -322,6 +323,27 @@ impl<T: GodotObject + Instanciable> Ref<T, Unique> {
     }
 }
 
+impl<T: GodotObject> Ref<T, Unique> {
+    /// Creates a new instance of a sub-class of `T` by its class name. Returns `None` if the
+    /// class does not exist, cannot be constructed, has a different `RefKind` from, or is not
+    /// a sub-class of `T`.
+    ///
+    /// The lifetime of the returned object is *not* automatically managed if `T` is a manually-
+    /// managed type. This means that if `Object` is used as the type parameter, any `Reference`
+    /// objects created, if returned, will be leaked. As a result, such calls will return `None`.
+    /// Casting between `Object` and `Reference` is possible on `TRef` and bare references.
+    #[inline]
+    pub fn by_class_name(class_name: &str) -> Option<Self> {
+        unsafe {
+            // Classes with NUL-bytes in their names can not exist
+            let class_name = CString::new(class_name).ok()?;
+            let ctor = (get_api().godot_get_class_constructor)(class_name.as_ptr())?;
+            let ptr = NonNull::new(ctor() as *mut sys::godot_object)?;
+            <T::RefKind as RefKindSpec>::impl_from_maybe_ref_counted(ptr)
+        }
+    }
+}
+
 /// Method for references that can be safely used.
 impl<T: GodotObject, Access: ThreadAccess> Ref<T, Access>
 where
@@ -1131,6 +1153,11 @@ pub trait RefKindSpec: Sized {
     #[doc(hidden)]
     type PtrWrapper: PtrWrapper;
 
+    #[doc(hidden)]
+    unsafe fn impl_from_maybe_ref_counted<T: GodotObject<RefKind = Self>>(
+        ptr: NonNull<sys::godot_object>,
+    ) -> Option<Ref<T, Unique>>;
+
     #[doc(hidden)]
     unsafe fn impl_assume_safe<'a, T: GodotObject<RefKind = Self>>(
         this: &Ref<T, Shared>,
@@ -1159,6 +1186,25 @@ pub trait RefKindSpec: Sized {
 impl RefKindSpec for ManuallyManaged {
     type PtrWrapper = Forget;
 
+    #[inline(always)]
+    unsafe fn impl_from_maybe_ref_counted<T: GodotObject<RefKind = Self>>(
+        ptr: NonNull<sys::godot_object>,
+    ) -> Option<Ref<T, Unique>> {
+        if RawObject::<ReferenceCountedClassPlaceholder>::try_from_sys_ref(ptr).is_some() {
+            drop(Ref::<ReferenceCountedClassPlaceholder, Unique>::init_from_sys(ptr));
+            None
+        } else {
+            let obj = Ref::<ManuallyManagedClassPlaceholder, Unique>::init_from_sys(ptr);
+
+            if obj.as_raw().is_class::<T>() {
+                Some(obj.cast_unchecked())
+            } else {
+                obj.free();
+                None
+            }
+        }
+    }
+
     #[inline(always)]
     unsafe fn impl_assume_safe<'a, T: GodotObject<RefKind = Self>>(
         this: &Ref<T, Shared>,
@@ -1190,6 +1236,24 @@ impl RefKindSpec for ManuallyManaged {
 impl RefKindSpec for RefCounted {
     type PtrWrapper = UnRef;
 
+    #[inline(always)]
+    unsafe fn impl_from_maybe_ref_counted<T: GodotObject<RefKind = Self>>(
+        ptr: NonNull<sys::godot_object>,
+    ) -> Option<Ref<T, Unique>> {
+        if RawObject::<ReferenceCountedClassPlaceholder>::try_from_sys_ref(ptr).is_some() {
+            let obj = Ref::<ReferenceCountedClassPlaceholder, Unique>::init_from_sys(ptr);
+
+            if obj.as_raw().is_class::<T>() {
+                Some(obj.cast_unchecked())
+            } else {
+                None
+            }
+        } else {
+            RawObject::<ManuallyManagedClassPlaceholder>::from_sys_ref_unchecked(ptr).free();
+            None
+        }
+    }
+
     #[inline(always)]
     unsafe fn impl_assume_safe<'a, T: GodotObject<RefKind = Self>>(
         this: &Ref<T, Shared>,

gdnative-core/src/private.rs

@@ -150,7 +150,7 @@ unsafe impl crate::object::GodotObject for ManuallyManagedClassPlaceholder {
     type RefKind = crate::ref_kind::ManuallyManaged;
 
     fn class_name() -> &'static str {
-        "{placeholder} manually managed object"
+        "Object"
     }
 }
 
@@ -162,7 +162,7 @@ unsafe impl crate::object::GodotObject for ReferenceCountedClassPlaceholder {
     type RefKind = crate::ref_kind::RefCounted;
 
     fn class_name() -> &'static str {
-        "{placeholder} reference counted object"
+        "Reference"
     }
 }
 

test/src/lib.rs

@@ -1,8 +1,8 @@
 #![allow(clippy::blacklisted_name)]
 
-use gdnative::api;
 use gdnative::prelude::*;
 
+mod test_constructor;
 mod test_derive;
 mod test_free_ub;
 mod test_register;
@@ -54,13 +54,13 @@ pub extern "C" fn run_tests(
     status &= gdnative::core_types::test_vector3_array_access();
     status &= gdnative::core_types::test_vector3_array_debug();
 
-    status &= test_constructor();
     status &= test_underscore_method_binding();
     status &= test_rust_class_construction();
     status &= test_from_instance_id();
 
     status &= test_derive::run_tests();
     status &= test_free_ub::run_tests();
+    status &= test_constructor::run_tests();
     status &= test_register::run_tests();
     status &= test_return_leak::run_tests();
     status &= test_variant_call_args::run_tests();
@@ -70,21 +70,6 @@ pub extern "C" fn run_tests(
     gdnative::core_types::Variant::from_bool(status).forget()
 }
 
-fn test_constructor() -> bool {
-    println!(" -- test_constructor");
-
-    // Just create an object and call a method as a sanity check for the
-    // generated constructors.
-    let lib = api::GDNativeLibrary::new();
-    let _ = lib.is_singleton();
-
-    let path = api::Path2D::new();
-    let _ = path.z_index();
-    path.free();
-
-    true
-}
-
 fn test_underscore_method_binding() -> bool {
     println!(" -- test_underscore_method_binding");
 
@@ -269,6 +254,7 @@ fn init(handle: InitHandle) {
 
     test_derive::register(handle);
     test_free_ub::register(handle);
+    test_constructor::register(handle);
     test_register::register(handle);
     test_return_leak::register(handle);
     test_variant_call_args::register(handle);

test/src/test_constructor.rs

@@ -0,0 +1,69 @@
+use gdnative::api;
+use gdnative::prelude::*;
+
+pub(crate) fn run_tests() -> bool {
+    let mut status = true;
+
+    status &= test_constructor();
+    status &= test_from_class_name();
+
+    status
+}
+
+pub(crate) fn register(_handle: InitHandle) {}
+
+fn test_constructor() -> bool {
+    println!(" -- test_constructor");
+
+    // Just create an object and call a method as a sanity check for the
+    // generated constructors.
+    let lib = api::GDNativeLibrary::new();
+    let _ = lib.is_singleton();
+
+    let path = api::Path2D::new();
+    let _ = path.z_index();
+    path.free();
+
+    true
+}
+
+fn test_from_class_name() -> bool {
+    println!(" -- test_from_class_name");
+
+    let ok = std::panic::catch_unwind(|| {
+        // Since this method is restricted to Godot types, there is no way we can detect
+        // here whether any invalid objects are leaked. Instead, the CI script is modified
+        // to look at stdout for any reported leaks.
+
+        let node = Ref::<Node, _>::by_class_name("Node2D").unwrap();
+        assert_eq!("Node2D", node.get_class().to_string());
+        let node = node.cast::<Node2D>().unwrap();
+        assert_eq!("Node2D", node.get_class().to_string());
+        let _ = node.position();
+        node.free();
+
+        let shader = Ref::<Reference, _>::by_class_name("Shader").unwrap();
+        assert_eq!("Shader", &shader.get_class().to_string());
+        let shader = shader.cast::<Shader>().unwrap();
+        assert_eq!("Shader", &shader.get_class().to_string());
+
+        let none = Ref::<Object, _>::by_class_name("Shader");
+        assert!(none.is_none());
+
+        let none = Ref::<Node2D, _>::by_class_name("Spatial");
+        assert!(none.is_none());
+
+        let none = Ref::<Shader, _>::by_class_name("AudioEffectReverb");
+        assert!(none.is_none());
+
+        let none = Ref::<Object, _>::by_class_name("ClassThatDoesNotExistProbably");
+        assert!(none.is_none());
+    })
+    .is_ok();
+
+    if !ok {
+        gdnative::godot_error!("   !! Test test_from_class_name failed");
+    }
+
+    ok
+}