Merge pull request #1191 from godot-rust/feature/vslice

`vslice![a, b]` for variant slices

Author: Bromeon

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

@@ -1579,6 +1579,8 @@ macro_rules! array {
 /// To create a typed `Array` with a single element type, see the [`array!`] macro.
 ///
 /// For dictionaries, a similar macro [`dict!`] exists.
+///
+/// To construct slices of variants, use [`vslice!`].
 #[macro_export]
 macro_rules! varray {
     // Note: use to_variant() and not Variant::from(), as that works with both references and values
@@ -1594,6 +1596,49 @@ macro_rules! varray {
     };
 }
 
+/// Constructs a slice of [`Variant`] literals, useful for passing to vararg functions.
+///
+/// Many APIs in Godot have variable-length arguments. GDScript can call such functions by simply passing more arguments, but in Rust,
+/// the parameter type `&[Variant]` is used.
+///
+/// This macro creates a [slice](https://doc.rust-lang.org/std/primitive.slice.html) of `Variant` values.
+///
+/// # Examples
+/// Variable number of arguments:
+/// ```no_run
+/// # use godot::prelude::*;
+/// let slice: &[Variant] = vslice![42, "hello", true];
+///
+/// let concat: GString = godot::global::str(slice);
+/// ```
+/// _(In practice, you might want to use [`godot_str!`][crate::global::godot_str] instead of `str()`.)_
+///
+/// Dynamic function call via reflection. NIL can still be passed inside `vslice!`, just use `Variant::nil()`.
+/// ```no_run
+/// # use godot::prelude::*;
+/// # fn some_object() -> Gd<Object> { unimplemented!() }
+/// let mut obj: Gd<Object> = some_object();
+/// obj.call("some_method", vslice![Vector2i::new(1, 2), Variant::nil()]);
+/// ```
+///
+/// # See also
+/// To create typed and untyped `Array`s, use the [`array!`] and [`varray!`] macros respectively.
+///
+/// For dictionaries, a similar macro [`dict!`] exists.
+#[macro_export]
+macro_rules! vslice {
+    // Note: use to_variant() and not Variant::from(), as that works with both references and values
+    ($($elements:expr),* $(,)?) => {
+        {
+            use $crate::meta::ToGodot as _;
+            let mut array = $crate::builtin::VariantArray::default();
+            &[
+                $( $elements.to_variant(), )*
+            ]
+        }
+    };
+}
+
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 
 #[cfg(feature = "serde")]

godot-core/src/builtin/mod.rs

@@ -48,7 +48,7 @@ pub mod __prelude_reexport {
     pub use vectors::*;
 
     pub use super::{EulerOrder, Side, VariantOperator, VariantType};
-    pub use crate::{array, dict, real, reals, varray};
+    pub use crate::{array, dict, real, reals, varray, vslice};
 }
 
 pub use __prelude_reexport::*;

itest/rust/src/builtin_tests/containers/callable_test.rs

@@ -7,7 +7,7 @@
 
 use crate::framework::itest;
 use godot::builtin::{
-    array, dict, varray, Array, Callable, Color, GString, NodePath, StringName, Variant,
+    array, dict, varray, vslice, Array, Callable, Color, GString, NodePath, StringName, Variant,
     VariantArray, Vector2,
 };
 use godot::classes::{Node2D, Object, RefCounted};
@@ -104,20 +104,20 @@ fn callable_variant_method() {
     // Dictionary
     let dict = dict! { "one": 1, "value": 2 };
     let dict_get = Callable::from_variant_method(&dict.to_variant(), "get");
-    assert_eq!(dict_get.call(&["one".to_variant()]), 1.to_variant());
+    assert_eq!(dict_get.call(vslice!["one"]), 1.to_variant());
 
     // GString
     let string = GString::from("some string").to_variant();
     let string_md5 = Callable::from_variant_method(&string, "md5_text");
     assert_eq!(
-        string_md5.call(&[]),
+        string_md5.call(vslice![]), // use vslice![] as alternative &[] syntax.
         "5ac749fbeec93607fc28d666be85e73a".to_variant()
     );
 
     // Object
     let obj = CallableTestObj::new_gd().to_variant();
     let obj_stringify = Callable::from_variant_method(&obj, "stringify_int");
-    assert_eq!(obj_stringify.call(&[10.to_variant()]), "10".to_variant());
+    assert_eq!(obj_stringify.call(vslice![10]), "10".to_variant());
 
     // Vector3
     let vector = Vector2::new(-1.2, 2.5).to_variant();
@@ -220,18 +220,15 @@ fn callable_call() {
     let callable = obj.callable("assign_int");
 
     assert_eq!(obj.bind().value, 0);
-    callable.call(&[10.to_variant()]);
+    callable.call(vslice![10]);
     assert_eq!(obj.bind().value, 10);
 
-    callable.call(&[20.to_variant(), 30.to_variant()]);
+    callable.call(vslice![20, 30]);
     assert_eq!(obj.bind().value, 10);
 
-    assert_eq!(callable.call(&["string".to_variant()]), Variant::nil());
+    assert_eq!(callable.call(vslice!["string"]), Variant::nil());
 
-    assert_eq!(
-        Callable::invalid().call(&[1.to_variant(), 2.to_variant(), 3.to_variant()]),
-        Variant::nil()
-    );
+    assert_eq!(Callable::invalid().call(vslice![1, 2, 3]), Variant::nil());
 }
 
 #[itest]
@@ -259,11 +256,11 @@ fn callable_call_engine() {
     assert_eq!(cb.method_name(), Some(StringName::from("set_position")));
 
     let pos = Vector2::new(5.0, 7.0);
-    cb.call(&[pos.to_variant()]);
+    cb.call(vslice![pos]);
     assert_eq!(obj.get_position(), pos);
 
     let pos = Vector2::new(1.0, 23.0);
-    let bound = cb.bind(&[pos.to_variant()]);
+    let bound = cb.bind(vslice![pos]);
     bound.call(&[]);
     assert_eq!(obj.get_position(), pos);
 
@@ -287,7 +284,7 @@ fn callable_bindv() {
 fn callable_bind() {
     let obj = CallableTestObj::new_gd();
     let callable = obj.callable("stringify_int");
-    let callable_bound = callable.bind(&[10.to_variant()]);
+    let callable_bound = callable.bind(vslice![10]);
 
     assert_eq!(
         callable_bound.call(&[]),
@@ -303,12 +300,7 @@ fn callable_unbind() {
     let callable_unbound = callable.unbind(3);
 
     assert_eq!(
-        callable_unbound.call(&[
-            121.to_variant(),
-            20.to_variant(),
-            30.to_variant(),
-            40.to_variant()
-        ]),
+        callable_unbound.call(vslice![121, 20, 30, 40]),
         121.to_variant().stringify().to_variant()
     );
 }
@@ -327,9 +319,7 @@ fn callable_get_argument_count() {
     let concat_array = obj.callable("concat_array");
     assert_eq!(concat_array.get_argument_count(), 4);
     assert_eq!(
-        concat_array
-            .bind(&[10.to_variant(), "hello".to_variant()])
-            .get_argument_count(),
+        concat_array.bind(vslice![10, "hello"]).get_argument_count(),
         2
     );
 }

itest/rust/src/builtin_tests/containers/signal_test.rs

@@ -6,7 +6,7 @@
  */
 
 use crate::framework::itest;
-use godot::builtin::{GString, Signal, StringName};
+use godot::builtin::{vslice, GString, Signal, StringName};
 use godot::classes::object::ConnectFlags;
 use godot::classes::{Node, Node3D, Object, RefCounted};
 use godot::meta::ToGodot;
@@ -27,7 +27,7 @@ fn signal_basic_connect_emit() {
     assert_eq!(receiver.bind().last_received(), LastReceived::Unit);
 
     emitter.connect("signal_int", &receiver.callable("receive_int"));
-    emitter.emit_signal("signal_int", &[1278.to_variant()]);
+    emitter.emit_signal("signal_int", vslice![1278]);
     assert_eq!(receiver.bind().last_received(), LastReceived::Int(1278));
 
     let emitter_variant = emitter.to_variant();
@@ -636,9 +636,8 @@ impl PubClassPrivSignal {
 
 #[cfg(since_api = "4.2")]
 mod custom_callable {
-    use godot::builtin::{Callable, Signal};
+    use godot::builtin::{vslice, Callable, Signal};
     use godot::classes::Node;
-    use godot::meta::ToGodot;
     use godot::obj::{Gd, NewAlloc};
     use std::sync::atomic::{AtomicU32, Ordering};
     use std::sync::Arc;
@@ -655,7 +654,7 @@ mod custom_callable {
                 node.add_user_signal("test_signal");
             },
             |node| {
-                node.emit_signal("test_signal", &[987i64.to_variant()]);
+                node.emit_signal("test_signal", vslice![987i64]);
             },
         );
     }
@@ -669,7 +668,7 @@ mod custom_callable {
                 node.add_user_signal("test_signal");
             },
             |node| {
-                node.emit_signal("test_signal", &[987i64.to_variant()]);
+                node.emit_signal("test_signal", vslice![987i64]);
             },
         );
     }

itest/rust/src/builtin_tests/containers/variant_test.rs

@@ -9,7 +9,8 @@ use std::cmp::Ordering;
 use std::fmt::Display;
 
 use godot::builtin::{
-    array, dict, varray, Array, GString, NodePath, Signal, StringName, Variant, Vector2, Vector3,
+    array, dict, varray, vslice, Array, GString, NodePath, Signal, StringName, Variant, Vector2,
+    Vector3,
 };
 use godot::builtin::{Basis, Dictionary, VariantArray, VariantOperator, VariantType};
 use godot::classes::{Node, Node2D};
@@ -308,7 +309,7 @@ fn variant_call() {
 
     // Object
     let position = Vector2::new(4.0, 5.0);
-    let result = variant.call("set_position", &[position.to_variant()]);
+    let result = variant.call("set_position", vslice![position]);
     assert!(result.is_nil());
 
     let result = variant
@@ -333,7 +334,7 @@ fn variant_call() {
     // 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()]);
+    let result = vector.to_variant().call("dot", vslice![vector_rhs]);
     assert_eq!(result, 2.0.to_variant());
 
     // Dynamic checks are only available in Debug builds.
@@ -478,7 +479,7 @@ fn variant_null_object_is_nil() {
 
     // Simulates an object that is returned but null
     // Use reflection to get a variant as return type
-    let variant = node.call("get_node_or_null", &[node_path.to_variant()]);
+    let variant = node.call("get_node_or_null", vslice![node_path]);
     let raw_type: sys::GDExtensionVariantType =
         unsafe { sys::interface_fn!(variant_get_type)(variant.var_sys()) };
 

itest/rust/src/engine_tests/async_test.rs

@@ -7,9 +7,8 @@
 
 use std::ops::Deref;
 
-use godot::builtin::{array, Array, Callable, Signal, Variant};
+use godot::builtin::{array, vslice, Array, Callable, Signal, Variant};
 use godot::classes::{Object, RefCounted};
-use godot::meta::ToGodot;
 use godot::obj::{Base, Gd, NewAlloc, NewGd};
 use godot::prelude::{godot_api, GodotClass};
 use godot::task::{self, create_test_signal_future_resolver, SignalFuture, TaskHandle};
@@ -50,10 +49,7 @@ fn start_async_task() -> TaskHandle {
 
     let ref_counted_arg = RefCounted::new_gd();
 
-    object.emit_signal(
-        "custom_signal",
-        &[10.to_variant(), ref_counted_arg.to_variant()],
-    );
+    object.emit_signal("custom_signal", vslice![10, ref_counted_arg]);
 
     task_handle
 }
@@ -77,7 +73,7 @@ fn async_task_array() -> TaskHandle {
 
     object.emit_signal(
         "custom_signal_array",
-        &[array![1, 2, 3].to_variant(), ref_counted_arg.to_variant()],
+        vslice![array![1, 2, 3], ref_counted_arg],
     );
 
     task_handle
@@ -154,7 +150,7 @@ fn signal_future_non_send_arg_panic() -> TaskHandle {
     std::thread::spawn(move || {
         let mut object = unsafe { object.extract() };
 
-        object.emit_signal("custom_signal", &[RefCounted::new_gd().to_variant()])
+        object.emit_signal("custom_signal", vslice![RefCounted::new_gd()])
     });
 
     handle
@@ -181,7 +177,7 @@ fn signal_future_send_arg_no_panic() -> TaskHandle {
     std::thread::spawn(move || {
         let mut object = unsafe { object.extract() };
 
-        object.emit_signal("custom_signal", &[1u8.to_variant()])
+        object.emit_signal("custom_signal", vslice![1u8])
     });
 
     handle

itest/rust/src/engine_tests/native_st_niche_pointer_test.rs

@@ -11,11 +11,10 @@
 
 use std::ptr;
 
-use godot::builtin::{Dictionary, Rect2, Rid};
+use godot::builtin::{vslice, Dictionary, Rect2, Rid};
 use godot::classes::native::{CaretInfo, Glyph, ObjectId, PhysicsServer2DExtensionShapeResult};
 use godot::classes::text_server::Direction;
 use godot::classes::{IRefCounted, Node3D, RefCounted};
-use godot::meta::ToGodot;
 use godot::obj::{Base, NewAlloc, NewGd};
 use godot::register::{godot_api, GodotClass};
 
@@ -80,7 +79,7 @@ fn native_structure_parameter() {
 
     let ptr = ptr::addr_of!(caret);
     let mut object = NativeStructTests::new_gd();
-    let result: Dictionary = object.call("pass_native_struct", &[ptr.to_variant()]).to();
+    let result: Dictionary = object.call("pass_native_struct", vslice![ptr]).to();
 
     assert_eq!(
         result.at("leading_caret").to::<Rect2>(),

itest/rust/src/engine_tests/node_test.rs

@@ -7,7 +7,7 @@
 
 use std::str::FromStr;
 
-use godot::builtin::{NodePath, Variant};
+use godot::builtin::{vslice, NodePath};
 use godot::classes::{Node, Node3D, PackedScene, SceneTree};
 use godot::global;
 use godot::obj::{NewAlloc, NewGd};
@@ -90,5 +90,5 @@ fn node_call_group(ctx: &TestContext) {
     let mut tree = node.get_tree().unwrap();
 
     node.add_to_group("group");
-    tree.call_group("group", "set_name", &[Variant::from("name")]);
+    tree.call_group("group", "set_name", vslice!["name"]);
 }

itest/rust/src/engine_tests/utilities_test.rs

@@ -10,7 +10,7 @@
 
 use crate::framework::itest;
 
-use godot::builtin::{GString, Variant};
+use godot::builtin::{vslice, GString, Variant};
 use godot::global::*;
 
 #[itest]
@@ -35,12 +35,7 @@ fn utilities_str() {
     let b = " is a ";
     let c = true;
     let d = " number";
-    let concat = str(&[
-        Variant::from(a),
-        Variant::from(b),
-        Variant::from(c),
-        Variant::from(d),
-    ]);
+    let concat = str(vslice![a, b, c, d]);
 
     let empty = str(&[]);
 
@@ -69,17 +64,13 @@ fn utilities_wrap() {
 
 #[itest]
 fn utilities_max() {
-    let output = max(
-        &Variant::from(1.0),
-        &Variant::from(3.0),
-        &[Variant::from(5.0), Variant::from(7.0)],
-    );
+    let output = max(&Variant::from(1.0), &Variant::from(3.0), vslice![5.0, 7.0]);
     assert_eq!(output, Variant::from(7.0));
 
     let output = max(
         &Variant::from(-1.0),
         &Variant::from(-3.0),
-        &[Variant::from(-5.0), Variant::from(-7.0)],
+        vslice![-5.0, -7.0],
     );
     assert_eq!(output, Variant::from(-1.0));
 }