chore: clippy (#5)

src/hash_builder/mod.rs

@@ -5,11 +5,13 @@ use super::{
     BranchNodeCompact, Nibbles, TrieMask, EMPTY_ROOT_HASH,
 };
 use crate::HashMap;
-use alloc::{collections::BTreeMap, vec::Vec};
 use alloy_primitives::{keccak256, Bytes, B256};
 use core::cmp;
 use tracing::trace;
 
+#[allow(unused_imports)]
+use alloc::{collections::BTreeMap, vec::Vec};
+
 mod value;
 pub use value::HashBuilderValue;
 
@@ -417,9 +419,7 @@ impl HashBuilder {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::HashMap;
-    use alloc::collections::BTreeMap;
-    use alloy_primitives::{b256, hex, keccak256, B256, U256};
+    use alloy_primitives::{b256, hex, U256};
     use alloy_rlp::Encodable;
 
     fn triehash_trie_root<I, K, V>(iter: I) -> B256

src/hash_builder/proof_retainer.rs

@@ -1,7 +1,9 @@
 use crate::Nibbles;
-use alloc::{collections::BTreeMap, vec::Vec};
 use alloy_primitives::Bytes;
 
+#[allow(unused_imports)]
+use alloc::{collections::BTreeMap, vec::Vec};
+
 /// Proof retainer is used to store proofs during merkle trie construction.
 /// It is intended to be used within the [`HashBuilder`](crate::HashBuilder).
 #[derive(Debug)]

src/hash_builder/value.rs

@@ -1,7 +1,9 @@
-use alloc::vec::Vec;
 use alloy_primitives::B256;
 use core::fmt;
 
+#[allow(unused_imports)]
+use alloc::vec::Vec;
+
 /// The current value of the hash builder.
 #[derive(Clone, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]

src/lib.rs

@@ -11,7 +11,8 @@
     clippy::missing_const_for_fn,
     rustdoc::all
 )]
-#![cfg_attr(not(test), warn(unused_crate_dependencies))]
+#![cfg_attr(not(test), warn(unused_crate_dependencies))] // TODO: https://github.com/proptest-rs/proptest/pull/427
+#![allow(unknown_lints, non_local_definitions)]
 #![deny(unused_must_use, rust_2018_idioms)]
 #![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
 #![cfg_attr(not(feature = "std"), no_std)]

src/nodes/branch.rs

@@ -1,8 +1,10 @@
 use super::{super::TrieMask, rlp_node, CHILD_INDEX_RANGE};
-use alloc::vec::Vec;
 use alloy_primitives::B256;
 use alloy_rlp::{BufMut, EMPTY_STRING_CODE};
 
+#[allow(unused_imports)]
+use alloc::{collections::BTreeMap, vec::Vec};
+
 /// A Branch node is only a pointer to the stack of nodes and is used to
 /// create the RLP encoding of the node using masks which filter from
 /// the stack of nodes.

src/nodes/extension.rs

@@ -1,9 +1,11 @@
 use super::{super::Nibbles, rlp_node};
-use alloc::vec::Vec;
 use alloy_rlp::{BufMut, Encodable};
 use core::fmt;
 use smallvec::SmallVec;
 
+#[allow(unused_imports)]
+use alloc::{collections::BTreeMap, vec::Vec};
+
 /// An intermediate node that exists solely to compress the trie's paths. It contains a path segment
 /// (a shared prefix of keys) and a single child pointer. Essentially, an extension node can be
 /// thought of as a shortcut within the trie to reduce its overall depth.

src/nodes/leaf.rs

@@ -1,9 +1,10 @@
 use super::{super::Nibbles, rlp_node};
-use alloc::vec::Vec;
 use alloy_rlp::{BufMut, Encodable};
+use core::fmt;
 use smallvec::SmallVec;
 
-use core::fmt;
+#[allow(unused_imports)]
+use alloc::vec::Vec;
 
 /// A leaf node represents the endpoint or terminal node in the trie. In other words, a leaf node is
 /// where actual values are stored.

src/nodes/mod.rs

@@ -1,10 +1,12 @@
 //! Various branch nodes produced by the hash builder.
 
-use alloc::vec::Vec;
 use alloy_primitives::{keccak256, B256};
 use alloy_rlp::EMPTY_STRING_CODE;
 use core::ops::Range;
 
+#[allow(unused_imports)]
+use alloc::vec::Vec;
+
 mod branch;
 pub use branch::{BranchNode, BranchNodeCompact};