Remove WithDeferredCall trait, move to WithBaseField

Author: Bromeon

godot-core/src/obj/call_deferred.rs

@@ -669,13 +669,14 @@ impl<T: GodotClass> Gd<T> {
 
     /// Defers the given closure to run during [idle time](https://docs.godotengine.org/en/stable/classes/class_object.html#class-object-method-call-deferred).
     ///
-    /// This is a type-safe alternative to [`Object::call_deferred()`][crate::classes::Object::call_deferred].
+    /// This is a type-safe alternative to [`Object::call_deferred()`][crate::classes::Object::call_deferred]. The closure receives
+    /// `&mut Self` allowing direct access to Rust fields and methods.
     ///
-    /// The closure receives `&mut T` allowing direct access to Rust fields and methods.
     /// This method is only available for user-defined classes with a `Base<T>` field.
-    ///
     /// For engine classes, use [`run_deferred_gd()`][Self::run_deferred_gd] instead.
     ///
+    /// See also [`WithBaseField::run_deferred()`] if you are within an `impl` block and have access to `self`.
+    ///
     /// # Panics
     /// If called outside the main thread.
     pub fn run_deferred<F>(&mut self, mut_self_method: F)
@@ -691,10 +692,10 @@ impl<T: GodotClass> Gd<T> {
 
     /// Defers the given closure to run during [idle time](https://docs.godotengine.org/en/stable/classes/class_object.html#class-object-method-call-deferred).
     ///
-    /// This is a type-safe alternative to [`Object::call_deferred()`][crate::classes::Object::call_deferred].
+    /// This is a type-safe alternative to [`Object::call_deferred()`][crate::classes::Object::call_deferred]. The closure receives
+    /// `Gd<T>`, which can be used to call engine methods or [`bind()`][Gd::bind]/[`bind_mut()`][Gd::bind_mut] to access the Rust object.
     ///
-    /// The closure receives a `Gd<T>` which can be used to call engine methods.
-    /// This method works for any Godot class (engine or user-defined).
+    /// See also [`WithBaseField::run_deferred_gd()`] if you are within an `impl` block and have access to `self`.
     ///
     /// # Panics
     /// If called outside the main thread.

godot-core/src/obj/gd.rs

@@ -12,7 +12,6 @@
 //! * [`Gd`], a smart pointer that manages instances of Godot classes.
 
 mod base;
-mod call_deferred;
 mod casts;
 mod dyn_gd;
 mod gd;
@@ -27,7 +26,6 @@ mod traits;
 pub(crate) mod rtti;
 
 pub use base::*;
-pub use call_deferred::WithDeferredCall;
 pub use dyn_gd::DynGd;
 pub use gd::*;
 pub use guards::{BaseMut, BaseRef, DynGdMut, DynGdRef, GdMut, GdRef};

godot-core/src/obj/mod.rs

@@ -540,6 +540,40 @@ pub trait WithBaseField: GodotClass + Bounds<Declarer = bounds::DeclUser> {
         // Narrows lifetime again from 'static to 'self.
         BaseMut::new(passive_gd, guard)
     }
+
+    /// Defers the given closure to run during [idle time](https://docs.godotengine.org/en/stable/classes/class_object.html#class-object-method-call-deferred).
+    ///
+    /// This is a type-safe alternative to [`Object::call_deferred()`][crate::classes::Object::call_deferred]. The closure receives
+    /// `&mut Self` allowing direct access to Rust fields and methods.
+    ///
+    /// See also [`Gd::run_deferred()`] to defer logic outside of `self`.
+    ///
+    /// # Panics
+    /// If called outside the main thread.
+    fn run_deferred<F>(&mut self, mut_self_method: F)
+    where
+        F: FnOnce(&mut Self) + 'static,
+    {
+        // We need to copy the Gd, because the lifetime of `&mut self` does not extend throughout the closure, which will only be called
+        // deferred. It might even be freed in-between, causing panic on bind_mut().
+        self.to_gd().run_deferred(mut_self_method)
+    }
+
+    /// Defers the given closure to run during [idle time](https://docs.godotengine.org/en/stable/classes/class_object.html#class-object-method-call-deferred).
+    ///
+    /// This is a type-safe alternative to [`Object::call_deferred()`][crate::classes::Object::call_deferred]. The closure receives
+    /// `Gd<Self>`, which can be used to call engine methods or [`bind()`][Gd::bind]/[`bind_mut()`][Gd::bind_mut] to access the Rust object.
+    ///
+    /// See also [`Gd::run_deferred_gd()`] to defer logic outside of `self`.
+    ///
+    /// # Panics
+    /// If called outside the main thread.
+    fn run_deferred_gd<F>(&mut self, gd_function: F)
+    where
+        F: FnOnce(Gd<Self>) + 'static,
+    {
+        self.to_gd().run_deferred_gd(gd_function)
+    }
 }
 
 /// Implemented for all classes with registered signals, both engine- and user-declared.

godot-core/src/obj/traits.rs

@@ -33,8 +33,7 @@ mod trait_reexports {
     pub use crate::obj::EngineEnum as _;
     pub use crate::obj::NewAlloc as _;
     pub use crate::obj::NewGd as _;
-    pub use crate::obj::WithBaseField as _; // base(), base_mut(), to_gd()
-    pub use crate::obj::WithDeferredCall as _; // apply_deferred()
+    pub use crate::obj::WithBaseField as _; // base(), base_mut(), to_gd(), run_deferred(), run_deferred_gd()
     pub use crate::obj::WithSignals as _; // Gd::signals()
     pub use crate::obj::WithUserSignals as _; // self.signals()
 }