Change Packed*Array::get() to return Option<T>, now that there is []

Author: Bromeon

godot-core/src/builtin/packed_array.rs

@@ -188,10 +188,16 @@ macro_rules! impl_packed_array {
             /// # Panics
             ///
             /// If `index` is out of bounds.
-            pub fn get(&self, index: usize) -> $Element {
-                let ptr = self.ptr(index);
-                // SAFETY: `ptr` just verified that the index is not out of bounds.
-                unsafe { (*ptr).clone() }
+            pub fn get(&self, index: usize) -> Option<$Element> {
+                if index >= self.len() {
+                    return None;
+                }
+
+                // SAFETY: bounds check above.
+                unsafe {
+                    let ptr = self.ptr_unchecked(index);
+                    Some((*ptr).clone())
+                }
             }
 
             /// Finds the index of an existing value in a sorted array using binary search.
@@ -293,8 +299,7 @@ macro_rules! impl_packed_array {
             // elements to their new position, the overhead of retrieving this element is trivial.
             #[doc(alias = "remove_at")]
             pub fn remove(&mut self, index: usize) -> $Element {
-                self.check_bounds(index);
-                let element = self.get(index);
+                let element = self[index].clone(); // panics on out-of-bounds
                 self.as_inner().remove_at(to_i64(index));
                 element
             }
@@ -334,9 +339,7 @@ macro_rules! impl_packed_array {
             /// If `index` is out of bounds.
             fn check_bounds(&self, index: usize) {
                 let len = self.len();
-                assert!(
-                    index < len,
-                    "Array index {index} is out of bounds: length is {len}");
+                assert!(index < len, "Array index {index} is out of bounds: length is {len}");
             }
 
             /// Returns a pointer to the element at the given index.
@@ -346,6 +349,7 @@ macro_rules! impl_packed_array {
             /// If `index` is out of bounds.
             fn ptr(&self, index: usize) -> *const $Element {
                 self.check_bounds(index);
+
                 // SAFETY: We just checked that the index is not out of bounds.
                 let ptr = unsafe {
                     let item_ptr: *const $IndexRetType =
@@ -356,6 +360,18 @@ macro_rules! impl_packed_array {
                 ptr
             }
 
+            /// Returns a pointer to the element at the given index, or `None` if `index` is out of bounds.
+            ///
+            /// # Safety
+            /// Bound checking is responsibility of the caller.
+            unsafe fn ptr_unchecked(&self, index: usize) -> *const $Element {
+                let item_ptr: *const $IndexRetType = interface_fn!($operator_index_const)(self.sys(), to_i64(index));
+                let ptr = item_ptr as *const $Element;
+
+                assert!(!ptr.is_null());
+                ptr
+            }
+
             /// Returns a mutable pointer to the element at the given index.
             ///
             /// # Panics
@@ -477,11 +493,11 @@ macro_rules! impl_packed_array {
             /// Formats `PackedArray` to match Godot's string representation.
             fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
                 write!(f, "[")?;
-                for i in 0..self.len() {
+                for (i, elem) in self.as_slice().iter().enumerate() {
                     if i != 0 {
                         write!(f, ", ")?;
                     }
-                    write!(f, "{}", self.get(i))?;
+                    write!(f, "{elem}")?;
                 }
                 write!(f, "]")
             }

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

@@ -23,17 +23,8 @@ fn packed_array_from_iterator() {
     let array = PackedByteArray::from_iter([1, 2]);
 
     assert_eq!(array.len(), 2);
-    assert_eq!(array.get(0), 1);
-    assert_eq!(array.get(1), 2);
-}
-
-#[itest]
-fn packed_array_from() {
-    let array = PackedByteArray::from(&[1, 2]);
-
-    assert_eq!(array.len(), 2);
-    assert_eq!(array.get(0), 1);
-    assert_eq!(array.get(1), 2);
+    assert_eq!(array[0], 1);
+    assert_eq!(array[1], 2);
 }
 
 #[itest]
@@ -78,7 +69,7 @@ fn packed_array_clone() {
     let clone = array.clone();
     array.set(0, 3);
 
-    assert_eq!(clone.get(0), 1);
+    assert_eq!(clone[0], 1);
 }
 
 #[itest]
@@ -159,11 +150,9 @@ fn packed_array_index() {
 fn packed_array_get() {
     let array = PackedByteArray::from(&[1, 2]);
 
-    assert_eq!(array.get(0), 1);
-    assert_eq!(array.get(1), 2);
-    expect_panic("Array index 2 out of bounds: length is 2", || {
-        array.get(2);
-    });
+    assert_eq!(array.get(0), Some(1));
+    assert_eq!(array.get(1), Some(2));
+    assert_eq!(array.get(2), None);
 }
 
 #[itest]
@@ -200,7 +189,7 @@ fn packed_array_set() {
     let mut array = PackedByteArray::from(&[1, 2]);
 
     array.set(0, 3);
-    assert_eq!(array.get(0), 3);
+    assert_eq!(array[0], 3);
 
     expect_panic("Array index 2 out of bounds: length is 2", move || {
         array.set(2, 4);
@@ -214,7 +203,7 @@ fn packed_array_push() {
     array.push(3);
 
     assert_eq!(array.len(), 3);
-    assert_eq!(array.get(2), 3);
+    assert_eq!(array[2], 3);
 }
 
 #[itest]

itest/rust/src/object_tests/virtual_methods_test.rs

@@ -381,20 +381,20 @@ 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.at(0).to::<PackedVector3Array>().get(0),
-        arr_rust.at(0).to::<PackedVector3Array>().get(0),
+        arr.at(0).to::<PackedVector3Array>()[0],
+        arr_rust.at(0).to::<PackedVector3Array>()[0],
     );
     assert_eq_approx!(
-        real::from_f32(arr.at(2).to::<PackedFloat32Array>().get(3)),
-        real::from_f32(arr_rust.at(2).to::<PackedFloat32Array>().get(3)),
+        real::from_f32(arr.at(2).to::<PackedFloat32Array>()[3]),
+        real::from_f32(arr_rust.at(2).to::<PackedFloat32Array>()[3]),
     );
     assert_eq_approx!(
-        arr.at(3).to::<PackedColorArray>().get(0),
-        arr_rust.at(3).to::<PackedColorArray>().get(0),
+        arr.at(3).to::<PackedColorArray>()[0],
+        arr_rust.at(3).to::<PackedColorArray>()[0],
     );
     assert_eq_approx!(
-        arr.at(4).to::<PackedVector2Array>().get(0),
-        arr_rust.at(4).to::<PackedVector2Array>().get(0),
+        arr.at(4).to::<PackedVector2Array>()[0],
+        arr_rust.at(4).to::<PackedVector2Array>()[0],
     );
     assert_eq!(
         arr.at(6).to::<PackedByteArray>(),