Implement Variant::call()

Author: Bromeon

godot-codegen/src/class_generator.rs

@@ -851,7 +851,7 @@ fn make_return(
                 let variant = Variant::#from_sys_init_method(|return_ptr| {
                     let mut __err = sys::default_call_error();
                     #varcall_invocation
-                    assert_eq!(__err.error, sys::GDEXTENSION_CALL_OK);
+                    sys::panic_on_call_error(&__err);
                 });
                 #return_expr
             }
@@ -863,7 +863,7 @@ fn make_return(
                 let mut __err = sys::default_call_error();
                 let return_ptr = std::ptr::null_mut();
                 #varcall_invocation
-                assert_eq!(__err.error, sys::GDEXTENSION_CALL_OK);
+                sys::panic_on_call_error(&__err);
             }
         }
         (None, Some(RustTy::EngineClass { tokens, .. })) => {

godot-core/src/builtin/variant/mod.rs

@@ -4,7 +4,7 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-use crate::builtin::GodotString;
+use crate::builtin::{GodotString, StringName};
 use godot_ffi as sys;
 use godot_ffi::GodotFfi;
 use std::{fmt, ptr};
@@ -91,12 +91,46 @@ impl Variant {
         }
     }
 
-    // TODO test
-    #[allow(unused_mut)]
+    /// ⚠️ Calls the specified `method` with the given `args`.
+    ///
+    /// Supports `Object` as well as built-ins with methods (e.g. `Array`, `Vector3`, `GodotString`, etc).
+    ///
+    /// # Panics
+    /// * If `self` is not a variant type which supports method calls.
+    /// * If the method does not exist or the signature is not compatible with the passed arguments.
+    /// * If the call causes an error.
+    #[inline]
+    pub fn call(&self, method: impl Into<StringName>, args: &[Variant]) -> Variant {
+        self.call_inner(method.into(), args)
+    }
+
+    fn call_inner(&self, method: StringName, args: &[Variant]) -> Variant {
+        let args_sys: Vec<_> = args.iter().map(|v| v.var_sys_const()).collect();
+        let mut error = sys::default_call_error();
+
+        #[allow(unused_mut)]
+        let mut result = Variant::nil();
+
+        unsafe {
+            interface_fn!(variant_call)(
+                self.var_sys(),
+                method.string_sys(),
+                args_sys.as_ptr(),
+                args_sys.len() as i64,
+                result.var_sys(),
+                ptr::addr_of_mut!(error),
+            )
+        };
+
+        sys::panic_on_call_error(&error);
+        result
+    }
+
     pub fn evaluate(&self, rhs: &Variant, op: VariantOperator) -> Option<Variant> {
         let op_sys = op.sys();
         let mut is_valid = false as u8;
 
+        #[allow(unused_mut)]
         let mut result = Variant::nil();
         unsafe {
             interface_fn!(variant_evaluate)(

godot-ffi/src/lib.rs

@@ -140,6 +140,7 @@ unsafe fn unwrap_ref_unchecked_mut<T>(opt: &mut Option<T>) -> &mut T {
 }
 
 #[doc(hidden)]
+#[inline]
 pub fn default_call_error() -> GDExtensionCallError {
     GDExtensionCallError {
         error: GDEXTENSION_CALL_OK,
@@ -148,6 +149,32 @@ pub fn default_call_error() -> GDExtensionCallError {
     }
 }
 
+#[doc(hidden)]
+#[inline]
+pub fn panic_on_call_error(err: &GDExtensionCallError) {
+    let actual = err.error;
+
+    assert_eq!(
+        actual,
+        GDEXTENSION_CALL_OK,
+        "encountered Godot error code {}",
+        call_error_to_string(actual)
+    );
+}
+
+fn call_error_to_string(err: GDExtensionCallErrorType) -> &'static str {
+    match err {
+        GDEXTENSION_CALL_OK => "OK",
+        GDEXTENSION_CALL_ERROR_INVALID_METHOD => "ERROR_INVALID_METHOD",
+        GDEXTENSION_CALL_ERROR_INVALID_ARGUMENT => "ERROR_INVALID_ARGUMENT",
+        GDEXTENSION_CALL_ERROR_TOO_MANY_ARGUMENTS => "ERROR_TOO_MANY_ARGUMENTS",
+        GDEXTENSION_CALL_ERROR_TOO_FEW_ARGUMENTS => "ERROR_TOO_FEW_ARGUMENTS",
+        GDEXTENSION_CALL_ERROR_INSTANCE_IS_NULL => "ERROR_INSTANCE_IS_NULL",
+        GDEXTENSION_CALL_ERROR_METHOD_NOT_CONST => "ERROR_METHOD_NOT_CONST",
+        _ => "(unknown)",
+    }
+}
+
 #[macro_export]
 #[doc(hidden)]
 macro_rules! builtin_fn {

itest/rust/src/variant_test.rs

@@ -4,11 +4,11 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-use crate::itest;
+use crate::{expect_panic, itest};
 use godot::builtin::{
     FromVariant, GodotString, NodePath, StringName, ToVariant, Variant, Vector2, Vector3,
 };
-use godot::engine::Node3D;
+use godot::engine::Node2D;
 use godot::obj::InstanceId;
 use godot::prelude::{Array, Dictionary, VariantConversionError};
 use godot::sys::{GodotFfi, VariantOperator, VariantType};
@@ -96,6 +96,53 @@ fn variant_equal() {
     equal(gstr("String"), 33, false);
 }
 
+#[itest]
+fn variant_call() {
+    use godot::obj::Share;
+    let node2d = Node2D::new_alloc();
+    let variant = Variant::from(node2d.share());
+
+    // Object
+    let position = Vector2::new(4.0, 5.0);
+    let result = variant.call("set_position", &[position.to_variant()]);
+    assert!(result.is_nil());
+
+    let result = variant.call("get_position", &[]);
+    assert_eq!(result.try_to::<Vector2>(), Ok(position));
+
+    let result = variant.call("to_string", &[]);
+    assert_eq!(result.get_type(), VariantType::String);
+
+    // Array
+    let array = godot::builtin::varray![1, "hello", false];
+    let result = array.to_variant().call("size", &[]);
+    assert_eq!(result, 3.to_variant());
+
+    // String
+    let string = GodotString::from("move_local_x");
+    let result = string.to_variant().call("capitalize", &[]);
+    assert_eq!(result, "Move Local X".to_variant());
+
+    // Vector2
+    let vector = Vector2::new(5.0, 3.0);
+    let vector_rhs = Vector2::new(1.0, -1.0);
+    let result = vector.to_variant().call("dot", &[vector_rhs.to_variant()]);
+    assert_eq!(result, 2.0.to_variant());
+
+    // Error cases
+    expect_panic("Variant::call on non-existent method", || {
+        variant.call("gut_position", &[]);
+    });
+    expect_panic("Variant::call with bad signature", || {
+        variant.call("set_position", &[]);
+    });
+    expect_panic("Variant::call with non-object variant (int)", || {
+        Variant::from(77).call("to_string", &[]);
+    });
+
+    node2d.free();
+}
+
 #[rustfmt::skip]
 #[itest]
 fn variant_evaluate() {
@@ -190,7 +237,7 @@ fn variant_sys_conversion() {
 fn variant_null_object_is_nil() {
     use godot::sys;
 
-    let mut node = Node3D::new_alloc();
+    let mut node = Node2D::new_alloc();
     let node_path = NodePath::from("res://NonExisting.tscn");
 
     // Simulates an object that is returned but null