Rename Array::get -> at, try_get -> get (closer to Vec)

Author: Bromeon

godot-core/src/builtin/array.rs

@@ -483,22 +483,26 @@ impl<T: ArrayElement + FromGodot> Array<T> {
         }
     }
 
-    /// Returns the value at the specified index.
+    /// ⚠️ Returns the value at the specified index.
+    ///
+    /// This replaces the `Index` trait, which cannot be implemented for `Array` as references are not guaranteed to remain valid.
     ///
     /// # Panics
     ///
-    /// If `index` is out of bounds.
-    pub fn get(&self, index: usize) -> T {
-        // Panics on out-of-bounds
+    /// If `index` is out of bounds. If you want to handle out-of-bounds access, use [`get()`](Self::get) instead.
+    pub fn at(&self, index: usize) -> T {
+        // Panics on out-of-bounds.
         let ptr = self.ptr(index);
 
         // SAFETY: `ptr` is a live pointer to a variant since `ptr.is_null()` just verified that the index is not out of bounds.
         let variant = unsafe { Variant::borrow_var_sys(ptr) };
         T::from_variant(variant)
     }
 
-    /// Returns the value at the specified index or `None` if the index is out-of-bounds.
-    pub fn try_get(&self, index: usize) -> Option<T> {
+    /// Returns the value at the specified index, or `None` if the index is out-of-bounds.
+    ///
+    /// If you know the index is correct, use [`at()`](Self::at) instead.
+    pub fn get(&self, index: usize) -> Option<T> {
         let ptr = self.ptr_or_null(index);
         if ptr.is_null() {
             None

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

@@ -62,17 +62,17 @@ fn array_from_iterator() {
     let array = Array::from_iter([1, 2]);
 
     assert_eq!(array.len(), 2);
-    assert_eq!(array.get(0), 1);
-    assert_eq!(array.get(1), 2);
+    assert_eq!(array.at(0), 1);
+    assert_eq!(array.at(1), 2);
 }
 
 #[itest]
 fn array_from_slice() {
     let array = Array::from(&[1, 2]);
 
     assert_eq!(array.len(), 2);
-    assert_eq!(array.get(0), 1);
-    assert_eq!(array.get(1), 2);
+    assert_eq!(array.at(0), 1);
+    assert_eq!(array.at(1), 2);
 }
 
 #[itest]
@@ -108,29 +108,29 @@ fn array_share() {
     let mut array = array![1, 2];
     let shared = array.clone();
     array.set(0, 3);
-    assert_eq!(shared.get(0), 3);
+    assert_eq!(shared.at(0), 3);
 }
 
 #[itest]
 fn array_duplicate_shallow() {
     let subarray = array![2, 3];
     let array = varray![1, subarray];
     let duplicate = array.duplicate_shallow();
-    Array::<i64>::try_from_variant(&duplicate.get(1))
+    Array::<i64>::try_from_variant(&duplicate.at(1))
         .unwrap()
         .set(0, 4);
-    assert_eq!(subarray.get(0), 4);
+    assert_eq!(subarray.at(0), 4);
 }
 
 #[itest]
 fn array_duplicate_deep() {
     let subarray = array![2, 3];
     let array = varray![1, subarray];
     let duplicate = array.duplicate_deep();
-    Array::<i64>::try_from_variant(&duplicate.get(1))
+    Array::<i64>::try_from_variant(&duplicate.at(1))
         .unwrap()
         .set(0, 4);
-    assert_eq!(subarray.get(0), 2);
+    assert_eq!(subarray.at(0), 2);
 }
 
 #[itest]
@@ -142,10 +142,10 @@ fn array_subarray_shallow() {
     let subarray = array![2, 3];
     let array = varray![1, subarray];
     let slice = array.subarray_shallow(1, 2, None);
-    Array::<i64>::try_from_variant(&slice.get(0))
+    Array::<i64>::try_from_variant(&slice.at(0))
         .unwrap()
         .set(0, 4);
-    assert_eq!(subarray.get(0), 4);
+    assert_eq!(subarray.at(0), 4);
 }
 
 #[itest]
@@ -157,30 +157,30 @@ fn array_subarray_deep() {
     let subarray = array![2, 3];
     let array = varray![1, subarray];
     let slice = array.subarray_deep(1, 2, None);
-    Array::<i64>::try_from_variant(&slice.get(0))
+    Array::<i64>::try_from_variant(&slice.at(0))
         .unwrap()
         .set(0, 4);
-    assert_eq!(subarray.get(0), 2);
+    assert_eq!(subarray.at(0), 2);
 }
 
 #[itest]
 fn array_get() {
     let array = array![1, 2];
 
-    assert_eq!(array.get(0), 1);
-    assert_eq!(array.get(1), 2);
+    assert_eq!(array.at(0), 1);
+    assert_eq!(array.at(1), 2);
     expect_panic("Array index 2 out of bounds: length is 2", || {
-        array.get(2);
+        array.at(2);
     });
 }
 
 #[itest]
 fn array_try_get() {
     let array = array![1, 2];
 
-    assert_eq!(array.try_get(0), Some(1));
-    assert_eq!(array.try_get(1), Some(2));
-    assert_eq!(array.try_get(2), None);
+    assert_eq!(array.get(0), Some(1));
+    assert_eq!(array.get(1), Some(2));
+    assert_eq!(array.get(2), None);
 }
 
 #[itest]
@@ -254,7 +254,7 @@ fn array_set() {
     let mut array = array![1, 2];
 
     array.set(0, 3);
-    assert_eq!(array.get(0), 3);
+    assert_eq!(array.at(0), 3);
 
     expect_panic("Array index 2 out of bounds: length is 2", move || {
         array.set(2, 4);
@@ -340,34 +340,34 @@ fn array_mixed_values() {
         user_refc,
     ];
 
-    assert_eq!(i64::try_from_variant(&array.get(0)).unwrap(), int);
-    assert_eq!(GString::try_from_variant(&array.get(1)).unwrap(), string);
+    assert_eq!(i64::try_from_variant(&array.at(0)).unwrap(), int);
+    assert_eq!(GString::try_from_variant(&array.at(1)).unwrap(), string);
     assert_eq!(
-        PackedByteArray::try_from_variant(&array.get(2)).unwrap(),
+        PackedByteArray::try_from_variant(&array.at(2)).unwrap(),
         packed_array
     );
-    assert_eq!(Array::try_from_variant(&array.get(3)).unwrap(), typed_array);
+    assert_eq!(Array::try_from_variant(&array.at(3)).unwrap(), typed_array);
     assert_eq!(
-        Gd::<Object>::try_from_variant(&array.get(4))
+        Gd::<Object>::try_from_variant(&array.at(4))
             .unwrap()
             .instance_id(),
         object.instance_id()
     );
     assert_eq!(
-        Gd::<Node>::try_from_variant(&array.get(5))
+        Gd::<Node>::try_from_variant(&array.at(5))
             .unwrap()
             .instance_id(),
         node.instance_id()
     );
 
     assert_eq!(
-        Gd::<RefCounted>::try_from_variant(&array.get(6))
+        Gd::<RefCounted>::try_from_variant(&array.at(6))
             .unwrap()
             .instance_id(),
         engine_refc.instance_id()
     );
     assert_eq!(
-        Gd::<ArrayTest>::try_from_variant(&array.get(7))
+        Gd::<ArrayTest>::try_from_variant(&array.at(7))
             .unwrap()
             .instance_id(),
         user_refc.instance_id()

itest/rust/src/engine_tests/native_structures_test.rs

@@ -137,8 +137,8 @@ fn test_native_structure_pointer_to_array_parameter() {
 
     // Check the result array.
     assert_eq!(result.len(), 2);
-    assert_eq!(result.get(0).get("start"), Some(Variant::from(99)));
-    assert_eq!(result.get(1).get("start"), Some(Variant::from(700)));
+    assert_eq!(result.at(0).get("start"), Some(Variant::from(99)));
+    assert_eq!(result.at(1).get("start"), Some(Variant::from(700)));
 }
 
 #[itest]

itest/rust/src/object_tests/virtual_methods_test.rs

@@ -381,28 +381,28 @@ fn test_virtual_method_with_return() {
     assert_eq!(arr.len(), arr_rust.len());
     // can't just assert_eq because the values of some floats change slightly
     assert_eq_approx!(
-        arr.get(0).to::<PackedVector3Array>().get(0),
-        arr_rust.get(0).to::<PackedVector3Array>().get(0),
+        arr.at(0).to::<PackedVector3Array>().get(0),
+        arr_rust.at(0).to::<PackedVector3Array>().get(0),
     );
     assert_eq_approx!(
-        real::from_f32(arr.get(2).to::<PackedFloat32Array>().get(3)),
-        real::from_f32(arr_rust.get(2).to::<PackedFloat32Array>().get(3)),
+        real::from_f32(arr.at(2).to::<PackedFloat32Array>().get(3)),
+        real::from_f32(arr_rust.at(2).to::<PackedFloat32Array>().get(3)),
     );
     assert_eq_approx!(
-        arr.get(3).to::<PackedColorArray>().get(0),
-        arr_rust.get(3).to::<PackedColorArray>().get(0),
+        arr.at(3).to::<PackedColorArray>().get(0),
+        arr_rust.at(3).to::<PackedColorArray>().get(0),
     );
     assert_eq_approx!(
-        arr.get(4).to::<PackedVector2Array>().get(0),
-        arr_rust.get(4).to::<PackedVector2Array>().get(0),
+        arr.at(4).to::<PackedVector2Array>().get(0),
+        arr_rust.at(4).to::<PackedVector2Array>().get(0),
     );
     assert_eq!(
-        arr.get(6).to::<PackedByteArray>(),
-        arr_rust.get(6).to::<PackedByteArray>(),
+        arr.at(6).to::<PackedByteArray>(),
+        arr_rust.at(6).to::<PackedByteArray>(),
     );
     assert_eq!(
-        arr.get(10).to::<PackedInt32Array>(),
-        arr_rust.get(10).to::<PackedInt32Array>()
+        arr.at(10).to::<PackedInt32Array>(),
+        arr_rust.at(10).to::<PackedInt32Array>()
     );
 }