Remove redundant type param fom CachedTreeHash

eth2/types/src/slot_epoch_macros.rs

@@ -224,7 +224,7 @@ macro_rules! impl_ssz {
             }
         }
 
-        impl cached_tree_hash::CachedTreeHash<$type> for $type {
+        impl cached_tree_hash::CachedTreeHash for $type {
             fn new_tree_hash_cache(
                 &self,
                 depth: usize,

eth2/types/src/tree_hash_vector.rs

@@ -55,9 +55,9 @@ where
     }
 }
 
-impl<T> CachedTreeHash<TreeHashVector<T>> for TreeHashVector<T>
+impl<T> CachedTreeHash for TreeHashVector<T>
 where
-    T: CachedTreeHash<T> + TreeHash,
+    T: CachedTreeHash + TreeHash,
 {
     fn new_tree_hash_cache(
         &self,

eth2/utils/cached_tree_hash/src/btree_overlay.rs

@@ -42,7 +42,7 @@ pub struct BTreeOverlay {
 impl BTreeOverlay {
     pub fn new<T>(item: &T, initial_offset: usize, depth: usize) -> Self
     where
-        T: CachedTreeHash<T>,
+        T: CachedTreeHash,
     {
         Self::from_schema(item.tree_hash_cache_schema(depth), initial_offset)
     }

eth2/utils/cached_tree_hash/src/impls.rs

@@ -6,7 +6,7 @@ pub mod vec;
 
 macro_rules! impl_for_single_leaf_int {
     ($type: ident) => {
-        impl CachedTreeHash<$type> for $type {
+        impl CachedTreeHash for $type {
             fn new_tree_hash_cache(&self, _depth: usize) -> Result<TreeHashCache, Error> {
                 Ok(TreeHashCache::from_bytes(
                     merkleize(self.to_le_bytes().to_vec()),
@@ -37,7 +37,7 @@ impl_for_single_leaf_int!(u32);
 impl_for_single_leaf_int!(u64);
 impl_for_single_leaf_int!(usize);
 
-impl CachedTreeHash<bool> for bool {
+impl CachedTreeHash for bool {
     fn new_tree_hash_cache(&self, _depth: usize) -> Result<TreeHashCache, Error> {
         Ok(TreeHashCache::from_bytes(
             merkleize((*self as u8).to_le_bytes().to_vec()),
@@ -60,7 +60,7 @@ impl CachedTreeHash<bool> for bool {
     }
 }
 
-impl CachedTreeHash<[u8; 4]> for [u8; 4] {
+impl CachedTreeHash for [u8; 4] {
     fn new_tree_hash_cache(&self, _depth: usize) -> Result<TreeHashCache, Error> {
         Ok(TreeHashCache::from_bytes(
             merkleize(self.to_vec()),
@@ -83,7 +83,7 @@ impl CachedTreeHash<[u8; 4]> for [u8; 4] {
     }
 }
 
-impl CachedTreeHash<H256> for H256 {
+impl CachedTreeHash for H256 {
     fn new_tree_hash_cache(&self, _depth: usize) -> Result<TreeHashCache, Error> {
         Ok(TreeHashCache::from_bytes(
             self.as_bytes().to_vec(),

eth2/utils/cached_tree_hash/src/impls/vec.rs

@@ -2,9 +2,9 @@ use super::*;
 use crate::btree_overlay::LeafNode;
 use crate::merkleize::{merkleize, num_sanitized_leaves, sanitise_bytes};
 
-impl<T> CachedTreeHash<Vec<T>> for Vec<T>
+impl<T> CachedTreeHash for Vec<T>
 where
-    T: CachedTreeHash<T> + TreeHash,
+    T: CachedTreeHash + TreeHash,
 {
     fn new_tree_hash_cache(&self, depth: usize) -> Result<TreeHashCache, Error> {
         let (mut cache, schema) = new_tree_hash_cache(self, depth)?;
@@ -40,7 +40,7 @@ where
     }
 }
 
-pub fn new_tree_hash_cache<T: CachedTreeHash<T>>(
+pub fn new_tree_hash_cache<T: CachedTreeHash>(
     vec: &Vec<T>,
     depth: usize,
 ) -> Result<(TreeHashCache, BTreeSchema), Error> {
@@ -65,7 +65,7 @@ pub fn new_tree_hash_cache<T: CachedTreeHash<T>>(
     Ok((cache, schema))
 }
 
-pub fn produce_schema<T: CachedTreeHash<T>>(vec: &Vec<T>, depth: usize) -> BTreeSchema {
+pub fn produce_schema<T: CachedTreeHash>(vec: &Vec<T>, depth: usize) -> BTreeSchema {
     let lengths = match T::tree_hash_type() {
         TreeHashType::Basic => {
             // Ceil division.
@@ -89,7 +89,7 @@ pub fn produce_schema<T: CachedTreeHash<T>>(vec: &Vec<T>, depth: usize) -> BTree
     BTreeSchema::from_lengths(depth, lengths)
 }
 
-pub fn update_tree_hash_cache<T: CachedTreeHash<T>>(
+pub fn update_tree_hash_cache<T: CachedTreeHash>(
     vec: &Vec<T>,
     cache: &mut TreeHashCache,
 ) -> Result<BTreeOverlay, Error> {
@@ -273,7 +273,7 @@ fn splice_in_new_tree<T>(
     cache: &mut TreeHashCache,
 ) -> Result<(), Error>
 where
-    T: CachedTreeHash<T>,
+    T: CachedTreeHash,
 {
     let (bytes, mut bools, schemas) = TreeHashCache::new(item, depth)?.into_components();
 
@@ -296,7 +296,7 @@ where
 
 fn get_packed_leaves<T>(vec: &Vec<T>) -> Result<Vec<u8>, Error>
 where
-    T: CachedTreeHash<T>,
+    T: CachedTreeHash,
 {
     let num_packed_bytes = (BYTES_PER_CHUNK / T::tree_hash_packing_factor()) * vec.len();
     let num_leaves = num_sanitized_leaves(num_packed_bytes);

eth2/utils/cached_tree_hash/src/lib.rs

@@ -1,5 +1,4 @@
 use hashing::hash;
-use merkleize::num_unsanitized_leaves;
 use std::ops::Range;
 use tree_hash::{TreeHash, TreeHashType, BYTES_PER_CHUNK, HASHSIZE};
 
@@ -14,7 +13,7 @@ pub use btree_overlay::{BTreeOverlay, BTreeSchema};
 pub use errors::Error;
 pub use tree_hash_cache::TreeHashCache;
 
-pub trait CachedTreeHash<Item>: TreeHash {
+pub trait CachedTreeHash: TreeHash {
     fn tree_hash_cache_schema(&self, depth: usize) -> BTreeSchema;
 
     fn num_tree_hash_cache_chunks(&self) -> usize {
@@ -34,7 +33,7 @@ pub struct CachedTreeHasher {
 impl CachedTreeHasher {
     pub fn new<T>(item: &T) -> Result<Self, Error>
     where
-        T: CachedTreeHash<T>,
+        T: CachedTreeHash,
     {
         Ok(Self {
             cache: TreeHashCache::new(item, 0)?,
@@ -43,7 +42,7 @@ impl CachedTreeHasher {
 
     pub fn update<T>(&mut self, item: &T) -> Result<(), Error>
     where
-        T: CachedTreeHash<T>,
+        T: CachedTreeHash,
     {
         self.cache.update(item)
     }
@@ -57,7 +56,7 @@ impl CachedTreeHasher {
 #[macro_export]
 macro_rules! cached_tree_hash_ssz_encoding_as_vector {
     ($type: ident, $num_bytes: expr) => {
-        impl cached_tree_hash::CachedTreeHash<$type> for $type {
+        impl cached_tree_hash::CachedTreeHash for $type {
             fn new_tree_hash_cache(
                 &self,
                 depth: usize,
@@ -94,7 +93,7 @@ macro_rules! cached_tree_hash_ssz_encoding_as_vector {
 #[macro_export]
 macro_rules! cached_tree_hash_bytes_as_list {
     ($type: ident) => {
-        impl cached_tree_hash::CachedTreeHash<$type> for $type {
+        impl cached_tree_hash::CachedTreeHash for $type {
             fn new_tree_hash_cache(
                 &self,
                 depth: usize,

eth2/utils/cached_tree_hash/src/tree_hash_cache.rs

@@ -33,14 +33,14 @@ impl Into<Vec<u8>> for TreeHashCache {
 impl TreeHashCache {
     pub fn new<T>(item: &T, depth: usize) -> Result<Self, Error>
     where
-        T: CachedTreeHash<T>,
+        T: CachedTreeHash,
     {
         item.new_tree_hash_cache(depth)
     }
 
     pub fn update<T>(&mut self, item: &T) -> Result<(), Error>
     where
-        T: CachedTreeHash<T>,
+        T: CachedTreeHash,
     {
         if self.is_empty() {
             Err(Error::CacheNotInitialized)
@@ -62,7 +62,7 @@ impl TreeHashCache {
         depth: usize,
     ) -> Result<Self, Error>
     where
-        T: CachedTreeHash<T>,
+        T: CachedTreeHash,
     {
         let overlay = BTreeOverlay::new(item, 0, depth);
 

eth2/utils/cached_tree_hash/tests/tests.rs

@@ -34,7 +34,7 @@ pub struct NestedStruct {
 
 fn test_routine<T>(original: T, modified: Vec<T>)
 where
-    T: CachedTreeHash<T> + std::fmt::Debug,
+    T: CachedTreeHash + std::fmt::Debug,
 {
     let mut hasher = CachedTreeHasher::new(&original).unwrap();
 

eth2/utils/tree_hash_derive/src/lib.rs

@@ -56,7 +56,7 @@ pub fn subtree_derive(input: TokenStream) -> TokenStream {
     let idents_c = idents_a.clone();
 
     let output = quote! {
-        impl cached_tree_hash::CachedTreeHash<#name> for #name {
+        impl cached_tree_hash::CachedTreeHash for #name {
             fn new_tree_hash_cache(&self, depth: usize) -> Result<cached_tree_hash::TreeHashCache, cached_tree_hash::Error> {
                 let tree = cached_tree_hash::TreeHashCache::from_leaves_and_subtrees(
                     self,

eth2/utils/tree_hash_derive/tests/tests.rs

@@ -10,10 +10,7 @@ pub struct Inner {
     pub d: u64,
 }
 
-fn test_standard_and_cached<T>(original: &T, modified: &T)
+fn test_standard_and_cached<T: CachedTreeHash>(original: &T, modified: &T) {
-where
-    T: CachedTreeHash<T>,
-{
     // let mut cache = original.new_tree_hash_cache().unwrap();
     let mut hasher = CachedTreeHasher::new(original).unwrap();