WIP: in-mem overlay proptest

Author: mediocregopher

crates/trie/trie/src/forward_cursor.rs

@@ -23,36 +23,32 @@ impl<'a, K, V> ForwardInMemoryCursor<'a, K, V> {
         self.is_empty
     }
 
-    /// Returns the last entry iterated to. Returns `None` if never iterated or if exhausted.
+    /// Returns the current entry pointed to be the cursor, or `None` if no entries are left.
     #[inline]
-    pub fn current(&self) -> Option<&'a (K, V)> {
+    pub fn current(&self) -> Option<&(K, V)> {
         self.entries.clone().next()
     }
-}
-
-impl<'a, K, V> Iterator for ForwardInMemoryCursor<'a, K, V> {
-    type Item = &'a (K, V);
 
-    fn next(&mut self) -> Option<&'a (K, V)> {
-        self.entries.next();
-        self.current()
+    #[inline]
+    fn next(&mut self) -> Option<&(K, V)> {
+        self.entries.next()
     }
 }
 
-impl<'a, K, V> ForwardInMemoryCursor<'a, K, V>
+impl<K, V> ForwardInMemoryCursor<'_, K, V>
 where
     K: PartialOrd + Clone,
     V: Clone,
 {
     /// Returns the first entry from the current cursor position that's greater or equal to the
     /// provided key. This method advances the cursor forward.
-    pub fn seek(&mut self, key: &K) -> Option<&'a (K, V)> {
+    pub fn seek(&mut self, key: &K) -> Option<(K, V)> {
         self.advance_while(|k| k < key)
     }
 
     /// Returns the first entry from the current cursor position that's greater than the provided
     /// key. This method advances the cursor forward.
-    pub fn first_after(&mut self, key: &K) -> Option<&'a (K, V)> {
+    pub fn first_after(&mut self, key: &K) -> Option<(K, V)> {
         self.advance_while(|k| k <= key)
     }
 
@@ -61,15 +57,17 @@ where
     ///
     /// Returns the first entry for which `predicate` returns `false` or `None`. The cursor will
     /// point to the returned entry.
-    fn advance_while(&mut self, predicate: impl Fn(&'a K) -> bool) -> Option<&'a (K, V)> {
+    fn advance_while(&mut self, predicate: impl Fn(&K) -> bool) -> Option<(K, V)> {
+        let mut entry;
         loop {
-            if self.current().is_some_and(|(k, _)| predicate(k)) {
-                self.entries.next();
+            entry = self.current();
+            if entry.is_some_and(|(k, _)| predicate(k)) {
+                self.next();
             } else {
                 break;
             }
         }
-        self.current()
+        entry.cloned()
     }
 }
 
@@ -80,17 +78,18 @@ mod tests {
     #[test]
     fn test_cursor() {
         let mut cursor = ForwardInMemoryCursor::new(&[(1, ()), (2, ()), (3, ()), (4, ()), (5, ())]);
+        assert_eq!(cursor.current(), Some(&(1, ())));
 
-        assert_eq!(cursor.seek(&0), Some(&(1, ())));
+        assert_eq!(cursor.seek(&0), Some((1, ())));
         assert_eq!(cursor.current(), Some(&(1, ())));
 
-        assert_eq!(cursor.seek(&3), Some(&(3, ())));
+        assert_eq!(cursor.seek(&3), Some((3, ())));
         assert_eq!(cursor.current(), Some(&(3, ())));
 
-        assert_eq!(cursor.seek(&3), Some(&(3, ())));
+        assert_eq!(cursor.seek(&3), Some((3, ())));
         assert_eq!(cursor.current(), Some(&(3, ())));
 
-        assert_eq!(cursor.seek(&4), Some(&(4, ())));
+        assert_eq!(cursor.seek(&4), Some((4, ())));
         assert_eq!(cursor.current(), Some(&(4, ())));
 
         assert_eq!(cursor.seek(&6), None);

crates/trie/trie/src/hashed_cursor/post_state.rs

@@ -93,7 +93,7 @@ where
         // It's an exact match, return the account from post state without looking up in the
         // database.
         if post_state_entry.is_some_and(|entry| entry.0 == key) {
-            return Ok(post_state_entry.copied())
+            return Ok(post_state_entry)
         }
 
         // It's not an exact match, reposition to the first greater or equal account that wasn't
@@ -104,7 +104,7 @@ where
         }
 
         // Compare two entries and return the lowest.
-        Ok(Self::compare_entries(post_state_entry.copied(), db_entry))
+        Ok(Self::compare_entries(post_state_entry, db_entry))
     }
 
     fn next_inner(&mut self, last_account: B256) -> Result<Option<(B256, Account)>, DatabaseError> {
@@ -120,7 +120,7 @@ where
         }
 
         // Compare two entries and return the lowest.
-        Ok(Self::compare_entries(post_state_entry.copied(), db_entry))
+        Ok(Self::compare_entries(post_state_entry, db_entry))
     }
 
     /// Return the account with the lowest hashed account key.
@@ -228,7 +228,7 @@ where
         // If database storage was wiped or it's an exact match,
         // return the storage slot from post state without looking up in the database.
         if self.storage_wiped || post_state_entry.is_some_and(|entry| entry.0 == subkey) {
-            return Ok(post_state_entry.copied())
+            return Ok(post_state_entry)
         }
 
         // It's not an exact match and storage was not wiped,
@@ -239,7 +239,7 @@ where
         }
 
         // Compare two entries and return the lowest.
-        Ok(Self::compare_entries(post_state_entry.copied(), db_entry))
+        Ok(Self::compare_entries(post_state_entry, db_entry))
     }
 
     /// Find the storage entry that is right after current cursor position.
@@ -250,7 +250,7 @@ where
 
         // Return post state entry immediately if database was wiped.
         if self.storage_wiped {
-            return Ok(post_state_entry.copied())
+            return Ok(post_state_entry)
         }
 
         // If post state was given precedence, move the cursor forward.
@@ -264,7 +264,7 @@ where
         }
 
         // Compare two entries and return the lowest.
-        Ok(Self::compare_entries(post_state_entry.copied(), db_entry))
+        Ok(Self::compare_entries(post_state_entry, db_entry))
     }
 
     /// Return the storage entry with the lowest hashed storage key (hashed slot).