Merge pull request #552 from godot-rust/qol/bounds

Split `GodotClass`/`Bounds`, `UserClass` -> `NewGd`/`NewAlloc`

Author: Bromeon

examples/dodge-the-creeps/rust/src/main_scene.rs

@@ -119,7 +119,7 @@ impl Main {
 impl INode for Main {
     fn init(base: Base<Node>) -> Self {
         Main {
-            mob_scene: PackedScene::new(),
+            mob_scene: PackedScene::new_gd(),
             score: 0,
             base,
             music: None,

godot-codegen/src/class_generator.rs

@@ -452,7 +452,7 @@ fn make_constructor_and_default(
     // Note: this could use class_name() but is not yet done due to upcoming lazy-load refactoring.
     //let class_name_obj = quote! { <Self as crate::obj::GodotClass>::class_name() };
 
-    let (constructor, godot_default_impl);
+    let (constructor, has_godot_default_impl);
     if ctx.is_singleton(godot_class_name) {
         // Note: we cannot return &'static mut Self, as this would be very easy to mutably alias.
         // &'static Self would be possible, but we would lose the whole mutability information (even if that is best-effort and
@@ -468,43 +468,38 @@ fn make_constructor_and_default(
                 }
             }
         };
-        godot_default_impl = TokenStream::new();
+        has_godot_default_impl = false;
     } else if !class.is_instantiable {
         // Abstract base classes or non-singleton classes without constructor
         constructor = TokenStream::new();
-        godot_default_impl = TokenStream::new();
+        has_godot_default_impl = false;
     } else if class.is_refcounted {
         // RefCounted, Resource, etc
         constructor = quote! {
+            #[deprecated = "Replaced with `new_gd` in extension trait `NewGd`."]
             pub fn new() -> Gd<Self> {
-                unsafe {
-                    let class_name = #godot_class_stringname;
-                    let object_ptr = sys::interface_fn!(classdb_construct_object)(class_name.string_sys());
-                    Gd::from_obj_sys(object_ptr)
-                }
+                // <Self as crate::obj::NewGd>::new_gd()
+                crate::obj::Gd::default()
             }
         };
-        godot_default_impl = quote! {
+        has_godot_default_impl = true;
+    } else {
+        // Manually managed classes: Object, Node etc
+        constructor = quote! {};
+        has_godot_default_impl = true;
+    }
+
+    let godot_default_impl = if has_godot_default_impl {
+        quote! {
             impl crate::obj::cap::GodotDefault for #class_name {
                 fn __godot_default() -> crate::obj::Gd<Self> {
-                    Self::new()
+                    crate::engine::construct_engine_object::<Self>()
                 }
             }
-        };
+        }
     } else {
-        // Manually managed classes: Object, Node etc
-        constructor = quote! {
-            #[must_use]
-            pub fn new_alloc() -> Gd<Self> {
-                unsafe {
-                    let class_name = #godot_class_stringname;
-                    let object_ptr = sys::interface_fn!(classdb_construct_object)(class_name.string_sys());
-                    Gd::from_obj_sys(object_ptr)
-                }
-            }
-        };
-        godot_default_impl = TokenStream::new();
-    }
+        TokenStream::new()
+    };
 
     (constructor, godot_default_impl)
 }
@@ -609,12 +604,18 @@ fn make_class(class: &Class, class_name: &TyName, ctx: &mut Context) -> Generate
         }
     };
 
-    let memory = if class_name.rust_ty == "Object" {
-        ident("DynamicRefCount")
+    let assoc_dyn_memory = if class_name.rust_ty == "Object" {
+        ident("MemDynamic")
     } else if class.is_refcounted {
-        ident("StaticRefCount")
+        ident("MemRefCounted")
     } else {
-        ident("ManualMemory")
+        ident("MemManual")
+    };
+
+    let assoc_memory = if class.is_refcounted {
+        ident("MemRefCounted")
+    } else {
+        ident("MemManual")
     };
 
     // mod re_export needed, because class should not appear inside the file module, and we can't re-export private struct as pub.
@@ -648,15 +649,19 @@ fn make_class(class: &Class, class_name: &TyName, ctx: &mut Context) -> Generate
                 #internal_methods
                 #constants
             }
-            unsafe impl crate::obj::GodotClass for #class_name {
+            impl crate::obj::GodotClass for #class_name {
                 type Base = #base_ty;
-                type Declarer = crate::obj::dom::EngineDomain;
-                type Mem = crate::obj::mem::#memory;
-                const INIT_LEVEL: Option<crate::init::InitLevel> = #init_level;
 
                 fn class_name() -> ClassName {
                     ClassName::from_ascii_cstr(#class_name_cstr)
                 }
+
+                const INIT_LEVEL: crate::init::InitLevel = #init_level;
+            }
+            unsafe impl crate::obj::Bounds for #class_name {
+                type Memory = crate::obj::bounds::#assoc_memory;
+                type DynMemory = crate::obj::bounds::#assoc_dyn_memory;
+                type Declarer = crate::obj::bounds::DeclEngine;
             }
             impl crate::obj::EngineClass for #class_name {
                 fn as_object_ptr(&self) -> sys::GDExtensionObjectPtr {

godot-codegen/src/util.rs

@@ -65,9 +65,9 @@ impl ClassCodegenLevel {
 
     pub fn to_init_level(self) -> TokenStream {
         match self {
-            Self::Servers => quote! { Some(crate::init::InitLevel::Servers) },
-            Self::Scene => quote! { Some(crate::init::InitLevel::Scene) },
-            Self::Editor => quote! { Some(crate::init::InitLevel::Editor) },
+            Self::Servers => quote! { crate::init::InitLevel::Servers },
+            Self::Scene => quote! { crate::init::InitLevel::Scene },
+            Self::Editor => quote! { crate::init::InitLevel::Editor },
         }
     }
 }

godot-core/src/builder/method.rs

@@ -117,7 +117,7 @@ macro_rules! impl_code_method {
 
                 $(
                     let $arg = <$Param as sys::GodotFfi>::from_sys(*args.offset(idx));
-                    // FIXME update refcount, e.g. Gd::ready() or T::Mem::maybe_inc_ref(&result);
+                    // FIXME update refcount, e.g. Gd::ready() or T::DynMemory::maybe_inc_ref(&result);
                     // possibly in from_sys() directly; what about from_sys_init() and from_{obj|str}_sys()?
                     idx += 1;
                 )*

godot-core/src/builtin/array.rs

@@ -8,7 +8,6 @@
 use godot_ffi as sys;
 
 use crate::builtin::*;
-use crate::obj::Share;
 use crate::property::{Export, Property, PropertyHintInfo, TypeStringHint};
 use std::fmt;
 use std::marker::PhantomData;
@@ -718,12 +717,6 @@ impl<T: GodotType> Clone for Array<T> {
     }
 }
 
-impl<T: GodotType> Share for Array<T> {
-    fn share(&self) -> Self {
-        self.clone()
-    }
-}
-
 impl<T: GodotType + TypeStringHint> TypeStringHint for Array<T> {
     fn type_string() -> String {
         format!("{}:{}", VariantType::Array as i32, T::type_string())

godot-core/src/builtin/callable.rs

@@ -10,7 +10,8 @@ use godot_ffi as sys;
 use crate::builtin::meta::{impl_godot_as_self, GodotType, ToGodot};
 use crate::builtin::{inner, StringName, Variant, VariantArray};
 use crate::engine::Object;
-use crate::obj::mem::Memory;
+use crate::obj::bounds::DynMemory;
+use crate::obj::Bounds;
 use crate::obj::{Gd, GodotClass, InstanceId};
 use std::{fmt, ptr};
 use sys::{ffi_methods, GodotFfi};
@@ -202,7 +203,7 @@ impl Callable {
         // Increment refcount because we're getting a reference, and `InnerCallable::get_object` doesn't
         // increment the refcount.
         self.as_inner().get_object().map(|object| {
-            <Object as GodotClass>::Mem::maybe_inc_ref(&object.raw);
+            <Object as Bounds>::DynMemory::maybe_inc_ref(&object.raw);
             object
         })
     }

godot-core/src/builtin/dictionary.rs

@@ -9,7 +9,6 @@ use godot_ffi as sys;
 
 use crate::builtin::meta::{FromGodot, ToGodot};
 use crate::builtin::{inner, Variant};
-use crate::obj::Share;
 use crate::property::{Export, Property, PropertyHintInfo, TypeStringHint};
 use std::fmt;
 use std::marker::PhantomData;
@@ -340,12 +339,6 @@ impl Clone for Dictionary {
     }
 }
 
-impl Share for Dictionary {
-    fn share(&self) -> Self {
-        self.clone()
-    }
-}
-
 impl Property for Dictionary {
     type Intermediate = Self;
 

godot-core/src/builtin/meta/class_name.rs

@@ -33,7 +33,10 @@ pub struct ClassName {
 }
 
 impl ClassName {
-    #[doc(hidden)]
+    /// Construct from a null-terminated ASCII string.
+    ///
+    /// # Panics
+    /// If the string is not null-terminated or contains internal null bytes.
     pub fn from_ascii_cstr(bytes: &'static [u8]) -> Self {
         assert!(bytes.is_ascii(), "string must be ASCII"); // only half of u8 range
         let c_str = CStr::from_bytes_with_nul(bytes).expect("string must be null-terminated");

godot-core/src/engine/mod.rs

@@ -8,8 +8,7 @@
 //! Godot engine classes and methods.
 
 use crate::builtin::{GString, NodePath};
-use crate::obj::dom::EngineDomain;
-use crate::obj::{Gd, GodotClass, Inherits, InstanceId};
+use crate::obj::{bounds, Bounds, Gd, GodotClass, Inherits, InstanceId};
 use std::collections::HashSet;
 
 // Re-exports of generated symbols
@@ -115,7 +114,7 @@ impl NodeExt for Node {
 
 impl<U> NodeExt for Gd<U>
 where
-    U: GodotClass<Declarer = EngineDomain> + Inherits<Node>,
+    U: Bounds<Declarer = bounds::DeclEngine> + Inherits<Node>,
 {
     fn try_get_node_as<T>(&self, path: impl Into<NodePath>) -> Option<Gd<T>>
     where
@@ -161,8 +160,16 @@ pub(crate) fn object_ptr_from_id(instance_id: InstanceId) -> sys::GDExtensionObj
     unsafe { sys::interface_fn!(object_get_instance_from_id)(instance_id.to_u64()) }
 }
 
-// ----------------------------------------------------------------------------------------------------------------------------------------------
-// Implementation of this file
+pub(crate) fn construct_engine_object<T>() -> Gd<T>
+where
+    T: GodotClass + Bounds<Declarer = bounds::DeclEngine>,
+{
+    // SAFETY: adhere to Godot API; valid class name and returned pointer is an object.
+    unsafe {
+        let object_ptr = sys::interface_fn!(classdb_construct_object)(T::class_name().string_sys());
+        Gd::from_obj_sys(object_ptr)
+    }
+}
 
 pub(crate) fn ensure_object_alive(
     instance_id: InstanceId,
@@ -203,6 +210,9 @@ pub(crate) fn ensure_object_inherits(
     )
 }
 
+// ----------------------------------------------------------------------------------------------------------------------------------------------
+// Implementation of this file
+
 /// Checks if `derived` inherits from `base`, using a cache for _successful_ queries.
 #[cfg(debug_assertions)]
 fn is_derived_base_cached(derived: ClassName, base: ClassName) -> bool {