Merge pull request #1428 from godot-rust/qol/untyped-collection-rename

Rename untyped collections to `VarArray` + `VarDictionary`

Author: Bromeon

godot-codegen/src/conv/type_conversions.rs

@@ -53,7 +53,8 @@ fn to_hardcoded_rust_ident(full_ty: &GodotTy) -> Option<&str> {
         // Others
         ("bool", None) => "bool",
         ("String", None) => "GString",
-        ("Array", None) => "VariantArray",
+        ("Array", None) => "VarArray",
+        ("Dictionary", None) => "VarDictionary",
 
         // Types needed for native structures mapping
         ("uint8_t", None) => "u8",
@@ -331,8 +332,8 @@ fn to_rust_expr_inner(expr: &str, ty: &RustTy, is_inner: bool) -> TokenStream {
         "true" => return quote! { true },
         "false" => return quote! { false },
         "[]" | "{}" if is_inner => return quote! {},
-        "[]" => return quote! { Array::new() }, // VariantArray or Array<T>
-        "{}" => return quote! { Dictionary::new() },
+        "[]" => return quote! { Array::new() }, // VarArray or Array<T>
+        "{}" => return quote! { VarDictionary::new() },
         "null" => {
             return match ty {
                 RustTy::BuiltinIdent { ty: ident, .. } if ident == "Variant" => {
@@ -614,7 +615,7 @@ fn gdscript_to_rust_expr() {
         // Special literals
         ("true",                                           None,               quote! { true }),
         ("false",                                          None,               quote! { false }),
-        ("{}",                                             None,               quote! { Dictionary::new() }),
+        ("{}",                                             None,               quote! { VarDictionary::new() }),
         ("[]",                                             None,               quote! { Array::new() }),
 
         ("null",                                           ty_variant,         quote! { Variant::nil() }),

godot-codegen/src/generator/builtins.rs

@@ -211,7 +211,7 @@ fn method_safety_doc(class_name: &TyName, method: &BuiltinMethod) -> Option<Toke
                ///
                /// In the current implementation, both cases will produce a panic rather than undefined behavior, but this should not be relied upon.
             });
-        } else if &method.return_value().type_tokens().to_string() == "VariantArray" {
+        } else if &method.return_value().type_tokens().to_string() == "VarArray" {
             return Some(quote! {
                 /// # Safety
                 ///

godot-core/src/builtin/callable.rs

@@ -11,7 +11,7 @@ use std::{fmt, ptr};
 use godot_ffi as sys;
 use sys::{ffi_methods, ExtVariantType, GodotFfi};
 
-use crate::builtin::{inner, GString, StringName, Variant, VariantArray};
+use crate::builtin::{inner, GString, StringName, VarArray, Variant};
 use crate::meta::{GodotType, ToGodot};
 use crate::obj::bounds::DynMemory;
 use crate::obj::{Bounds, Gd, GodotClass, InstanceId, Singleton};
@@ -381,14 +381,14 @@ impl Callable {
     /// - If called on an invalid Callable then no error is printed, and `NIL` is returned.
     ///
     /// _Godot equivalent: `callv`_
-    pub fn callv(&self, arguments: &VariantArray) -> Variant {
+    pub fn callv(&self, arguments: &VarArray) -> Variant {
         self.as_inner().callv(arguments)
     }
 
     /// Returns a copy of this Callable with one or more arguments bound, reading them from an array.
     ///
     /// _Godot equivalent: `bindv`_
-    pub fn bindv(&self, arguments: &VariantArray) -> Self {
+    pub fn bindv(&self, arguments: &VarArray) -> Self {
         self.as_inner().bindv(arguments)
     }
 

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

@@ -37,7 +37,7 @@ use crate::registry::property::{BuiltinExport, Export, Var};
 /// Godot's `Array` can be either typed or untyped.
 ///
 /// An untyped array can contain any kind of [`Variant`], even different types in the same array.
-/// We represent this in Rust as `VariantArray`, which is just a type alias for `Array<Variant>`.
+/// We represent this in Rust as `VarArray`, which is just a type alias for `Array<Variant>`.
 ///
 /// Godot also supports typed arrays, which are also just `Variant` arrays under the hood, but with
 /// runtime checks, so that no values of the wrong type are inserted into the array. We represent this as
@@ -93,8 +93,8 @@ use crate::registry::property::{BuiltinExport, Export, Var};
 ///
 /// ```no_run
 /// # use godot::prelude::*;
-/// // VariantArray allows dynamic element types.
-/// let mut array = VariantArray::new();
+/// // VarArray allows dynamic element types.
+/// let mut array = VarArray::new();
 /// array.push(&10.to_variant());
 /// array.push(&"Hello".to_variant());
 ///
@@ -191,11 +191,14 @@ impl<'a> std::ops::Deref for ImmutableInnerArray<'a> {
     }
 }
 
-/// A Godot `Array` without an assigned type.
+#[deprecated = "Renamed to `VarArray`."]
 pub type VariantArray = Array<Variant>;
 
+/// Untyped Godot `Array`.
+pub type VarArray = Array<Variant>;
+
 // TODO check if these return a typed array
-impl_builtin_froms!(VariantArray;
+impl_builtin_froms!(VarArray;
     PackedByteArray => array_from_packed_byte_array,
     PackedColorArray => array_from_packed_color_array,
     PackedFloat32Array => array_from_packed_float32_array,
@@ -208,7 +211,7 @@ impl_builtin_froms!(VariantArray;
 );
 
 #[cfg(since_api = "4.3")]
-impl_builtin_froms!(VariantArray;
+impl_builtin_froms!(VarArray;
     PackedVector4Array => array_from_packed_vector4_array,
 );
 
@@ -521,7 +524,7 @@ impl<T: ArrayElement> Array<T> {
         self.balanced_ensure_mutable();
 
         // SAFETY: `append_array` will only read values from `other`, and all types can be converted to `Variant`.
-        let other: &VariantArray = unsafe { other.assume_type_ref::<Variant>() };
+        let other: &VarArray = unsafe { other.assume_type_ref::<Variant>() };
 
         // SAFETY: `append_array` will only write values gotten from `other` into `self`, and all values in `other` are guaranteed
         // to be of type `T`.
@@ -1124,7 +1127,7 @@ fn correct_variant_t() {
     assert!(!Array::<i64>::has_variant_t());
 }
 
-impl VariantArray {
+impl VarArray {
     /// # Safety
     /// - Variant must have type `VariantType::ARRAY`.
     /// - Subsequent operations on this array must not rely on the type of the array.
@@ -1165,7 +1168,7 @@ unsafe impl<T: ArrayElement> GodotFfi for Array<T> {
 }
 
 // Only implement for untyped arrays; typed arrays cannot be nested in Godot.
-impl ArrayElement for VariantArray {}
+impl ArrayElement for VarArray {}
 
 impl<T: ArrayElement> GodotConvert for Array<T> {
     type Via = Self;
@@ -1271,7 +1274,7 @@ where
     fn export_hint() -> PropertyHintInfo {
         // If T == Variant, then we return "Array" builtin type hint.
         if Self::has_variant_t() {
-            PropertyHintInfo::type_name::<VariantArray>()
+            PropertyHintInfo::type_name::<VarArray>()
         } else {
             PropertyHintInfo::export_array_element::<T>()
         }
@@ -1598,14 +1601,14 @@ macro_rules! array {
     };
 }
 
-/// Constructs [`VariantArray`] literals, similar to Rust's standard `vec!` macro.
+/// Constructs [`VarArray`] literals, similar to Rust's standard `vec!` macro.
 ///
 /// The type of the array elements is always [`Variant`].
 ///
 /// # Example
 /// ```no_run
 /// # use godot::prelude::*;
-/// let arr: VariantArray = varray![42_i64, "hello", true];
+/// let arr: VarArray = varray![42_i64, "hello", true];
 /// ```
 ///
 /// # See also
@@ -1620,7 +1623,7 @@ macro_rules! varray {
     ($($elements:expr),* $(,)?) => {
         {
             use $crate::meta::ToGodot as _;
-            let mut array = $crate::builtin::VariantArray::default();
+            let mut array = $crate::builtin::VarArray::default();
             $(
                 array.push(&$elements.to_variant());
             )*
@@ -1668,7 +1671,6 @@ macro_rules! vslice {
     ($($elements:expr),* $(,)?) => {
         {
             use $crate::meta::ToGodot as _;
-            let mut array = $crate::builtin::VariantArray::default();
             &[
                 $( $elements.to_variant(), )*
             ]

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

@@ -5,7 +5,7 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-use crate::builtin::{to_usize, Array, Callable, Variant, VariantArray};
+use crate::builtin::{to_usize, Array, Callable, VarArray, Variant};
 use crate::meta::{ArrayElement, AsArg};
 use crate::{meta, sys};
 
@@ -59,7 +59,7 @@ impl<'a, T: ArrayElement> ArrayFunctionalOps<'a, T> {
     /// **Rust alternatives:** [`Iterator::map()`].
     ///
     /// The callable has signature `fn(T) -> Variant`. Since the transformation can change the element type, this method returns
-    /// a `VariantArray` (untyped array).
+    /// a `VarArray` (untyped array).
     ///
     /// # Example
     /// ```no_run
@@ -71,7 +71,7 @@ impl<'a, T: ArrayElement> ArrayFunctionalOps<'a, T> {
     /// assert_eq!(rounded, varray![1, 2, 2]);
     /// ```
     #[must_use]
-    pub fn map(&self, callable: &Callable) -> VariantArray {
+    pub fn map(&self, callable: &Callable) -> VarArray {
         // SAFETY: map() returns an untyped array.
         unsafe { self.array.as_inner().map(callable) }
     }