Eliminate ParamType entirely

Author: TitanNano

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

@@ -11,6 +11,7 @@ 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,
@@ -675,7 +676,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 = <T as ParamType>::owned_to_arg(ignored_value);
+        let ignored_value = AsArg::into_arg(&ignored_value);
 
         let godot_comparator = |args: &[&Variant]| {
             let value = T::from_variant(args[0]);
@@ -1118,20 +1119,13 @@ 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)
     }
-
-    fn arg_to_ref<'r>(arg: &'r Self::Arg<'_>) -> &'r Self {
-        arg.cow_as_ref()
-    }
-
-    fn arg_into_owned(arg: Self::Arg<'_>) -> Self {
-        arg.cow_into_owned()
-    }
 }
 
 impl<T: ArrayElement> GodotConvert for Array<T> {
@@ -1427,15 +1421,15 @@ impl<T: ArrayElement + ToGodot> FromIterator<T> for Array<T> {
 }
 
 /// Extends a `Array` with the contents of an iterator.
-impl<T: ArrayElement + ToGodot> Extend<T> for Array<T> {
+impl<T: ArrayElement> Extend<T> for Array<T> {
     fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
         // Unfortunately the GDExtension API does not offer the equivalent of `Vec::reserve`.
         // Otherwise, we could use it to pre-allocate based on `iter.size_hint()`.
         //
         // 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(ParamType::owned_to_arg(item));
+            self.push(AsArg::into_arg(&item));
         }
     }
 }

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

@@ -26,8 +26,6 @@ use std::ffi::CStr;
 /// Implicitly converting from `T` for by-ref builtins is explicitly not supported. This emphasizes that there is no need to consume the object,
 /// thus discourages unnecessary cloning.
 ///
-/// If you need to pass owned values in generic code, you can use [`ParamType::owned_to_arg()`].
-///
 /// # Performance for strings
 /// Godot has three string types: [`GString`], [`StringName`] and [`NodePath`]. Conversions between those three, as well as between `String` and
 /// them, is generally expensive because of allocations, re-encoding, validations, hashing, etc. While this doesn't matter for a few strings
@@ -130,41 +128,27 @@ 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
             }
-
-            fn arg_to_ref<'r>(arg: &'r Self::Arg<'_>) -> &'r Self {
-                arg
-            }
-
-            fn arg_into_owned(arg: Self::Arg<'_>) -> Self {
-                arg
-            }
         }
     };
 }
 
 #[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)
             }
-
-            fn arg_to_ref<'r>(arg: &'r Self::Arg<'_>) -> &'r Self {
-                arg.cow_as_ref()
-            }
-
-            fn arg_into_owned(arg: Self::Arg<'_>) -> Self {
-                arg.cow_into_owned()
-            }
         }
     };
 }
@@ -180,7 +164,7 @@ macro_rules! declare_arg_method {
         pub fn arg<T>(&self) -> impl $crate::meta::AsArg<T>
         where
             for<'a> T: From<&'a Self>
-                + $crate::meta::ParamType<Arg<'a> = $crate::meta::CowArg<'a, T>>
+                + $crate::meta::ToGodot
                 + 'a,
         {
             $crate::meta::CowArg::Owned(T::from(self))
@@ -271,6 +255,10 @@ 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
 // GodotType bound not required right now, but conceptually should always be the case.
 {
@@ -290,16 +278,4 @@ pub trait ParamType: sealed::Sealed + Sized + 'static + ToGodot
     ///
     /// 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>;
-
-    /// Converts an argument to a shared reference.
-    ///
-    /// Useful in generic contexts where you need to extract a reference of an argument, independently of how it is passed.
-    #[doc(hidden)] // for now, users are encouraged to use only call-site of impl AsArg; declaration-site may still develop.
-    fn arg_to_ref<'r>(arg: &'r Self::Arg<'_>) -> &'r Self;
-
-    /// Clones an argument into an owned value.
-    ///
-    /// Useful in generic contexts where you need to extract a value of an argument, independently of how it is passed.
-    #[doc(hidden)] // for now, users are encouraged to use only call-site of impl AsArg; declaration-site may still develop.
-    fn arg_into_owned(arg: Self::Arg<'_>) -> Self;
 }

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

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

godot-core/src/meta/traits.rs

@@ -8,15 +8,16 @@
 use crate::builtin::{Variant, VariantType};
 use crate::global::PropertyUsageFlags;
 use crate::meta::error::ConvertError;
+#[expect(deprecated)]
 use crate::meta::{
-    sealed, ClassName, FromGodot, GodotConvert, PropertyHintInfo, PropertyInfo, ToGodot,
+    sealed, ClassName, FromGodot, GodotConvert, ParamType, PropertyHintInfo, PropertyInfo, ToGodot,
 };
 use crate::registry::method::MethodParamOrReturnInfo;
 use godot_ffi as sys;
 
 // Re-export sys traits in this module, so all are in one place.
+use crate::builtin;
 use crate::registry::property::builtin_type_string;
-use crate::{builtin, meta};
 pub use sys::{GodotFfi, GodotNullableFfi};
 
 /// Conversion of [`GodotFfi`] types to/from [`Variant`].
@@ -163,11 +164,14 @@ pub trait GodotType: GodotConvert<Via = Self> + sealed::Sealed + Sized + 'static
 ///
 /// Also, keep in mind that Godot uses `Variant` for each element. If performance matters and you have small element types such as `u8`,
 /// consider using packed arrays (e.g. `PackedByteArray`) instead.
+//
+// TODO: The ParamType super trait is no longer needed and can be removed in 0.4. We are only keeping it for backwards compatebility.
 #[diagnostic::on_unimplemented(
     message = "`Array<T>` can only store element types supported in Godot arrays (no nesting).",
     label = "has invalid element type"
 )]
-pub trait ArrayElement: ToGodot + FromGodot + sealed::Sealed + meta::ParamType {
+#[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,6 +547,7 @@ where
 }
 */
 
+#[expect(deprecated)]
 impl<T, D> meta::ParamType for DynGd<T, D>
 where
     T: GodotClass,
@@ -557,14 +558,6 @@ where
     fn owned_to_arg<'v>(self) -> Self::Arg<'v> {
         meta::CowArg::Owned(self)
     }
-
-    fn arg_to_ref<'r>(arg: &'r Self::Arg<'_>) -> &'r Self {
-        arg.cow_as_ref()
-    }
-
-    fn arg_into_owned(arg: Self::Arg<'_>) -> Self {
-        arg.cow_into_owned()
-    }
 }
 
 impl<T, D> meta::ArrayElement for DynGd<T, D>

godot-core/src/obj/gd.rs

@@ -13,6 +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,
     ParamType, PropertyHintInfo, RefArg, ToGodot,
@@ -866,20 +868,13 @@ 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)
     }
-
-    fn arg_to_ref<'r>(arg: &'r Self::Arg<'_>) -> &'r Self {
-        arg.cow_as_ref()
-    }
-
-    fn arg_into_owned(arg: Self::Arg<'_>) -> Self {
-        arg.cow_into_owned()
-    }
 }
 
 impl<T: GodotClass> AsArg<Option<Gd<T>>> for Option<&Gd<T>> {
@@ -892,20 +887,13 @@ 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)
     }
-
-    fn arg_to_ref<'r>(arg: &'r Self::Arg<'_>) -> &'r Self {
-        arg.cow_as_ref()
-    }
-
-    fn arg_into_owned(arg: Self::Arg<'_>) -> Self {
-        arg.cow_into_owned()
-    }
 }
 
 impl<T> Default for Gd<T>