Remove the `current_leaf` method from `Tree`

The notion of `current` doesn't make a lot of sense in the context of
out-of-order insertion.

bridgetree/src/lib.rs

@@ -1324,10 +1324,6 @@ mod tests {
             BridgeTree::current_position(self)
         }
 
-        fn current_leaf(&self) -> Option<&H> {
-            BridgeTree::current_leaf(self)
-        }
-
         fn get_marked_leaf(&self, position: Position) -> Option<&H> {
             BridgeTree::get_marked_leaf(self, position)
         }

incrementalmerkletree/src/testing.rs

@@ -40,9 +40,6 @@ pub trait Tree<H, C> {
     /// Returns the most recently appended leaf value.
     fn current_position(&self) -> Option<Position>;
 
-    /// Returns the most recently appended leaf value.
-    fn current_leaf(&self) -> Option<&H>;
-
     /// Returns the leaf at the specified position if the tree can produce
     /// a witness for it.
     fn get_marked_leaf(&self, position: Position) -> Option<&H>;
@@ -138,7 +135,6 @@ impl<H: Hashable> Hashable for Option<H> {
 pub enum Operation<A, C> {
     Append(A, Retention<C>),
     CurrentPosition,
-    CurrentLeaf,
     MarkedLeaf(Position),
     MarkedPositions,
     Unmark(Position),
@@ -170,7 +166,6 @@ impl<H: Hashable + Clone, C: Clone> Operation<H, C> {
                 None
             }
             CurrentPosition => None,
-            CurrentLeaf => None,
             MarkedLeaf(_) => None,
             MarkedPositions => None,
             Unmark(p) => {
@@ -205,7 +200,6 @@ impl<H: Hashable + Clone, C: Clone> Operation<H, C> {
         match self {
             Append(a, r) => Append(a.clone(), r.map(f)),
             CurrentPosition => CurrentPosition,
-            CurrentLeaf => CurrentLeaf,
             MarkedLeaf(l) => MarkedLeaf(*l),
             MarkedPositions => MarkedPositions,
             Unmark(p) => Unmark(*p),
@@ -235,7 +229,6 @@ where
     prop_oneof![
         (item_gen, arb_retention()).prop_map(|(i, r)| Operation::Append(i, r)),
         prop_oneof![
-            Just(Operation::CurrentLeaf),
             Just(Operation::CurrentPosition),
             Just(Operation::MarkedPositions),
         ],
@@ -269,7 +262,6 @@ pub fn apply_operation<H, C, T: Tree<H, C>>(tree: &mut T, op: Operation<H, C>) {
             tree.rewind();
         }
         CurrentPosition => {}
-        CurrentLeaf => {}
         Witness(_, _) => {}
         MarkedLeaf(_) => {}
         MarkedPositions => {}
@@ -307,9 +299,6 @@ pub fn check_operations<H: Hashable + Ord + Clone, C: Clone, T: Tree<H, C>>(
                     prop_assert_eq!(tree_size - 1, pos.into());
                 }
             }
-            CurrentLeaf => {
-                prop_assert_eq!(tree_values.last(), tree.current_leaf());
-            }
             MarkedLeaf(position) => {
                 if tree.get_marked_leaf(*position).is_some() {
                     prop_assert!(<usize>::from(*position) < tree_size);
@@ -436,13 +425,6 @@ impl<H: Hashable + Ord + Clone + Debug, C: Clone, I: Tree<H, C>, E: Tree<H, C>>
         a
     }
 
-    fn current_leaf(&self) -> Option<&H> {
-        let a = self.inefficient.current_leaf();
-        let b = self.efficient.current_leaf();
-        assert_eq!(a, b);
-        a
-    }
-
     fn get_marked_leaf(&self, position: Position) -> Option<&H> {
         let a = self.inefficient.get_marked_leaf(position);
         let b = self.efficient.get_marked_leaf(position);

incrementalmerkletree/src/testing/complete_tree.rs

@@ -133,6 +133,8 @@ impl<H: Hashable, C: Clone + Ord + core::fmt::Debug, const DEPTH: u8> CompleteTr
         }
     }
 
+    /// Marks the current tree state leaf as a value that we're interested in
+    /// marking. Returns the current position if the tree is non-empty.
     fn mark(&mut self) -> Option<Position> {
         match self.current_position() {
             Some(pos) => {
@@ -217,8 +219,8 @@ impl<H: Hashable + PartialEq + Clone, C: Ord + Clone + core::fmt::Debug, const D
         Self::current_position(self)
     }
 
-    fn current_leaf(&self) -> Option<&H> {
-        self.leaves.last().and_then(|opt: &Option<H>| opt.as_ref())
+    fn marked_positions(&self) -> BTreeSet<Position> {
+        self.marks.clone()
     }
 
     fn get_marked_leaf(&self, position: Position) -> Option<&H> {
@@ -231,10 +233,6 @@ impl<H: Hashable + PartialEq + Clone, C: Ord + Clone + core::fmt::Debug, const D
         }
     }
 
-    fn marked_positions(&self) -> BTreeSet<Position> {
-        self.marks.clone()
-    }
-
     fn root(&self, checkpoint_depth: usize) -> Option<H> {
         self.leaves_at_checkpoint_depth(checkpoint_depth)
             .and_then(|len| root(&self.leaves[0..len], DEPTH))