Generated emit() functions now take impl AsArg<T>

Allows types to be *mostly* passed like in other engine APIs, e.g.
- `i32`, `Vector2` and other `Copy` types by value
- `Gd`, `DynGd`, `Variant`, `Array`, `Dictionary` by reference
- Strings by reference or "string" literals

Author: Bromeon

godot-core/src/meta/mod.rs

@@ -72,9 +72,10 @@ pub(crate) use traits::{
 use crate::registry::method::MethodParamOrReturnInfo;
 
 pub(crate) use crate::{
-    arg_into_owned, arg_into_ref, declare_arg_method, impl_asarg_by_ref, impl_asarg_by_value,
-    impl_godot_as_self,
+    arg_into_ref, declare_arg_method, impl_asarg_by_ref, impl_asarg_by_value, impl_godot_as_self,
 };
+// Public due to signals emit() needing it. Should be made pub(crate) again if that changes.
+pub use crate::arg_into_owned;
 
 #[doc(hidden)]
 pub use signature::*;

godot-core/src/obj/dyn_gd.rs

@@ -543,6 +543,23 @@ where
     }
 }
 
+/*
+// See `impl AsArg for Gd<T>` for why this isn't yet implemented.
+impl<'r, T, TBase, D> meta::AsArg<DynGd<TBase, D>> for &'r DynGd<T, D>
+where
+    T: Inherits<TBase>,
+    TBase: GodotClass,
+    D: ?Sized + 'static,
+{
+    fn into_arg<'cow>(self) -> meta::CowArg<'cow, DynGd<TBase, D>>
+    where
+        'r: 'cow,
+    {
+        meta::CowArg::Owned(self.clone().upcast::<TBase>())
+    }
+}
+*/
+
 impl<T, D> meta::ParamType for DynGd<T, D>
 where
     T: GodotClass,

godot-core/src/obj/gd.rs

@@ -852,6 +852,30 @@ impl<'r, T: GodotClass> AsArg<Gd<T>> for &'r Gd<T> {
     }
 }
 
+/*
+// TODO find a way to generalize AsArg to derived->base conversions without breaking type inference in array![].
+// Possibly we could use a "canonical type" with unambiguous mapping (&Gd<T> -> &Gd<T>, not &Gd<T> -> &Gd<TBase>).
+// See also regression test in array_test.rs.
+
+impl<'r, T, TBase> AsArg<Gd<TBase>> for &'r Gd<T>
+where
+    T: Inherits<TBase>,
+    TBase: GodotClass,
+{
+    #[doc(hidden)] // Repeated despite already hidden in trait; some IDEs suggest this otherwise.
+    fn into_arg<'cow>(self) -> CowArg<'cow, Gd<TBase>>
+    where
+        'r: 'cow, // Original reference must be valid for at least as long as the returned cow.
+    {
+        // Performance: clones unnecessarily, which has overhead for ref-counted objects.
+        // A result of being generic over base objects and allowing T: Inherits<Base> rather than just T == Base.
+        // Was previously `CowArg::Borrowed(self)`. Borrowed() can maybe be specialized for objects, or combined with AsObjectArg.
+
+        CowArg::Owned(self.clone().upcast::<TBase>())
+    }
+}
+*/
+
 impl<T: GodotClass> ParamType for Gd<T> {
     type Arg<'v> = CowArg<'v, Gd<T>>;
 

godot-macros/src/class/data_models/signal.rs

@@ -320,8 +320,35 @@ impl SignalCollection {
     }
 }
 
+fn make_asarg_params(params: &venial::Punctuated<venial::FnParam>) -> TokenStream {
+    // Could be specialized by trying to parse types, but won't be 100% accurate due to lack of semantics (AsArg could be a safe fallback). E.g.:
+    // if ty.tokens.iter().any(|tk| matches!(tk, TokenTree::Ident(ident) if ident == "Gd")) {
+    //     quote! { impl ::godot::meta::AsObjectArg<#some_inner_ty> }
+    // }
+
+    let mut tokens = TokenStream::new();
+
+    for (param, _punct) in params.iter() {
+        match param {
+            venial::FnParam::Typed(param) => {
+                let param_name = &param.name;
+                let param_type = &param.ty;
+
+                tokens.extend(quote! {
+                    #param_name: impl ::godot::meta::AsArg<#param_type>,
+                });
+            }
+            venial::FnParam::Receiver(_) => {
+                unreachable!("signals have no receivers; already checked")
+            }
+        };
+    }
+
+    tokens
+}
+
 fn make_signal_individual_struct(details: &SignalDetails) -> TokenStream {
-    let emit_params = &details.fn_signature.params;
+    let emit_params = make_asarg_params(&details.fn_signature.params);
 
     let SignalDetails {
         // class_name,
@@ -360,6 +387,12 @@ fn make_signal_individual_struct(details: &SignalDetails) -> TokenStream {
         #(#signal_cfg_attrs)*
         impl<C: ::godot::obj::WithSignals> #individual_struct_name<'_, C> {
             pub fn emit(&mut self, #emit_params) {
+                use ::godot::meta::AsArg;
+                #(
+                    ::godot::meta::arg_into_owned!(infer #param_names);
+                    //let #param_names = #param_names.into_arg();
+                )*
+
                 self.__typed.emit_tuple((#( #param_names, )*));
             }
         }

itest/rust/src/builtin_tests/containers/signal_test.rs

@@ -122,6 +122,28 @@ fn signal_symbols_external() {
     emitter.free();
 }
 
+// "External" means connect/emit happens from outside the class, via Gd::signals().
+#[cfg(since_api = "4.2")]
+#[itest]
+fn signal_symbols_complex_emit() {
+    let mut emitter = Emitter::new_alloc();
+    let arg = emitter.clone();
+    let mut sig = emitter.signals().signal_obj();
+
+    let tracker = Rc::new(RefCell::new(None));
+    {
+        let tracker = tracker.clone();
+        sig.connect(move |obj: Gd<Object>, name: GString| {
+            *tracker.borrow_mut() = Some((obj, name));
+        });
+    }
+
+    // Forward compat: .upcast() here becomes a breaking change if we generalize AsArg to include derived->base conversions.
+    sig.emit(&arg.upcast(), "hello");
+
+    emitter.free();
+}
+
 // "External" means connect/emit happens from outside the class, via Gd::signals().
 #[cfg(since_api = "4.2")]
 #[itest]
@@ -396,7 +418,7 @@ mod emitter {
         pub fn signal_int(arg1: i64);
 
         #[signal]
-        fn signal_obj(arg1: Gd<Object>, arg2: GString);
+        pub(super) fn signal_obj(arg1: Gd<Object>, arg2: GString);
 
         #[func]
         pub fn self_receive(&mut self, arg1: i64) {

itest/rust/src/engine_tests/async_test.rs

@@ -229,7 +229,10 @@ fn async_typed_signal_with_array() -> TaskHandle {
         assert_eq!(result, array![1, 2, 3]);
     });
 
-    object.signals().custom_signal_array().emit(array![1, 2, 3]);
+    object
+        .signals()
+        .custom_signal_array()
+        .emit(&array![1, 2, 3]);
 
     task_handle
 }

itest/rust/src/object_tests/dyn_gd_test.rs

@@ -347,6 +347,7 @@ fn dyn_gd_store_in_godot_array() {
     let a = Gd::from_object(RefcHealth { hp: 33 }).into_dyn();
     let b = foreign::NodeHealth::new_alloc().into_dyn();
 
+    // Forward compat: .upcast() here becomes a breaking change if we generalize AsArg to include derived->base conversions.
     let array: Array<DynGd<Object, _>> = array![&a.upcast(), &b.upcast()];
 
     assert_eq!(array.at(0).dyn_bind().get_hitpoints(), 33);
@@ -355,8 +356,9 @@ fn dyn_gd_store_in_godot_array() {
     array.at(1).free();
 
     // Tests also type inference of array![]. Independent variable c.
-    let c = Gd::from_object(RefcHealth { hp: 33 }).into_dyn();
-    let array_inferred = array![&c];
+    let c: DynGd<RefcHealth, dyn Health> = Gd::from_object(RefcHealth { hp: 33 }).into_dyn();
+    let c = c.upcast::<RefCounted>();
+    let array_inferred /*: Array<DynGd<RefCounted, _>>*/ = array![&c];
     assert_eq!(array_inferred.at(0).dyn_bind().get_hitpoints(), 33);
 }
 

itest/rust/src/object_tests/object_test.rs

@@ -1040,6 +1040,7 @@ pub mod object_test_gd {
 
         #[func]
         fn return_nested_self() -> Array<Gd<<Self as GodotClass>::Base>> {
+            // Forward compat: .upcast() here becomes a breaking change if we generalize AsArg to include derived->base conversions.
             array![&Self::return_self().upcast()]
         }
     }