Add varray![...] macro to construct variant arrays

Author: Bromeon

godot-core/src/builtin/array.rs

@@ -801,29 +801,48 @@ impl<T: VariantMetadata> GodotFfi for TypedArray<T> {
     }
 }
 
-/// Allows for construction of [`TypedArray`] literals, much in the same way as Rust's standard
-/// `vec!` macro. The type of the array is inferred from the arguments.
-///
-/// # Example
+/// Allows for construction of [`TypedArray`] literals, similar to Rust's standard `vec!` macro.
+/// The type of the array is inferred from the arguments.
 ///
+/// Example:
 /// ```no_run
 /// # use godot::prelude::*;
-/// let arr = array![3, 1, 4];
+/// let arr = array![3, 1, 4];  // type Array<i32>
 /// ```
 ///
-/// To create an `Array` of variants, you need to convert each element explicitly:
+/// To create an `Array` of variants, see the [`varray!`] macro.
+#[macro_export]
+macro_rules! array {
+    ($($elements:expr),* $(,)?) => {
+        {
+            let mut array = $crate::builtin::TypedArray::default();
+            $(
+                array.push($elements);
+            )*
+            array
+        }
+    };
+}
+
+/// Allows for construction of [`VariantArray`] literals, similar to Rust's standard `vec!` macro.
+/// The type of the array is always [`Variant`].
 ///
+/// Example:
 /// ```no_run
 /// # use godot::prelude::*;
-/// let arr: Array = array![42_i64.to_variant(), "hello".to_variant()];
+/// let arr: Array = varray![42_i64, "hello", true];
 /// ```
+///
+/// To create a typed `Array` with a single element type, see the [`array!`] macro.
 #[macro_export]
-macro_rules! array {
+macro_rules! varray {
+    // Note: use to_variant() and not Variant::from(), as that works with both references and values
     ($($elements:expr),* $(,)?) => {
         {
-            let mut array = $crate::builtin::TypedArray::default();
+            use $crate::builtin::ToVariant as _;
+            let mut array = $crate::builtin::Array::default();
             $(
-                array.push($elements);
+                array.push($elements.to_variant());
             )*
             array
         }

godot-core/src/builtin/mod.rs

@@ -55,7 +55,7 @@ mod vector4i;
 pub mod meta;
 
 // Re-export macros.
-pub use crate::{array, dict};
+pub use crate::{array, dict, varray};
 
 pub use array::*;
 pub use color::*;

godot/src/lib.rs

@@ -128,7 +128,7 @@ pub use godot_core::private;
 pub mod prelude {
     pub use super::bind::{godot_api, GodotClass, GodotExt};
     pub use super::builtin::*;
-    pub use super::builtin::{array, dict}; // Re-export macros.
+    pub use super::builtin::{array, dict, varray}; // Re-export macros.
     pub use super::engine::{
         load, try_load, utilities, AudioStreamPlayer, Camera2D, Camera3D, Input, Node, Node2D,
         Node3D, Object, PackedScene, RefCounted, Resource, SceneTree,

itest/rust/src/array_test.rs

@@ -77,7 +77,7 @@ fn typed_array_from_to_variant() {
 
 #[itest]
 fn untyped_array_from_to_variant() {
-    let array = array![1.to_variant(), 2.to_variant()];
+    let array = varray![1, 2];
     let variant = array.to_variant();
     let result = Array::try_from_variant(&variant);
     assert_eq!(result, Ok(array));
@@ -91,7 +91,7 @@ fn array_from_packed_array() {
     // which is not reflected in our static type. It would make sense if it did, but Godot decided
     // otherwise: we get an untyped array.
     array.push(GodotString::from("hi").to_variant());
-    assert_eq!(array, array![42.to_variant(), "hi".to_variant()]);
+    assert_eq!(array, varray![42, "hi"]);
 }
 
 #[itest]
@@ -146,7 +146,7 @@ fn array_share() {
 #[itest]
 fn array_duplicate_shallow() {
     let subarray = array![2, 3];
-    let array = array![1.to_variant(), subarray.to_variant()];
+    let array = varray![1, subarray];
     let duplicate = array.duplicate_shallow();
     TypedArray::<i64>::try_from_variant(&duplicate.get(1))
         .unwrap()
@@ -157,7 +157,7 @@ fn array_duplicate_shallow() {
 #[itest]
 fn array_duplicate_deep() {
     let subarray = array![2, 3];
-    let array = array![1.to_variant(), subarray.to_variant()];
+    let array = varray![1, subarray];
     let duplicate = array.duplicate_deep();
     TypedArray::<i64>::try_from_variant(&duplicate.get(1))
         .unwrap()
@@ -172,7 +172,7 @@ fn array_slice_shallow() {
     assert_eq!(slice, array![5, 3]);
 
     let subarray = array![2, 3];
-    let array = array![1.to_variant(), subarray.to_variant()];
+    let array = varray![1, subarray];
     let slice = array.slice_shallow(1, 2, None);
     TypedArray::<i64>::try_from_variant(&slice.get(0))
         .unwrap()
@@ -187,7 +187,7 @@ fn array_slice_deep() {
     assert_eq!(slice, array![5, 3]);
 
     let subarray = array![2, 3];
-    let array = array![1.to_variant(), subarray.to_variant()];
+    let array = varray![1, subarray];
     let slice = array.slice_deep(1, 2, None);
     TypedArray::<i64>::try_from_variant(&slice.get(0))
         .unwrap()
@@ -255,7 +255,7 @@ fn array_min_max() {
     assert_eq!(int_array.min(), Some(1));
     assert_eq!(int_array.max(), Some(2));
 
-    let uncomparable_array = array![1.to_variant(), GodotString::from("two").to_variant()];
+    let uncomparable_array = varray![1, GodotString::from("two")];
 
     assert_eq!(uncomparable_array.min(), None);
     assert_eq!(uncomparable_array.max(), None);
@@ -351,14 +351,14 @@ fn array_mixed_values() {
     let node = Node::new_alloc();
     let ref_counted = RefCounted::new();
 
-    let array = array![
-        int.to_variant(),
-        string.to_variant(),
-        packed_array.to_variant(),
-        typed_array.to_variant(),
-        object.to_variant(),
-        node.to_variant(),
-        ref_counted.to_variant(),
+    let array = varray![
+        int,
+        string,
+        packed_array,
+        typed_array,
+        object,
+        node,
+        ref_counted,
     ];
 
     assert_eq!(i64::try_from_variant(&array.get(0)).unwrap(), int);
@@ -405,10 +405,7 @@ fn untyped_array_pass_to_godot_func() {
     node.queue_free(); // Do not leak even if the test fails.
 
     assert_eq!(
-        node.callv(
-            StringName::from("has_signal"),
-            array!["tree_entered".to_variant()]
-        ),
+        node.callv(StringName::from("has_signal"), varray!["tree_entered"]),
         true.to_variant()
     );
 }
@@ -426,14 +423,7 @@ fn untyped_array_return_from_godot_func() {
     node.queue_free(); // Do not leak even if the test fails.
     let result = node.get_node_and_resource("child_node".into());
 
-    assert_eq!(
-        result,
-        array![
-            child.to_variant(),
-            Variant::nil(),
-            NodePath::default().to_variant()
-        ]
-    );
+    assert_eq!(result, varray![child, Variant::nil(), NodePath::default()]);
 }
 
 // TODO All API functions that take a `TypedArray` are even more obscure and not included in
@@ -489,7 +479,7 @@ impl ArrayTest {
 
     #[func]
     fn return_untyped_array(&self) -> Array {
-        array![42.to_variant(), "answer".to_variant()]
+        varray![42, "answer"]
     }
 
     #[func]

itest/rust/src/dictionary_test.rs

@@ -8,7 +8,7 @@ use std::collections::{HashMap, HashSet};
 
 use crate::{expect_panic, itest};
 use godot::{
-    builtin::{array, dict, Dictionary, FromVariant, ToVariant},
+    builtin::{dict, varray, Dictionary, FromVariant, ToVariant},
     prelude::{Share, Variant},
 };
 
@@ -339,16 +339,12 @@ fn dictionary_contains_keys() {
     assert!(dictionary.contains_key("foo"), "key = \"foo\"");
     assert!(dictionary.contains_key("bar"), "key = \"bar\"");
     assert!(
-        dictionary.contains_all_keys(array!["foo".to_variant(), "bar".to_variant()]),
+        dictionary.contains_all_keys(varray!["foo", "bar"]),
         "keys = [\"foo\", \"bar\"]"
     );
     assert!(!dictionary.contains_key("missing"), "key = \"missing\"");
     assert!(
-        !dictionary.contains_all_keys(array![
-            "foo".to_variant(),
-            "bar".to_variant(),
-            "missing".to_variant()
-        ]),
+        !dictionary.contains_all_keys(varray!["foo", "bar", "missing"]),
         "keys = [\"foo\", \"bar\", \"missing\"]"
     );
 }
@@ -360,14 +356,8 @@ fn dictionary_keys_values() {
         "bar": true,
     };
 
-    assert_eq!(
-        dictionary.keys_array(),
-        array!["foo".to_variant(), "bar".to_variant()]
-    );
-    assert_eq!(
-        dictionary.values_array(),
-        array![0.to_variant(), true.to_variant()]
-    );
+    assert_eq!(dictionary.keys_array(), varray!["foo", "bar"]);
+    assert_eq!(dictionary.values_array(), varray![0, true]);
 }
 
 #[itest]