Allow #[register_with] for #[monomorphize]

Author: chitoyuu

gdnative-core/src/export/class.rs

@@ -99,13 +99,20 @@ pub trait NativeClass: Sized + 'static {
 
 /// A NativeScript "class" that is statically named. [`NativeClass`] types that implement this
 /// trait can be registered using  [`InitHandle::add_class`].
+///
+/// This trait will be renamed to [`Monomorphized`] in a future version since its purpose has
+/// grown beyond simply providing a static type name.
 pub trait StaticallyNamed: NativeClass {
     /// The name of the class.
     ///
     /// This name must be unique for the dynamic library. For generic or library code where this
     /// is hard to satisfy, consider using [`InitHandle::add_class_as`] to provide a name
     /// at registration time instead.
     const CLASS_NAME: &'static str;
+
+    /// Function that registers methods specific to this monomorphization.
+    #[inline]
+    fn nativeclass_register_monomorphized(_builder: &ClassBuilder<Self>) {}
 }
 
 /// Trait used to provide information of Godot-exposed methods of a script class.

gdnative-core/src/init/init_handle.rs

@@ -34,7 +34,19 @@ impl InitHandle {
     where
         C: NativeClassMethods + StaticallyNamed,
     {
-        self.add_maybe_tool_class_as::<C>(Cow::Borrowed(C::CLASS_NAME), false)
+        self.add_class_with::<C>(|_| {})
+    }
+
+    /// Registers a new class to the engine.
+    #[inline]
+    pub fn add_class_with<C>(self, f: impl FnOnce(&ClassBuilder<C>))
+    where
+        C: NativeClassMethods + StaticallyNamed,
+    {
+        self.add_maybe_tool_class_as_with::<C>(Cow::Borrowed(C::CLASS_NAME), false, |builder| {
+            C::nativeclass_register_monomorphized(builder);
+            f(builder);
+        })
     }
 
     /// Registers a new tool class to the engine.
@@ -43,7 +55,19 @@ impl InitHandle {
     where
         C: NativeClassMethods + StaticallyNamed,
     {
-        self.add_maybe_tool_class_as::<C>(Cow::Borrowed(C::CLASS_NAME), true)
+        self.add_tool_class_with::<C>(|_| {})
+    }
+
+    /// Registers a new tool class to the engine.
+    #[inline]
+    pub fn add_tool_class_with<C>(self, f: impl FnOnce(&ClassBuilder<C>))
+    where
+        C: NativeClassMethods + StaticallyNamed,
+    {
+        self.add_maybe_tool_class_as_with::<C>(Cow::Borrowed(C::CLASS_NAME), true, |builder| {
+            C::nativeclass_register_monomorphized(builder);
+            f(builder);
+        })
     }
 
     /// Registers a new class to the engine
@@ -55,7 +79,19 @@ impl InitHandle {
     where
         C: NativeClassMethods,
     {
-        self.add_maybe_tool_class_as::<C>(Cow::Owned(name), false)
+        self.add_class_as_with::<C>(name, |_| {})
+    }
+
+    /// Registers a new class to the engine
+    ///
+    /// If the type implements [`StaticallyTyped`], that name is ignored in favor of the
+    /// name provided at registration.
+    #[inline]
+    pub fn add_class_as_with<C>(self, name: String, f: impl FnOnce(&ClassBuilder<C>))
+    where
+        C: NativeClassMethods,
+    {
+        self.add_maybe_tool_class_as_with::<C>(Cow::Owned(name), false, f)
     }
 
     /// Registers a new tool class to the engine
@@ -67,13 +103,29 @@ impl InitHandle {
     where
         C: NativeClassMethods,
     {
-        self.add_maybe_tool_class_as::<C>(Cow::Owned(name), true)
+        self.add_tool_class_as_with::<C>(name, |_| {})
     }
 
+    /// Registers a new tool class to the engine
+    ///
+    /// If the type implements [`StaticallyTyped`], that name is ignored in favor of the
+    /// name provided at registration.
     #[inline]
-    fn add_maybe_tool_class_as<C>(self, name: Cow<'static, str>, is_tool: bool)
+    pub fn add_tool_class_as_with<C>(self, name: String, f: impl FnOnce(&ClassBuilder<C>))
     where
         C: NativeClassMethods,
+    {
+        self.add_maybe_tool_class_as_with::<C>(Cow::Owned(name), true, f)
+    }
+
+    #[inline]
+    fn add_maybe_tool_class_as_with<C>(
+        self,
+        name: Cow<'static, str>,
+        is_tool: bool,
+        f: impl FnOnce(&ClassBuilder<C>),
+    ) where
+        C: NativeClassMethods,
     {
         let c_class_name = CString::new(&*name).unwrap();
 
@@ -202,6 +254,8 @@ impl InitHandle {
 
             // register methods
             C::nativeclass_register(&builder);
+
+            f(&builder);
         }
     }
 }

gdnative-derive/src/native_script/mod.rs

@@ -353,7 +353,7 @@ fn parse_derive_input(input: &DeriveInput) -> Result<DeriveData, syn::Error> {
 
 pub(crate) fn derive_monomorphize(
     args: AttributeArgs,
-    item_type: ItemType,
+    mut item_type: ItemType,
 ) -> Result<TokenStream2, syn::Error> {
     if let Some(arg) = args.first() {
         return Err(syn::Error::new(
@@ -367,12 +367,32 @@ pub(crate) fn derive_monomorphize(
     let name = &item_type.ident;
     let name_str = name.to_string();
 
+    let register_callback = item_type
+        .attrs
+        .iter()
+        .find(|a| a.path.is_ident("register_with"))
+        .map(|attr| attr.parse_args::<Path>())
+        .transpose()?
+        .map(|path| {
+            quote! {
+                #path(__builder);
+            }
+        });
+
+    item_type
+        .attrs
+        .retain(|attr| !attr.path.is_ident("register_with"));
+
     Ok(quote! {
         #item_type
 
         #derived
         impl #gdnative_core::export::StaticallyNamed for #name {
             const CLASS_NAME: &'static str = #name_str;
+
+            fn nativeclass_register_monomorphized(__builder: &#gdnative_core::export::ClassBuilder<#name>) {
+                #register_callback
+            }
         }
 
         #derived

test/project/main.gd

@@ -190,6 +190,7 @@ func _test_generic_class():
 	var status = true
 
 	status = status && int_ops.add(1, 2) == 3
+	status = status && int_ops.sub(3, 2) == 1
 	status = status && str_ops.add("foo", "bar") == "foobar"
 
 	if !status:

test/src/test_generic_class.rs

@@ -1,4 +1,4 @@
-use std::{marker::PhantomData, ops::Add};
+use std::{marker::PhantomData, ops::Add, ops::Sub};
 
 use gdnative::prelude::*;
 
@@ -40,8 +40,27 @@ where
     }
 }
 
+#[methods(mixin = "SubMixin")]
+impl<T> GenericOps<T>
+where
+    T: FromVariant + ToVariant + Sub<Output = T> + 'static,
+{
+    #[method]
+    fn sub(&self, a: T, b: T) -> T {
+        a - b
+    }
+}
+
 #[gdnative::derive::monomorphize]
+#[register_with(register_sub)]
 type IntOps = GenericOps<i32>;
 
 #[gdnative::derive::monomorphize]
 type StrOps = GenericOps<GodotString>;
+
+fn register_sub<T>(builder: &ClassBuilder<GenericOps<T>>)
+where
+    T: FromVariant + ToVariant + Sub<Output = T> + 'static,
+{
+    builder.mixin::<SubMixin>();
+}