feat: make TrieNode sized

Author: demosdemon

storage/src/tries/iter.rs

@@ -22,47 +22,47 @@ pub struct IterDescending;
 /// respectively.
 #[derive(Debug)]
 #[must_use = "iterators are lazy and do nothing unless consumed"]
-pub struct TrieEdgeIter<'a, N: ?Sized, V: ?Sized, D> {
+pub struct TrieEdgeIter<'root, N, V: ?Sized, D> {
     leading_path: PathBuf,
-    stack: Vec<Frame<'a, N, V>>,
+    stack: Vec<Frame<'root, N, V>>,
     marker: std::marker::PhantomData<D>,
 }
 
 /// An iterator over the key-value pairs in a key-value trie.
 #[derive(Debug)]
 #[must_use = "iterators are lazy and do nothing unless consumed"]
-pub struct TrieValueIter<'a, N: ?Sized, V: ?Sized, D> {
-    edges: TrieEdgeIter<'a, N, V, D>,
+pub struct TrieValueIter<'root, N, V: ?Sized, D> {
+    edges: TrieEdgeIter<'root, N, V, D>,
 }
 
 /// An iterator over the edges along a specified path in a key-value trie
 /// terminating at the node corresponding to the path, if it exists; otherwise,
 /// terminating at the deepest existing edge along the path.
 #[derive(Debug)]
 #[must_use = "iterators are lazy and do nothing unless consumed"]
-pub struct TriePathIter<'a, P, N: ?Sized, V: ?Sized> {
+pub struct TriePathIter<'root, P, N, V: ?Sized> {
     needle: P,
     current_path: PathBuf,
-    current_edge: Option<TrieEdgeState<'a, N>>,
+    current_edge: Option<TrieEdgeState<'root, N>>,
     marker: std::marker::PhantomData<V>,
 }
 
 #[derive(Debug)]
-struct Frame<'a, N: ?Sized, V: ?Sized> {
-    node: &'a N,
-    hash: Option<&'a HashType>,
+struct Frame<'root, N, V: ?Sized> {
+    node: N,
+    hash: Option<&'root HashType>,
     leading_path_len: usize,
     children: Option<std::array::IntoIter<PathComponent, { PathComponent::LEN }>>,
     marker: std::marker::PhantomData<V>,
 }
 
-impl<'a, N, V, D> TrieEdgeIter<'a, N, V, D>
+impl<'root, N, V, D> TrieEdgeIter<'root, N, V, D>
 where
-    N: TrieNode<V> + ?Sized,
-    V: AsRef<[u8]> + ?Sized,
+    N: TrieNode<'root, V>,
+    V: AsRef<[u8]> + ?Sized + 'root,
 {
     /// Creates a new iterator over the given key-value trie.
-    pub fn new(root: &'a N, root_hash: Option<&'a HashType>) -> Self {
+    pub fn new(root: N, root_hash: Option<&'root HashType>) -> Self {
         let mut this = Self {
             leading_path: PathBuf::new_const(),
             stack: Vec::new(),
@@ -74,15 +74,15 @@ where
 
     /// Transforms this iterator into an iterator over the key-value pairs in
     /// the trie.
-    pub const fn node_values(self) -> TrieValueIter<'a, N, V, D> {
+    pub const fn node_values(self) -> TrieValueIter<'root, N, V, D> {
         TrieValueIter { edges: self }
     }
 
     fn push_frame(
         &mut self,
         leading_component: Option<PathComponent>,
-        node: &'a N,
-        hash: Option<&'a HashType>,
+        node: N,
+        hash: Option<&'root HashType>,
     ) {
         let frame = Frame {
             node,
@@ -97,15 +97,15 @@ where
     }
 }
 
-impl<'a, P, N, V> TriePathIter<'a, P, N, V>
+impl<'root, P, N, V> TriePathIter<'root, P, N, V>
 where
     P: SplitPath,
-    N: TrieNode<V> + ?Sized,
-    V: AsRef<[u8]> + ?Sized,
+    N: TrieNode<'root, V>,
+    V: AsRef<[u8]> + ?Sized + 'root,
 {
     /// Creates a new iterator over the edges along the given path in the
     /// specified key-value trie.
-    pub const fn new(root: &'a N, root_hash: Option<&'a HashType>, path: P) -> Self {
+    pub const fn new(root: N, root_hash: Option<&'root HashType>, path: P) -> Self {
         let mut this = Self {
             needle: path,
             current_path: PathBuf::new_const(),
@@ -149,12 +149,12 @@ macro_rules! descend {
     };
 }
 
-impl<'a, N, V> Iterator for TrieEdgeIter<'a, N, V, IterAscending>
+impl<'root, N, V> Iterator for TrieEdgeIter<'root, N, V, IterAscending>
 where
-    N: TrieNode<V> + ?Sized,
-    V: AsRef<[u8]> + ?Sized,
+    N: TrieNode<'root, V>,
+    V: AsRef<[u8]> + ?Sized + 'root,
 {
-    type Item = (PathBuf, TrieEdgeState<'a, N>);
+    type Item = (PathBuf, TrieEdgeState<'root, N>);
 
     fn next(&mut self) -> Option<Self::Item> {
         while let Some(&mut Frame {
@@ -191,12 +191,12 @@ where
     }
 }
 
-impl<'a, N, V> Iterator for TrieEdgeIter<'a, N, V, IterDescending>
+impl<'root, N, V> Iterator for TrieEdgeIter<'root, N, V, IterDescending>
 where
-    N: TrieNode<V> + ?Sized,
-    V: AsRef<[u8]> + ?Sized,
+    N: TrieNode<'root, V>,
+    V: AsRef<[u8]> + ?Sized + 'root,
 {
-    type Item = (PathBuf, TrieEdgeState<'a, N>);
+    type Item = (PathBuf, TrieEdgeState<'root, N>);
 
     fn next(&mut self) -> Option<Self::Item> {
         while let Some(&mut Frame {
@@ -226,39 +226,39 @@ where
     }
 }
 
-impl<'a, N, V> Iterator for TrieValueIter<'a, N, V, IterAscending>
+impl<'root, N, V> Iterator for TrieValueIter<'root, N, V, IterAscending>
 where
-    N: TrieNode<V> + ?Sized,
-    V: AsRef<[u8]> + ?Sized + 'a,
+    N: TrieNode<'root, V>,
+    V: AsRef<[u8]> + ?Sized + 'root,
 {
-    type Item = (PathBuf, &'a V);
+    type Item = (PathBuf, &'root V);
 
     fn next(&mut self) -> Option<Self::Item> {
         self.edges
             .find_map(|(path, node)| node.value().map(|v| (path, v)))
     }
 }
 
-impl<'a, N, V> Iterator for TrieValueIter<'a, N, V, IterDescending>
+impl<'root, N, V> Iterator for TrieValueIter<'root, N, V, IterDescending>
 where
-    N: TrieNode<V> + ?Sized,
-    V: AsRef<[u8]> + ?Sized + 'a,
+    N: TrieNode<'root, V>,
+    V: AsRef<[u8]> + ?Sized + 'root,
 {
-    type Item = (PathBuf, &'a V);
+    type Item = (PathBuf, &'root V);
 
     fn next(&mut self) -> Option<Self::Item> {
         self.edges
             .find_map(|(path, node)| node.value().map(|v| (path, v)))
     }
 }
 
-impl<'a, P, N, V> Iterator for TriePathIter<'a, P, N, V>
+impl<'root, P, N, V> Iterator for TriePathIter<'root, P, N, V>
 where
     P: SplitPath,
-    N: TrieNode<V> + ?Sized,
-    V: AsRef<[u8]> + ?Sized,
+    N: TrieNode<'root, V>,
+    V: AsRef<[u8]> + ?Sized + 'root,
 {
-    type Item = (PathBuf, TrieEdgeState<'a, N>);
+    type Item = (PathBuf, TrieEdgeState<'root, N>);
 
     fn next(&mut self) -> Option<Self::Item> {
         // qualified path to `Option::take` because rust-analyzer thinks
@@ -293,7 +293,7 @@ where
 
 // auto-derived implementations would require N: Clone, V: Clone which is too much
 
-impl<N: ?Sized, V: ?Sized, D> Clone for TrieEdgeIter<'_, N, V, D> {
+impl<N: Copy, V: ?Sized, D> Clone for TrieEdgeIter<'_, N, V, D> {
     fn clone(&self) -> Self {
         Self {
             leading_path: self.leading_path.clone(),
@@ -308,7 +308,7 @@ impl<N: ?Sized, V: ?Sized, D> Clone for TrieEdgeIter<'_, N, V, D> {
     }
 }
 
-impl<N: ?Sized, V: ?Sized, D> Clone for TrieValueIter<'_, N, V, D> {
+impl<N: Copy, V: ?Sized, D> Clone for TrieValueIter<'_, N, V, D> {
     fn clone(&self) -> Self {
         Self {
             edges: self.edges.clone(),
@@ -320,7 +320,7 @@ impl<N: ?Sized, V: ?Sized, D> Clone for TrieValueIter<'_, N, V, D> {
     }
 }
 
-impl<P: SplitPath, N: ?Sized, V: ?Sized> Clone for TriePathIter<'_, P, N, V> {
+impl<P: Copy, N: Copy, V: ?Sized> Clone for TriePathIter<'_, P, N, V> {
     fn clone(&self) -> Self {
         Self {
             needle: self.needle,
@@ -337,7 +337,7 @@ impl<P: SplitPath, N: ?Sized, V: ?Sized> Clone for TriePathIter<'_, P, N, V> {
     }
 }
 
-impl<N: ?Sized, V: ?Sized> Clone for Frame<'_, N, V> {
+impl<N: Copy, V: ?Sized> Clone for Frame<'_, N, V> {
     fn clone(&self) -> Self {
         Self {
             node: self.node,

storage/src/tries/kvp.rs

@@ -275,67 +275,70 @@ impl<'a, T: AsRef<[u8]> + ?Sized> HashedKeyValueTrieRoot<'a, T> {
     }
 }
 
-impl<T: AsRef<[u8]> + ?Sized> TrieNode<T> for KeyValueTrieRoot<'_, T> {
-    type PartialPath<'a>
-        = PackedPathRef<'a>
-    where
-        Self: 'a;
+impl<'root, T> TrieNode<'root, T> for &'root KeyValueTrieRoot<'root, T>
+where
+    T: AsRef<[u8]> + ?Sized + 'root,
+{
+    type PartialPath = PackedPathRef<'root>;
 
-    fn partial_path(&self) -> Self::PartialPath<'_> {
+    fn partial_path(self) -> Self::PartialPath {
         self.partial_path
     }
 
-    fn value(&self) -> Option<&T> {
+    fn value(self) -> Option<&'root T> {
         self.value
     }
 
-    fn child_hash(&self, pc: PathComponent) -> Option<&HashType> {
+    fn child_hash(self, pc: PathComponent) -> Option<&'root HashType> {
         let _ = pc;
         None
     }
 
-    fn child_node(&self, pc: PathComponent) -> Option<&Self> {
+    fn child_node(self, pc: PathComponent) -> Option<Self> {
         self.children[pc].as_deref()
     }
 
-    fn child_state(&self, pc: PathComponent) -> Option<super::TrieEdgeState<'_, Self>> {
+    fn child_state(self, pc: PathComponent) -> Option<super::TrieEdgeState<'root, Self>> {
         self.children[pc]
             .as_deref()
             .map(|node| super::TrieEdgeState::UnhashedChild { node })
     }
 }
 
-impl<T: AsRef<[u8]> + ?Sized> TrieNode<T> for HashedKeyValueTrieRoot<'_, T> {
-    type PartialPath<'a>
-        = PackedPathRef<'a>
-    where
-        Self: 'a;
+impl<'root, T> TrieNode<'root, T> for &'root HashedKeyValueTrieRoot<'root, T>
+where
+    T: AsRef<[u8]> + ?Sized + 'root,
+{
+    type PartialPath = PackedPathRef<'root>;
 
-    fn partial_path(&self) -> Self::PartialPath<'_> {
+    fn partial_path(self) -> Self::PartialPath {
         self.partial_path
     }
 
-    fn value(&self) -> Option<&T> {
+    fn value(self) -> Option<&'root T> {
         self.value
     }
 
-    fn child_hash(&self, pc: PathComponent) -> Option<&HashType> {
+    fn child_hash(self, pc: PathComponent) -> Option<&'root HashType> {
         self.children[pc].as_deref().map(|c| &c.computed)
     }
 
-    fn child_node(&self, pc: PathComponent) -> Option<&Self> {
+    fn child_node(self, pc: PathComponent) -> Option<Self> {
         self.children[pc].as_deref()
     }
 
-    fn child_state(&self, pc: PathComponent) -> Option<super::TrieEdgeState<'_, Self>> {
+    fn child_state(self, pc: PathComponent) -> Option<super::TrieEdgeState<'root, Self>> {
         self.children[pc]
             .as_deref()
             .map(|node| super::TrieEdgeState::from_node(node, Some(&node.computed)))
     }
 }
 
-impl<T: AsRef<[u8]> + ?Sized> HashedTrieNode<T> for HashedKeyValueTrieRoot<'_, T> {
-    fn computed(&self) -> &HashType {
+impl<'root, T> HashedTrieNode<'root, T> for &'root HashedKeyValueTrieRoot<'root, T>
+where
+    T: AsRef<[u8]> + ?Sized + 'root,
+{
+    fn computed(self) -> &'root HashType {
         &self.computed
     }
 }