feat(core): support easier, type-safe deferred calls

Author: goatfryed

godot-core/src/obj/deferred.rs

@@ -0,0 +1,90 @@
+/*
+ * 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::builtin::{Callable, Variant};
+use crate::obj::{bounds, Bounds, Gd, GodotClass, WithBaseField};
+use godot_ffi::is_main_thread;
+use std::ops::DerefMut;
+
+pub trait DeferredCallableGd<T>
+where
+    T: GodotClass + Bounds<Declarer = bounds::DeclUser>,
+{
+    /// Runs the given Closure deferred.
+    ///
+    /// This can be a type-safe alternative to [`classes::Object::call_deferred`], but does not handle dynamic dispatch, unless explicitly used.
+    /// This must be used on the main thread.
+    fn apply_deferred<F>(&mut self, rust_function: F)
+    where
+        F: FnMut(&mut T) + 'static;
+}
+
+pub trait CallEngineClassDeferred<T>
+where
+    T: GodotClass + Bounds<Declarer = bounds::DeclEngine>,
+{
+    /// Runs the given Closure deferred.
+    ///
+    /// This can be a type-safe alternative to [`classes::Object::call_deferred`], but does not handle dynamic dispatch, unless explicitly used.
+    /// This must be used on the main thread.
+    fn apply_deferred<F>(&mut self, rust_function: F)
+    where
+        F: FnMut(Gd<T>) + 'static;
+}
+
+impl<T> DeferredCallableGd<T> for T
+where
+    T: GodotClass + Bounds<Declarer = bounds::DeclUser> + WithBaseField,
+{
+    fn apply_deferred<F>(&mut self, rust_function: F)
+    where
+        F: FnMut(&mut T) + 'static,
+    {
+        self.to_gd().apply_deferred(rust_function);
+    }
+}
+
+impl<T> DeferredCallableGd<T> for Gd<T>
+where
+    T: GodotClass + Bounds<Declarer = bounds::DeclUser>,
+{
+    fn apply_deferred<F>(&mut self, mut rust_function: F)
+    where
+        F: FnMut(&mut T) + 'static,
+    {
+        assert!(
+            is_main_thread(),
+            "apply_deferred must be called on main thread"
+        );
+        let this = self.clone();
+        let callable = Callable::from_local_fn("apply_deferred", move |_| {
+            rust_function(this.clone().bind_mut().deref_mut());
+            Ok(Variant::nil())
+        });
+        callable.call_deferred(&[]);
+    }
+}
+
+impl<T> CallEngineClassDeferred<T> for Gd<T>
+where
+    T: GodotClass + Bounds<Declarer = bounds::DeclEngine>,
+{
+    fn apply_deferred<F>(&mut self, mut rust_function: F)
+    where
+        F: FnMut(Gd<T>) + 'static,
+    {
+        assert!(
+            is_main_thread(),
+            "apply_deferred must be called on main thread"
+        );
+        let this = self.clone();
+        let callable = Callable::from_local_fn("apply_deferred", move |_| {
+            rust_function(this.clone());
+            Ok(Variant::nil())
+        });
+        callable.call_deferred(&[]);
+    }
+}

godot-core/src/obj/mod.rs

@@ -34,7 +34,10 @@ pub use raw_gd::*;
 pub use traits::*;
 
 pub mod bounds;
+#[cfg(since_api = "4.2")]
+pub mod deferred;
 pub mod script;
+
 pub use bounds::private::Bounds;
 
 // Do not re-export rtti here.

itest/rust/src/object_tests/deferred_call_test.rs

@@ -4,23 +4,28 @@
  * 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::framework::itest;
-use crate::object_tests::deferred_call_test::TestState::{Accepted, Initial};
+use crate::object_tests::deferred_call_test::TestState::{
+    Accepted, FailedEngineClass, Initial, VerifyEngineClass,
+};
+use godot::obj::deferred::{CallEngineClassDeferred, DeferredCallableGd};
 use godot::prelude::*;
 use godot::task::{SignalFuture, TaskHandle};
+use std::ops::DerefMut;
 
 #[derive(GodotConvert, Var, Export, Clone, PartialEq, Debug)]
 #[godot(via = GString)]
 enum TestState {
     Initial,
     Accepted,
+    VerifyEngineClass,
+    FailedEngineClass,
 }
 
 #[derive(GodotClass)]
-#[class(base=Node)]
+#[class(base=Node2D)]
 struct DeferredTestNode {
-    base: Base<Node>,
+    base: Base<Node2D>,
     state: TestState,
 }
 
@@ -35,10 +40,11 @@ impl DeferredTestNode {
     }
 
     fn as_expectation_task(&self) -> TaskHandle {
-        assert_eq!(Initial, self.state, "accept evaluated synchronously");
+        assert_ne!(Accepted, self.state, "accept evaluated synchronously");
 
         let test_will_succeed: SignalFuture<(Variant,)> =
             Signal::from_object_signal(&self.to_gd(), "test_completed").to_future();
+
         godot::task::spawn(async move {
             let (final_state,) = test_will_succeed.await;
             let final_state: TestState = final_state.to();
@@ -49,7 +55,7 @@ impl DeferredTestNode {
 }
 
 #[godot_api]
-impl INode for DeferredTestNode {
+impl INode2D for DeferredTestNode {
     fn init(base: Base<Self::Base>) -> Self {
         Self {
             base,
@@ -58,6 +64,14 @@ impl INode for DeferredTestNode {
     }
 
     fn process(&mut self, _delta: f64) {
+        if self.state == VerifyEngineClass {
+            if self.base().get_name() == "changed".into() {
+                self.state = Accepted;
+            } else {
+                self.state = FailedEngineClass;
+            }
+        }
+
         let args = vslice![self.state];
         self.base_mut().emit_signal("test_completed", args);
     }
@@ -67,9 +81,47 @@ impl INode for DeferredTestNode {
 fn calls_method_names_deferred(ctx: &crate::framework::TestContext) -> TaskHandle {
     let mut test_node = DeferredTestNode::new_alloc();
     ctx.scene_tree.clone().add_child(&test_node);
-    
+
     test_node.call_deferred("accept", &[]);
 
     let handle = test_node.bind().as_expectation_task();
     handle
 }
+
+#[itest(async)]
+fn calls_user_class_deferred_from_self(ctx: &crate::framework::TestContext) -> TaskHandle {
+    let mut test_node = DeferredTestNode::new_alloc();
+    ctx.scene_tree.clone().add_child(&test_node);
+
+    test_node
+        .bind_mut()
+        .deref_mut()
+        .apply_deferred(DeferredTestNode::accept);
+
+    let handle = test_node.bind().as_expectation_task();
+    handle
+}
+
+#[itest(async)]
+fn calls_user_class_deferred(ctx: &crate::framework::TestContext) -> TaskHandle {
+    let mut test_node = DeferredTestNode::new_alloc();
+    ctx.scene_tree.clone().add_child(&test_node);
+
+    test_node.apply_deferred(DeferredTestNode::accept);
+
+    let handle = test_node.bind().as_expectation_task();
+    handle
+}
+
+#[itest(async)]
+fn calls_engine_class_deferred(ctx: &crate::framework::TestContext) -> TaskHandle {
+    let mut test_node = DeferredTestNode::new_alloc();
+    ctx.scene_tree.clone().add_child(&test_node);
+
+    let mut node = test_node.clone().upcast::<Node>();
+    node.apply_deferred(|mut that_node| that_node.set_name("changed"));
+
+    test_node.bind_mut().state = VerifyEngineClass;
+    let handle = test_node.bind().as_expectation_task();
+    handle
+}