feat: define explicit associated types on Hashable

Author: demosdemon

firewood/src/proof.rs

@@ -108,17 +108,32 @@ impl std::fmt::Debug for ProofNode {
 }
 
 impl Hashable for ProofNode {
-    fn parent_prefix_path(&self) -> impl IntoSplitPath + '_ {
+    type LeadingPath<'a>
+        = &'a [PathComponent]
+    where
+        Self: 'a;
+
+    type PartialPath<'a>
+        = &'a [PathComponent]
+    where
+        Self: 'a;
+
+    type FullPath<'a>
+        = &'a [PathComponent]
+    where
+        Self: 'a;
+
+    fn parent_prefix_path(&self) -> Self::LeadingPath<'_> {
         let (prefix, _) = self.key.split_at(self.partial_len);
         prefix
     }
 
-    fn partial_path(&self) -> impl IntoSplitPath + '_ {
+    fn partial_path(&self) -> Self::PartialPath<'_> {
         let (_, suffix) = self.key.split_at(self.partial_len);
         suffix
     }
 
-    fn full_path(&self) -> impl IntoSplitPath + '_ {
+    fn full_path(&self) -> Self::FullPath<'_> {
         &self.key
     }
 

storage/src/hashednode.rs

@@ -3,7 +3,6 @@
 
 use crate::{
     Children, HashType, HashableShunt, IntoSplitPath, Node, Path, PathComponent, SplitPath,
-    TriePath,
 };
 use smallvec::SmallVec;
 
@@ -153,22 +152,32 @@ impl<T: AsRef<[u8]>> AsRef<[u8]> for ValueDigest<T> {
 
 /// A node in the trie that can be hashed.
 pub trait Hashable: std::fmt::Debug {
+    /// The type of the leading path.
+    type LeadingPath<'a>: IntoSplitPath + 'a
+    where
+        Self: 'a;
+
+    /// The type of the partial path.
+    type PartialPath<'a>: IntoSplitPath + 'a
+    where
+        Self: 'a;
+
+    /// The type of the full path.
+    type FullPath<'a>: IntoSplitPath + 'a
+    where
+        Self: 'a;
+
     /// The full path of this node's parent where each byte is a nibble.
-    fn parent_prefix_path(&self) -> impl IntoSplitPath + '_;
+    fn parent_prefix_path(&self) -> Self::LeadingPath<'_>;
     /// The partial path of this node where each byte is a nibble.
-    fn partial_path(&self) -> impl IntoSplitPath + '_;
+    fn partial_path(&self) -> Self::PartialPath<'_>;
+    /// The full path of this node including the parent's prefix where each byte is a nibble.
+    fn full_path(&self) -> Self::FullPath<'_>;
     /// The node's value or hash.
     fn value_digest(&self) -> Option<ValueDigest<&[u8]>>;
     /// Each element is a child's index and hash.
     /// Yields 0 elements if the node is a leaf.
     fn children(&self) -> Children<Option<HashType>>;
-
-    /// The full path of this node including the parent's prefix where each byte is a nibble.
-    fn full_path(&self) -> impl IntoSplitPath + '_ {
-        self.parent_prefix_path()
-            .into_split_path()
-            .append(self.partial_path().into_split_path())
-    }
 }
 
 /// A preimage of a hash.

storage/src/hashedshunt.rs

@@ -1,7 +1,7 @@
 // Copyright (C) 2025, Ava Labs, Inc. All rights reserved.
 // See the file LICENSE.md for licensing terms.
 
-use crate::{Children, HashType, Hashable, IntoSplitPath, SplitPath, ValueDigest};
+use crate::{Children, HashType, Hashable, JoinedPath, SplitPath, ValueDigest};
 
 /// A shunt for a hasheable trie that we can use to compute the hash of a node
 /// using component parts.
@@ -51,14 +51,33 @@ impl<P1: SplitPath, P2: SplitPath> std::fmt::Debug for HashableShunt<'_, P1, P2>
 }
 
 impl<P1: SplitPath, P2: SplitPath> Hashable for HashableShunt<'_, P1, P2> {
-    fn parent_prefix_path(&self) -> impl IntoSplitPath + '_ {
+    type LeadingPath<'a>
+        = P1
+    where
+        Self: 'a;
+
+    type PartialPath<'a>
+        = P2
+    where
+        Self: 'a;
+
+    type FullPath<'a>
+        = JoinedPath<P1, P2>
+    where
+        Self: 'a;
+
+    fn parent_prefix_path(&self) -> Self::LeadingPath<'_> {
         self.parent_prefix
     }
 
-    fn partial_path(&self) -> impl IntoSplitPath + '_ {
+    fn partial_path(&self) -> Self::PartialPath<'_> {
         self.partial_path
     }
 
+    fn full_path(&self) -> Self::FullPath<'_> {
+        self.parent_prefix_path().append(self.partial_path())
+    }
+
     fn value_digest(&self) -> Option<ValueDigest<&[u8]>> {
         self.value.clone()
     }

storage/src/tries/kvp.rs

@@ -4,8 +4,8 @@
 #[cfg(not(feature = "branch_factor_256"))]
 use crate::PackedPathRef;
 use crate::{
-    Children, HashType, Hashable, HashableShunt, HashedTrieNode, PathBuf, PathComponent, PathGuard,
-    SplitPath, TrieNode, TriePath, TriePathFromPackedBytes, ValueDigest,
+    Children, HashType, Hashable, HashableShunt, HashedTrieNode, JoinedPath, PathBuf,
+    PathComponent, PathGuard, SplitPath, TrieNode, TriePath, TriePathFromPackedBytes, ValueDigest,
 };
 
 #[cfg(feature = "branch_factor_256")]
@@ -280,7 +280,12 @@ impl<'a, T: AsRef<[u8]> + ?Sized> HashedKeyValueTrieRoot<'a, T> {
 }
 
 impl<T: AsRef<[u8]> + ?Sized> TrieNode<T> for KeyValueTrieRoot<'_, T> {
-    fn partial_path(&self) -> impl SplitPath + '_ {
+    type PartialPath<'a>
+        = PackedPathRef<'a>
+    where
+        Self: 'a;
+
+    fn partial_path(&self) -> Self::PartialPath<'_> {
         self.partial_path
     }
 
@@ -305,7 +310,12 @@ impl<T: AsRef<[u8]> + ?Sized> TrieNode<T> for KeyValueTrieRoot<'_, T> {
 }
 
 impl<T: AsRef<[u8]> + ?Sized> TrieNode<T> for HashedKeyValueTrieRoot<'_, T> {
-    fn partial_path(&self) -> impl SplitPath + '_ {
+    type PartialPath<'a>
+        = PackedPathRef<'a>
+    where
+        Self: 'a;
+
+    fn partial_path(&self) -> Self::PartialPath<'_> {
         self.partial_path
     }
 
@@ -334,15 +344,34 @@ impl<T: AsRef<[u8]> + ?Sized> HashedTrieNode<T> for HashedKeyValueTrieRoot<'_, T
     }
 }
 
-impl<T: AsRef<[u8]> + ?Sized> Hashable for HashedKeyValueTrieRoot<'_, T> {
-    fn parent_prefix_path(&self) -> impl crate::IntoSplitPath + '_ {
-        self.leading_path.as_slice()
+impl<'a, T: AsRef<[u8]> + ?Sized> Hashable for HashedKeyValueTrieRoot<'a, T> {
+    type LeadingPath<'b>
+        = &'b [PathComponent]
+    where
+        Self: 'b;
+
+    type PartialPath<'b>
+        = PackedPathRef<'a>
+    where
+        Self: 'b;
+
+    type FullPath<'b>
+        = JoinedPath<&'b [PathComponent], PackedPathRef<'a>>
+    where
+        Self: 'b;
+
+    fn parent_prefix_path(&self) -> Self::LeadingPath<'_> {
+        &self.leading_path
     }
 
-    fn partial_path(&self) -> impl crate::IntoSplitPath + '_ {
+    fn partial_path(&self) -> Self::PartialPath<'_> {
         self.partial_path
     }
 
+    fn full_path(&self) -> Self::FullPath<'_> {
+        self.parent_prefix_path().append(self.partial_path)
+    }
+
     fn value_digest(&self) -> Option<ValueDigest<&[u8]>> {
         self.value.map(|v| ValueDigest::Value(v.as_ref()))
     }

storage/src/tries/mod.rs

@@ -4,7 +4,7 @@
 mod iter;
 mod kvp;
 
-use crate::{HashType, PathComponent, SplitPath};
+use crate::{HashType, IntoSplitPath, PathComponent};
 
 pub use self::iter::{IterAscending, IterDescending, TrieEdgeIter, TrieValueIter};
 pub use self::kvp::{DuplicateKeyError, HashedKeyValueTrieRoot, KeyValueTrieRoot};
@@ -38,8 +38,13 @@ pub enum TrieEdgeState<'a, N: ?Sized> {
 
 /// A node in a fixed-arity radix trie.
 pub trait TrieNode<V: AsRef<[u8]> + ?Sized> {
+    /// The type of path from this node's parent to this node.
+    type PartialPath<'a>: IntoSplitPath + 'a
+    where
+        Self: 'a;
+
     /// The path from this node's parent to this node.
-    fn partial_path(&self) -> impl SplitPath + '_;
+    fn partial_path(&self) -> Self::PartialPath<'_>;
 
     /// The value stored at this node, if any.
     fn value(&self) -> Option<&V>;