remove ParamType from AsArg

Author: TitanNano

godot-core/src/builtin/collections/array.rs

@@ -1118,15 +1118,6 @@ unsafe impl<T: ArrayElement> GodotFfi for Array<T> {
 // Only implement for untyped arrays; typed arrays cannot be nested in Godot.
 impl ArrayElement for VariantArray {}
 
-impl<'r, T: ArrayElement> AsArg<Array<T>> for &'r Array<T> {
-    fn into_arg<'cow>(self) -> CowArg<'cow, Array<T>>
-    where
-        'r: 'cow, // Original reference must be valid for at least as long as the returned cow.
-    {
-        CowArg::Borrowed(self)
-    }
-}
-
 impl<T: ArrayElement> ParamType for Array<T> {
     type Arg<'v> = CowArg<'v, Self>;
 

godot-core/src/meta/args/as_arg.rs

@@ -6,7 +6,7 @@
  */
 
 use crate::builtin::{GString, NodePath, StringName};
-use crate::meta::{sealed, CowArg};
+use crate::meta::{sealed, CowArg, ToGodot};
 use std::ffi::CStr;
 
 /// Implicit conversions for arguments passed to Godot APIs.
@@ -53,16 +53,37 @@ use std::ffi::CStr;
     note = "GString/StringName/NodePath aren't implicitly convertible for performance reasons; use their `arg()` method.",
     note = "see also `AsArg` docs: https://godot-rust.github.io/docs/gdext/master/godot/meta/trait.AsArg.html"
 )]
-pub trait AsArg<T: ParamType>
+pub trait AsArg<T: ToGodot>
 where
     Self: Sized,
 {
+    // The usage of the CowArg return type introduces a small runtime penalty for values that implement Copy. Currently, the usage
+    // ergonomics out weigh the runtime cost. Using the CowArg allows us to create a blanket implementation of the trait for all types that
+    // implement ToGodot.
     #[doc(hidden)]
-    fn into_arg<'r>(self) -> <T as ParamType>::Arg<'r>
+    fn into_arg<'r>(self) -> CowArg<'r, T>
     where
         Self: 'r;
 }
 
+impl<T: ToGodot> AsArg<T> for &T {
+    fn into_arg<'r>(self) -> CowArg<'r, T>
+    where
+        Self: 'r,
+    {
+        CowArg::Borrowed(self)
+    }
+}
+
+impl<T: ToGodot + Copy> AsArg<T> for T {
+    fn into_arg<'r>(self) -> CowArg<'r, T>
+    where
+        Self: 'r,
+    {
+        CowArg::Owned(self)
+    }
+}
+
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Blanket impls
 
@@ -81,7 +102,7 @@ macro_rules! arg_into_ref {
     };
     ($arg_variable:ident: $T:ty) => {
         let $arg_variable = $arg_variable.into_arg();
-        let $arg_variable: &$T = $crate::meta::ParamType::arg_to_ref(&$arg_variable);
+        let $arg_variable: &$T = $arg_variable.cow_as_ref();
     };
 }
 
@@ -102,20 +123,13 @@ macro_rules! arg_into_owned {
     };
     (infer $arg_variable:ident) => {
         let $arg_variable = $arg_variable.into_arg();
-        let $arg_variable = $crate::meta::ParamType::arg_into_owned($arg_variable);
+        let $arg_variable = $arg_variable.cow_into_owned();
     };
 }
 
 #[macro_export]
 macro_rules! impl_asarg_by_value {
     ($T:ty) => {
-        impl $crate::meta::AsArg<$T> for $T {
-            fn into_arg<'r>(self) -> <$T as $crate::meta::ParamType>::Arg<'r> {
-                // Moves value (but typically a Copy type).
-                self
-            }
-        }
-
         impl $crate::meta::ParamType for $T {
             type Arg<'v> = $T;
 
@@ -137,22 +151,6 @@ macro_rules! impl_asarg_by_value {
 #[macro_export]
 macro_rules! impl_asarg_by_ref {
     ($T:ty) => {
-        impl<'r> $crate::meta::AsArg<$T> for &'r $T {
-            // 1 rustfmt + 1 rustc problems (bugs?) here:
-            // - formatting doesn't converge; `where` keeps being further indented on each run.
-            // - a #[rustfmt::skip] annotation over the macro causes a compile error when mentioning `crate::impl_asarg_by_ref`.
-            //   "macro-expanded `macro_export` macros from the current crate cannot be referred to by absolute paths"
-            // Thus, keep `where` on same line.
-            // type ArgType<'v> = &'v $T where Self: 'v;
-
-            fn into_arg<'cow>(self) -> <$T as $crate::meta::ParamType>::Arg<'cow>
-            where
-                'r: 'cow, // Original reference must be valid for at least as long as the returned cow.
-            {
-                $crate::meta::CowArg::Borrowed(self)
-            }
-        }
-
         impl $crate::meta::ParamType for $T {
             type Arg<'v> = $crate::meta::CowArg<'v, $T>;
 
@@ -199,7 +197,7 @@ macro_rules! declare_arg_method {
 /// This is necessary for packed array dispatching to different "inner" backend signatures.
 impl<T> AsArg<T> for CowArg<'_, T>
 where
-    for<'r> T: ParamType<Arg<'r> = CowArg<'r, T>> + 'r,
+    for<'r> T: ToGodot,
 {
     fn into_arg<'r>(self) -> CowArg<'r, T>
     where
@@ -273,7 +271,7 @@ impl AsArg<NodePath> for &String {
 /// Implemented for all parameter types `T` that are allowed to receive [impl `AsArg<T>`][AsArg].
 // ParamType used to be a subtrait of GodotType, but this can be too restrictive. For example, DynGd is not a "Godot canonical type"
 // (GodotType), however it's still useful to store it in arrays -- which requires AsArg and subsequently ParamType.
-pub trait ParamType: sealed::Sealed + Sized + 'static
+pub trait ParamType: sealed::Sealed + Sized + 'static + ToGodot
 // GodotType bound not required right now, but conceptually should always be the case.
 {
     /// Canonical argument passing type, either `T` or an internally-used CoW type.

godot-core/src/meta/args/cow_arg.rs

@@ -11,6 +11,7 @@ use crate::meta::{FromGodot, GodotConvert, GodotFfiVariant, RefArg, ToGodot};
 use crate::sys;
 use godot_ffi::{GodotFfi, GodotNullableFfi, PtrcallType};
 use std::fmt;
+use std::ops::Deref;
 
 /// Owned or borrowed value, used when passing arguments through `impl AsArg` to Godot APIs.
 #[doc(hidden)]
@@ -182,3 +183,14 @@ where
         self.cow_as_ref().is_null()
     }
 }
+
+impl<T> Deref for CowArg<'_, T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        match self {
+            CowArg::Owned(value) => value,
+            CowArg::Borrowed(value) => value,
+        }
+    }
+}

godot-core/src/obj/dyn_gd.rs

@@ -530,19 +530,6 @@ where
     }
 }
 
-impl<'r, T, D> meta::AsArg<DynGd<T, D>> for &'r DynGd<T, D>
-where
-    T: GodotClass,
-    D: ?Sized + 'static,
-{
-    fn into_arg<'cow>(self) -> meta::CowArg<'cow, DynGd<T, D>>
-    where
-        'r: 'cow, // Original reference must be valid for at least as long as the returned cow.
-    {
-        meta::CowArg::Borrowed(self)
-    }
-}
-
 /*
 // 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>

godot-core/src/obj/gd.rs

@@ -842,16 +842,6 @@ impl<T: GodotClass> ArrayElement for Option<Gd<T>> {
     }
 }
 
-impl<'r, T: GodotClass> AsArg<Gd<T>> for &'r Gd<T> {
-    #[doc(hidden)] // Repeated despite already hidden in trait; some IDEs suggest this otherwise.
-    fn into_arg<'cow>(self) -> CowArg<'cow, Gd<T>>
-    where
-        'r: 'cow, // Original reference must be valid for at least as long as the returned cow.
-    {
-        CowArg::Borrowed(self)
-    }
-}
-
 /*
 // 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>).

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

@@ -9,8 +9,9 @@ use crate::framework::itest;
 use godot::builtin::{vslice, GString, Signal, StringName};
 use godot::classes::object::ConnectFlags;
 use godot::classes::{Node, Node3D, Object, RefCounted};
-use godot::meta::ToGodot;
+use godot::meta::{FromGodot, GodotConvert, ToGodot};
 use godot::obj::{Base, Gd, InstanceId, NewAlloc, NewGd};
+use godot::prelude::ConvertError;
 use godot::register::{godot_api, GodotClass};
 use godot::sys;
 use godot::sys::Global;
@@ -472,6 +473,55 @@ fn signal_construction_and_id() {
     assert_eq!(signal.object(), None);
 }
 
+#[cfg(since_api = "4.2")]
+#[itest]
+fn enums_as_signal_args() {
+    #[derive(Debug, Clone)]
+    enum EventType {
+        Ready,
+    }
+
+    impl GodotConvert for EventType {
+        type Via = u8;
+    }
+
+    impl ToGodot for EventType {
+        type ToVia<'v> = Self::Via;
+
+        fn to_godot(&self) -> Self::ToVia<'_> {
+            match self {
+                EventType::Ready => 0,
+            }
+        }
+    }
+
+    impl FromGodot for EventType {
+        fn try_from_godot(via: Self::Via) -> Result<Self, godot::prelude::ConvertError> {
+            match via {
+                0 => Ok(Self::Ready),
+                _ => Err(ConvertError::new("value out of range")),
+            }
+        }
+    }
+
+    #[derive(GodotClass)]
+    #[class(base = RefCounted, init)]
+    struct SignalObject {
+        base: Base<RefCounted>,
+    }
+
+    #[godot_api]
+    impl SignalObject {
+        #[signal]
+        fn game_event(ty: EventType);
+    }
+
+    let object = SignalObject::new_gd();
+    let event = EventType::Ready;
+
+    object.signals().game_event().emit(&event);
+}
+
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Helper types