Repurpose ParamType for by-value/by-ref distinction

Author: Bromeon

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

@@ -11,10 +11,9 @@ use std::{cmp, fmt};
 use crate::builtin::*;
 use crate::meta;
 use crate::meta::error::{ConvertError, FromGodotError, FromVariantError};
-#[expect(deprecated)]
 use crate::meta::{
-    element_godot_type_name, element_variant_type, ArrayElement, ArrayTypeInfo, AsArg, ClassName,
-    CowArg, FromGodot, GodotConvert, GodotFfiVariant, GodotType, ParamType, PropertyHintInfo,
+    element_godot_type_name, element_variant_type, ArrayElement, ArrayTypeInfo, AsArg, ByRef,
+    ClassName, FromGodot, GodotConvert, GodotFfiVariant, GodotType, ParamType, PropertyHintInfo,
     RefArg, ToGodot,
 };
 use crate::obj::{bounds, Bounds, DynGd, Gd, GodotClass};
@@ -676,7 +675,7 @@ impl<T: ArrayElement> Array<T> {
         // We need one dummy element of type T, because Godot's bsearch_custom() checks types (so Variant::nil() can't be passed).
         // Optimization: roundtrip Variant -> T -> Variant could be avoided, but anyone needing speed would use Rust binary search...
         let ignored_value = self.at(0);
-        let ignored_value = AsArg::into_arg(&ignored_value);
+        let ignored_value = meta::val_into_arg(ignored_value); //AsArg::into_arg(&ignored_value);
 
         let godot_comparator = |args: &[&Variant]| {
             let value = T::from_variant(args[0]);
@@ -1119,13 +1118,8 @@ unsafe impl<T: ArrayElement> GodotFfi for Array<T> {
 // Only implement for untyped arrays; typed arrays cannot be nested in Godot.
 impl ArrayElement for VariantArray {}
 
-#[expect(deprecated)]
 impl<T: ArrayElement> ParamType for Array<T> {
-    type Arg<'v> = CowArg<'v, Self>;
-
-    fn owned_to_arg<'v>(self) -> Self::Arg<'v> {
-        CowArg::Owned(self)
-    }
+    type ArgPassing = ByRef;
 }
 
 impl<T: ArrayElement> GodotConvert for Array<T> {
@@ -1429,7 +1423,8 @@ impl<T: ArrayElement> Extend<T> for Array<T> {
         // A faster implementation using `resize()` and direct pointer writes might still be possible.
         // Note that this could technically also use iter(), since no moves need to happen (however Extend requires IntoIterator).
         for item in iter.into_iter() {
-            self.push(AsArg::into_arg(&item));
+            // self.push(AsArg::into_arg(&item));
+            self.push(meta::val_into_arg(item));
         }
     }
 }

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

@@ -6,7 +6,8 @@
  */
 
 use crate::builtin::{GString, NodePath, StringName};
-use crate::meta::{sealed, CowArg, ToGodot};
+use crate::meta::sealed::Sealed;
+use crate::meta::{CowArg, ToGodot};
 use std::ffi::CStr;
 
 /// Implicit conversions for arguments passed to Godot APIs.
@@ -64,7 +65,19 @@ where
         Self: 'r;
 }
 
-impl<T: ToGodot> AsArg<T> for &T {
+/// Generic abstraction over `T` and `&T` that should be passed as `AsArg<T>`.
+#[doc(hidden)]
+pub fn val_into_arg<'r, T>(arg: T) -> impl AsArg<T> + 'r
+where
+    T: ToGodot + 'r,
+{
+    CowArg::Owned(arg)
+}
+
+impl<T> AsArg<T> for &T
+where
+    T: ToGodot + ParamType<ArgPassing = ByRef>,
+{
     fn into_arg<'r>(self) -> CowArg<'r, T>
     where
         Self: 'r,
@@ -73,7 +86,10 @@ impl<T: ToGodot> AsArg<T> for &T {
     }
 }
 
-impl<T: ToGodot + Copy> AsArg<T> for T {
+impl<T> AsArg<T> for T
+where
+    T: ToGodot + ParamType<ArgPassing = ByValue>,
+{
     fn into_arg<'r>(self) -> CowArg<'r, T>
     where
         Self: 'r,
@@ -128,27 +144,17 @@ macro_rules! arg_into_owned {
 #[macro_export]
 macro_rules! impl_asarg_by_value {
     ($T:ty) => {
-        #[expect(deprecated)]
         impl $crate::meta::ParamType for $T {
-            type Arg<'v> = $T;
-
-            fn owned_to_arg<'v>(self) -> Self::Arg<'v> {
-                self
-            }
+            type ArgPassing = $crate::meta::ByValue;
         }
     };
 }
 
 #[macro_export]
 macro_rules! impl_asarg_by_ref {
     ($T:ty) => {
-        #[expect(deprecated)]
         impl $crate::meta::ParamType for $T {
-            type Arg<'v> = $crate::meta::CowArg<'v, $T>;
-
-            fn owned_to_arg<'v>(self) -> Self::Arg<'v> {
-                $crate::meta::CowArg::Owned(self)
-            }
+            type ArgPassing = $crate::meta::ByRef;
         }
     };
 }
@@ -255,27 +261,31 @@ 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.
-#[deprecated(
-    since = "0.3.2",
-    note = "This trait is no longer needed and will be removed in 0.4"
-)]
-pub trait ParamType: sealed::Sealed + Sized + 'static + ToGodot
+//
+// TODO(v0.4): merge ParamType::ArgPassing into ToGodot::ToVia, reducing redundancy on user side.
+pub trait ParamType: ToGodot + Sized + 'static
 // 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.
-    ///
-    /// The general rule is that `Copy` types are passed by value, while the rest is passed by reference.
-    ///
-    /// This associated type is closely related to [`ToGodot::ToVia<'v>`][crate::meta::ToGodot::ToVia] and may be reorganized in the future.
-    #[doc(hidden)]
-    type Arg<'v>: AsArg<Self>
-    where
-        Self: 'v;
-
-    /// Converts an owned value to the canonical argument type, which can be passed to [`impl AsArg<T>`][AsArg].
-    ///
-    /// Useful in generic contexts where only a value is available, and one doesn't want to dispatch between value/reference.
-    ///
-    /// You should not rely on the exact return type, as it may change in future versions; treat it like `impl AsArg<Self>`.
-    fn owned_to_arg<'v>(self) -> Self::Arg<'v>;
+    type ArgPassing: ArgPassing;
+
+    #[deprecated(
+        since = "0.3.2",
+        note = "This method is no longer needed and will be removed in 0.4"
+    )]
+    fn owned_to_arg(self) -> impl AsArg<Self> {
+        val_into_arg(self)
+    }
 }
+
+// ----------------------------------------------------------------------------------------------------------------------------------------------
+// Argument passing (mutually exclusive by-val or by-ref).
+
+pub trait ArgPassing: Sealed {}
+
+pub enum ByValue {}
+impl ArgPassing for ByValue {}
+impl Sealed for ByValue {}
+
+pub enum ByRef {}
+impl ArgPassing for ByRef {}
+impl Sealed for ByRef {}

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

@@ -13,8 +13,7 @@ mod ref_arg;
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Public APIs
 
-#[expect(deprecated)]
-pub use as_arg::{AsArg, ParamType};
+pub use as_arg::{val_into_arg, ArgPassing, AsArg, ByRef, ByValue, ParamType};
 pub use object_arg::AsObjectArg;
 pub use ref_arg::RefArg;
 

godot-core/src/meta/godot_convert/mod.rs

@@ -60,6 +60,17 @@ pub trait ToGodot: Sized + GodotConvert {
     where
         Self: 'v;
 
+    /*
+    // TODO(v0.4): add this type, to replace ParamType::ArgPassing and possibly Self::ToVia<'v>.
+    /// Whether this type is passed by value or by reference in `AsArg` contexts.
+    ///
+    /// Can be either [`ArgPassing::ByValue`] or [`ArgPassing::ByRef`]. For types implementing `Copy`, by-value is strongly recommended.
+    ///
+    /// Will auto-implement `AsArg<T>` for either `T` (by-value) or for `&T` (by-reference). This has an influence on contexts such as
+    /// [`Array::push()`](crate::builtin::Array::push) or generated signal `emit()` signatures.
+    type ArgPassing: ArgPassing;
+     */
+
     /// Converts this type to the Godot type by reference, usually by cloning.
     fn to_godot(&self) -> Self::ToVia<'_>;
 

godot-core/src/meta/traits.rs

@@ -8,7 +8,6 @@
 use crate::builtin::{Variant, VariantType};
 use crate::global::PropertyUsageFlags;
 use crate::meta::error::ConvertError;
-#[expect(deprecated)]
 use crate::meta::{
     sealed, ClassName, FromGodot, GodotConvert, ParamType, PropertyHintInfo, PropertyInfo, ToGodot,
 };
@@ -170,7 +169,6 @@ pub trait GodotType: GodotConvert<Via = Self> + sealed::Sealed + Sized + 'static
     message = "`Array<T>` can only store element types supported in Godot arrays (no nesting).",
     label = "has invalid element type"
 )]
-#[expect(deprecated)]
 pub trait ArrayElement: ToGodot + FromGodot + sealed::Sealed + ParamType + 'static {
     // Note: several indirections in ArrayElement and the global `element_*` functions go through `GodotConvert::Via`,
     // to not require Self: GodotType. What matters is how array elements map to Godot on the FFI level (GodotType trait).

godot-core/src/obj/dyn_gd.rs

@@ -547,17 +547,12 @@ where
 }
 */
 
-#[expect(deprecated)]
 impl<T, D> meta::ParamType for DynGd<T, D>
 where
     T: GodotClass,
     D: ?Sized + 'static,
 {
-    type Arg<'v> = meta::CowArg<'v, DynGd<T, D>>;
-
-    fn owned_to_arg<'v>(self) -> Self::Arg<'v> {
-        meta::CowArg::Owned(self)
-    }
+    type ArgPassing = meta::ByRef;
 }
 
 impl<T, D> meta::ArrayElement for DynGd<T, D>

godot-core/src/obj/gd.rs

@@ -13,10 +13,8 @@ use sys::{static_assert_eq_size_align, SysPtr as _};
 
 use crate::builtin::{Callable, NodePath, StringName, Variant};
 use crate::meta::error::{ConvertError, FromFfiError};
-
-#[expect(deprecated)]
 use crate::meta::{
-    ArrayElement, AsArg, CallContext, ClassName, CowArg, FromGodot, GodotConvert, GodotType,
+    ArrayElement, AsArg, ByRef, CallContext, ClassName, CowArg, FromGodot, GodotConvert, GodotType,
     ParamType, PropertyHintInfo, RefArg, ToGodot,
 };
 use crate::obj::{
@@ -868,13 +866,8 @@ where
 }
 */
 
-#[expect(deprecated)]
 impl<T: GodotClass> ParamType for Gd<T> {
-    type Arg<'v> = CowArg<'v, Gd<T>>;
-
-    fn owned_to_arg<'v>(self) -> Self::Arg<'v> {
-        CowArg::Owned(self)
-    }
+    type ArgPassing = ByRef;
 }
 
 impl<T: GodotClass> AsArg<Option<Gd<T>>> for Option<&Gd<T>> {
@@ -887,13 +880,8 @@ impl<T: GodotClass> AsArg<Option<Gd<T>>> for Option<&Gd<T>> {
     }
 }
 
-#[expect(deprecated)]
 impl<T: GodotClass> ParamType for Option<Gd<T>> {
-    type Arg<'v> = CowArg<'v, Option<Gd<T>>>;
-
-    fn owned_to_arg<'v>(self) -> Self::Arg<'v> {
-        CowArg::Owned(self)
-    }
+    type ArgPassing = ByRef;
 }
 
 impl<T> Default for Gd<T>

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

@@ -9,12 +9,12 @@ 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::{FromGodot, GodotConvert, ToGodot};
+use godot::meta::{FromGodot, GodotConvert, ParamType, 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;
+use godot::{meta, sys};
 use std::cell::{Cell, RefCell};
 use std::rc::Rc;
 
@@ -495,8 +495,12 @@ fn enums_as_signal_args() {
         }
     }
 
+    impl ParamType for EventType {
+        type ArgPassing = meta::ByValue;
+    }
+
     impl FromGodot for EventType {
-        fn try_from_godot(via: Self::Via) -> Result<Self, godot::prelude::ConvertError> {
+        fn try_from_godot(via: Self::Via) -> Result<Self, ConvertError> {
             match via {
                 0 => Ok(Self::Ready),
                 _ => Err(ConvertError::new("value out of range")),
@@ -519,7 +523,7 @@ fn enums_as_signal_args() {
     let object = SignalObject::new_gd();
     let event = EventType::Ready;
 
-    object.signals().game_event().emit(&event);
+    object.signals().game_event().emit(event);
 }
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------