fix(array): fix double ended iterator implementation

Refs: #316

Author: Xenira

src/types/array.rs

@@ -573,7 +573,9 @@ impl ToOwned for ZendHashTable {
 pub struct Iter<'a> {
     ht: &'a ZendHashTable,
     current_num: i64,
+    end_num: i64,
     pos: HashPosition,
+    end_pos: HashPosition,
 }
 
 #[derive(Debug, PartialEq)]
@@ -627,10 +629,19 @@ impl<'a> Iter<'a> {
     ///
     /// * `ht` - The hashtable to iterate.
     pub fn new(ht: &'a ZendHashTable) -> Self {
+        let end_num: i64 = ht.len().try_into().unwrap();
+        let end_pos = if ht.nNumOfElements > 0 {
+            ht.nNumOfElements - 1
+        } else {
+            0
+        };
+
         Self {
             ht,
             current_num: 0,
+            end_num,
             pos: 0,
+            end_pos,
         }
     }
 }
@@ -686,6 +697,10 @@ impl ExactSizeIterator for Iter<'_> {
 
 impl DoubleEndedIterator for Iter<'_> {
     fn next_back(&mut self) -> Option<Self::Item> {
+        if self.end_num <= self.current_num {
+            return None;
+        }
+
         let key_type = unsafe {
             zend_hash_get_current_key_type_ex(
                 self.ht as *const ZendHashTable as *mut ZendHashTable,
@@ -703,35 +718,39 @@ impl DoubleEndedIterator for Iter<'_> {
             zend_hash_get_current_key_zval_ex(
                 self.ht as *const ZendHashTable as *mut ZendHashTable,
                 &key as *const Zval as *mut Zval,
-                &mut self.pos as *mut HashPosition,
+                &mut self.end_pos as *mut HashPosition,
             );
         }
         let value = unsafe {
             &*zend_hash_get_current_data_ex(
                 self.ht as *const ZendHashTable as *mut ZendHashTable,
-                &mut self.pos as *mut HashPosition,
+                &mut self.end_pos as *mut HashPosition,
             )
         };
 
         let key = match ArrayKey::from_zval(&key) {
             Some(key) => key,
-            None => ArrayKey::Long(self.current_num),
+            None => ArrayKey::Long(self.end_num),
         };
 
         unsafe {
             zend_hash_move_backwards_ex(
                 self.ht as *const ZendHashTable as *mut ZendHashTable,
-                &mut self.pos as *mut HashPosition,
+                &mut self.end_pos as *mut HashPosition,
             )
         };
-        self.current_num -= 1;
+        self.end_num -= 1;
 
         Some((key, value))
     }
 }
 
 impl<'a> Iter<'a> {
     pub fn next_zval(&mut self) -> Option<(Zval, &'a Zval)> {
+        if self.current_num >= self.end_num {
+            return None;
+        }
+
         let key_type = unsafe {
             zend_hash_get_current_key_type_ex(
                 self.ht as *const ZendHashTable as *mut ZendHashTable,

tests/src/integration/iterator.php

@@ -0,0 +1,11 @@
+<?php
+
+assert(iter_next([]) === []);
+assert(iter_next([1, 2, 3]) === [0, 1, 1, 2, 2, 3]);
+assert(iter_back([]) === []);
+assert(iter_back([1, 2, 3]) === [2, 3, 1, 2, 0, 1]);
+
+assert(iter_next_back([], 2) === [null, null]);
+assert(iter_next_back([1, 2 ,3], 2) === [2, 3, 0, 1, 1, 2, null, null]);
+var_dump(iter_next_back([1, 2, 3, 4, 5], 3));
+assert(iter_next_back([1, 2, 3, 4, 5], 3) === [4, 5, 0, 1, 1, 2, 3, 4, 2, 3, null, null, null]);

tests/src/integration/iterator.rs

@@ -0,0 +1,4 @@
+#[test]
+fn iterator_works() {
+    assert!(crate::integration::run_php("iterator.php"));
+}