Move ToSignalObject -> meta::ObjectToOwned

Author: Bromeon

godot-core/src/meta/mod.rs

@@ -48,6 +48,7 @@ mod class_id;
 mod element_type;
 mod godot_convert;
 mod method_info;
+mod object_to_owned;
 mod param_tuple;
 mod property_info;
 mod signature;
@@ -67,6 +68,7 @@ pub use class_id::{ClassId, ClassName};
 pub use element_type::{ElementScript, ElementType};
 pub use godot_convert::{FromGodot, GodotConvert, ToGodot};
 pub use method_info::MethodInfo;
+pub use object_to_owned::ObjectToOwned;
 pub use param_tuple::{InParamTuple, OutParamTuple, ParamTuple};
 pub use property_info::{PropertyHintInfo, PropertyInfo};
 #[cfg(feature = "trace")]

godot-core/src/meta/object_to_owned.rs

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) godot-rust; Bromeon and contributors.
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+use crate::obj::{Gd, GodotClass, WithBaseField};
+
+/// Obtain owned `Gd` from either `&self` or `&Gd`.
+///
+/// This trait allows passing either `Gd<T>` or `C` (where `C: WithBaseField`) to functions that need an owned `Gd<T>`.
+///
+/// This is primarily used for signal connection methods in [`TypedSignal`][crate::registry::signal::TypedSignal] and
+/// [`ConnectBuilder`][crate::registry::signal::ConnectBuilder], where you can pass either a `&Gd` (outside) or `&SomeClass`
+/// (from within `impl` block) as the receiver object.
+///
+/// # Similar traits
+/// - [`UniformObjectDeref`][crate::meta::UniformObjectDeref] provides unified dereferencing of user and engine classes.
+/// - [`AsArg`][crate::meta::AsArg] enables general argument conversions for Godot APIs.
+pub trait ObjectToOwned<T: GodotClass> {
+    /// Converts the object reference to an owned `Gd<T>`.
+    fn object_to_owned(&self) -> Gd<T>;
+}
+
+impl<T: GodotClass> ObjectToOwned<T> for Gd<T> {
+    fn object_to_owned(&self) -> Gd<T> {
+        self.clone()
+    }
+}
+
+impl<C: WithBaseField> ObjectToOwned<C> for C {
+    fn object_to_owned(&self) -> Gd<C> {
+        WithBaseField::to_gd(self)
+    }
+}

godot-core/src/meta/uniform_object_deref.rs

@@ -60,6 +60,9 @@ use crate::obj::{Gd, GdMut, GdRef, GodotClass, WithBaseField};
 ///     abstract_over_objects(&user_obj);
 /// }
 /// ```
+///
+/// # Similar traits
+/// - [`ObjectToOwned`][crate::meta::ObjectToOwned] provides conversion from `&self` or `&Gd<T>` to owned `Gd<T>`.
 //
 // The crate `https://crates.io/crates/disjoint_impls` handles this in a more user-friendly way, we should
 // consider using it if disjoint impls are going to be frequently used.

godot-core/src/registry/signal/connect_builder.rs

@@ -11,10 +11,10 @@ use crate::builtin::Callable;
 use crate::builtin::{GString, Variant};
 use crate::classes::object::ConnectFlags;
 use crate::meta;
-use crate::meta::InParamTuple;
+use crate::meta::{InParamTuple, ObjectToOwned};
 use crate::obj::{bounds, Bounds, Gd, GodotClass, WithSignals};
 use crate::registry::signal::signal_receiver::{IndirectSignalReceiver, SignalReceiver};
-use crate::registry::signal::{ConnectHandle, ToSignalObj, TypedSignal};
+use crate::registry::signal::{ConnectHandle, TypedSignal};
 
 /// Builder for customizing signal connections.
 ///
@@ -239,15 +239,15 @@ impl<C: WithSignals, Ps: InParamTuple + 'static> ConnectBuilder<'_, '_, C, Ps> {
     /// - If you need cross-thread signals, use [`connect_sync()`](#method.connect_sync) instead (requires feature "experimental-threads").
     pub fn connect_other_mut<F, OtherC>(
         self,
-        object: &impl ToSignalObj<OtherC>,
+        object: &impl ObjectToOwned<OtherC>,
         mut method: F,
     ) -> ConnectHandle
     where
         OtherC: GodotClass + Bounds<Declarer = bounds::DeclUser>,
         for<'c_rcv> F: SignalReceiver<&'c_rcv mut OtherC, Ps>,
         for<'c_rcv> IndirectSignalReceiver<'c_rcv, &'c_rcv mut OtherC, Ps, F>: From<&'c_rcv mut F>,
     {
-        let mut gd = object.to_signal_obj();
+        let mut gd = object.object_to_owned();
 
         let godot_fn = make_godot_fn(move |args| {
             let mut guard = Gd::bind_mut(&mut gd);
@@ -256,7 +256,7 @@ impl<C: WithSignals, Ps: InParamTuple + 'static> ConnectBuilder<'_, '_, C, Ps> {
                 .call(&mut *guard, args);
         });
 
-        self.inner_connect_godot_fn::<F>(godot_fn, &object.to_signal_obj())
+        self.inner_connect_godot_fn::<F>(godot_fn, &object.object_to_owned())
     }
 
     /// Connect a method with any `&mut Gd<OtherC>` as the first parameter (user + engine classes).
@@ -272,23 +272,23 @@ impl<C: WithSignals, Ps: InParamTuple + 'static> ConnectBuilder<'_, '_, C, Ps> {
     /// - If you need cross-thread signals, use [`connect_sync()`](#method.connect_sync) instead (requires feature "experimental-threads").
     pub fn connect_other_gd<F, OtherC>(
         self,
-        object: &impl ToSignalObj<OtherC>,
+        object: &impl ObjectToOwned<OtherC>,
         mut method: F,
     ) -> ConnectHandle
     where
         OtherC: GodotClass,
         F: SignalReceiver<Gd<OtherC>, Ps>,
         for<'c_rcv> IndirectSignalReceiver<'c_rcv, Gd<OtherC>, Ps, F>: From<&'c_rcv mut F>,
     {
-        let gd = object.to_signal_obj();
+        let gd = object.object_to_owned();
 
         let godot_fn = make_godot_fn(move |args| {
             IndirectSignalReceiver::from(&mut method)
                 .function()
                 .call(gd.clone(), args);
         });
 
-        self.inner_connect_godot_fn::<F>(godot_fn, &object.to_signal_obj())
+        self.inner_connect_godot_fn::<F>(godot_fn, &object.object_to_owned())
     }
 
     /// Connect to this signal using a thread-safe function, allows the signal to be called across threads.

godot-core/src/registry/signal/typed_signal.rs

@@ -13,31 +13,10 @@ use super::{make_callable_name, make_godot_fn, ConnectBuilder, ConnectHandle, Si
 use crate::builtin::{Callable, Variant};
 use crate::classes::object::ConnectFlags;
 use crate::meta;
-use crate::meta::{InParamTuple, UniformObjectDeref};
-use crate::obj::{Gd, GodotClass, WithBaseField, WithSignals};
+use crate::meta::{InParamTuple, ObjectToOwned, UniformObjectDeref};
+use crate::obj::{Gd, GodotClass, WithSignals};
 use crate::registry::signal::signal_receiver::{IndirectSignalReceiver, SignalReceiver};
 
-// TODO(v0.4): find more general name for trait.
-/// Object part of the signal receiver (handler).
-///
-/// Functionality overlaps partly with [`meta::AsObjectArg`] and [`meta::AsArg<ObjectArg>`]. Can however not directly be replaced
-/// with `AsObjectArg`, since that allows nullability and doesn't require `&mut T`. Maybe there's a way to reuse them though.
-pub trait ToSignalObj<C: GodotClass> {
-    fn to_signal_obj(&self) -> Gd<C>;
-}
-
-impl<C: GodotClass> ToSignalObj<C> for Gd<C> {
-    fn to_signal_obj(&self) -> Gd<C> {
-        self.clone()
-    }
-}
-
-impl<C: WithBaseField> ToSignalObj<C> for C {
-    fn to_signal_obj(&self) -> Gd<C> {
-        WithBaseField::to_gd(self)
-    }
-}
-
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 
 /// Type-safe version of a Godot signal.
@@ -234,23 +213,23 @@ impl<C: WithSignals, Ps: InParamTuple + 'static> TypedSignal<'_, C, Ps> {
     /// The parameter `object` can be of 2 different "categories":
     /// - Any `&Gd<OtherC>` (e.g.: `&Gd<Node>`, `&Gd<CustomUserClass>`).
     /// - `&OtherC`, as long as `OtherC` is a user class that contains a `base` field (it implements the
-    ///   [`WithBaseField`](WithBaseField) trait).
+    ///   [`WithBaseField`][crate::obj::WithBaseField] trait).
     ///
     /// ---
     ///
     /// - To connect to methods on the object that owns this signal, use [`connect_self()`][Self::connect_self].
     /// - If you need [`connect flags`](ConnectFlags) or cross-thread signals, use [`builder()`][Self::builder].
     pub fn connect_other<F, OtherC, Declarer>(
         &self,
-        object: &impl ToSignalObj<OtherC>,
+        object: &impl ObjectToOwned<OtherC>,
         mut method: F,
     ) -> ConnectHandle
     where
         OtherC: UniformObjectDeref<Declarer>,
         for<'c_rcv> F: SignalReceiver<&'c_rcv mut OtherC, Ps> + 'static,
         for<'c_rcv> IndirectSignalReceiver<'c_rcv, &'c_rcv mut OtherC, Ps, F>: From<&'c_rcv mut F>,
     {
-        let mut gd = object.to_signal_obj();
+        let mut gd = object.object_to_owned();
 
         let godot_fn = make_godot_fn(move |args| {
             let mut target = OtherC::object_as_mut(&mut gd);
@@ -260,6 +239,6 @@ impl<C: WithSignals, Ps: InParamTuple + 'static> TypedSignal<'_, C, Ps> {
                 .call(target_mut, args);
         });
 
-        self.inner_connect_godot_fn::<F>(godot_fn, &object.to_signal_obj())
+        self.inner_connect_godot_fn::<F>(godot_fn, &object.object_to_owned())
     }
 }