Clippy clean (#536)

* Change into_iter to iter

* Fix clippy 'easy' warnings

* Clippy eth2/utils

* Add struct NetworkInfo

* Clippy for types, utils, and beacon_node/store/src/iters.rs

* Cargo fmt

* Change foo to my_foo

* Remove complex signature

* suppress clippy warning for unit_value in benches

* Use enumerate instead of iterating over range

* Allow trivially_copy_pass_by_ref in serde_utils

eth2/utils/bls/src/secret_key.rs

@@ -80,8 +80,7 @@ mod tests {
     #[test]
     pub fn test_ssz_round_trip() {
         let original =
-            SecretKey::from_bytes("jzjxxgjajfjrmgodszzsgqccmhnyvetcuxobhtynojtpdtbj".as_bytes())
-                .unwrap();
+            SecretKey::from_bytes(b"jzjxxgjajfjrmgodszzsgqccmhnyvetcuxobhtynojtpdtbj").unwrap();
 
         let bytes = ssz_encode(&original);
         let decoded = SecretKey::from_ssz_bytes(&bytes).unwrap();

eth2/utils/eth2_interop_keypairs/src/lib.rs

@@ -58,10 +58,12 @@ pub fn be_private_key(validator_index: usize) -> [u8; PRIVATE_KEY_BYTES] {
 
 /// Return a public and private keypair for a given `validator_index`.
 pub fn keypair(validator_index: usize) -> Keypair {
-    let sk = SecretKey::from_bytes(&be_private_key(validator_index)).expect(&format!(
-        "Should build valid private key for validator index {}",
-        validator_index
-    ));
+    let sk = SecretKey::from_bytes(&be_private_key(validator_index)).unwrap_or_else(|_| {
+        panic!(
+            "Should build valid private key for validator index {}",
+            validator_index
+        )
+    });
 
     Keypair {
         pk: PublicKey::from_secret_key(&sk),

eth2/utils/eth2_interop_keypairs/tests/generation.rs

@@ -19,14 +19,11 @@ fn reference_private_keys() {
         "2908643403277969554503670470854573663206729491025062456164283925661321952518",
         "19554639423851580804889717218680781396599791537051606512605582393920758869044",
     ];
-    reference
-        .into_iter()
-        .enumerate()
-        .for_each(|(i, reference)| {
-            let bytes = be_private_key(i);
-            let num = BigUint::from_bytes_be(&bytes);
-            assert_eq!(&num.to_str_radix(10), reference)
-        });
+    reference.iter().enumerate().for_each(|(i, reference)| {
+        let bytes = be_private_key(i);
+        let num = BigUint::from_bytes_be(&bytes);
+        assert_eq!(&num.to_str_radix(10), reference)
+    });
 }
 
 #[test]
@@ -46,19 +43,16 @@ fn reference_public_keys() {
         "ptMQ27+rmiJFD1mZP4ekzl22Ij87Xx8w0sTscYki1ADgs8d0HejlmWD3JBGg7hCn",
         "mJNBPAAoOj+e2f2YRd2hzqOCKNIlZ/lUHczDV+VKLWpuIEEDySVky8BfSQWsfEk6",
     ];
-    reference
-        .into_iter()
-        .enumerate()
-        .for_each(|(i, reference)| {
-            let pair = keypair(i);
-            let reference = base64::decode(reference).expect("Reference should be valid base64");
+    reference.iter().enumerate().for_each(|(i, reference)| {
+        let pair = keypair(i);
+        let reference = base64::decode(reference).expect("Reference should be valid base64");
 
-            assert_eq!(
-                reference.len(),
-                48,
-                "Reference should be 48 bytes (public key size)"
-            );
+        assert_eq!(
+            reference.len(),
+            48,
+            "Reference should be 48 bytes (public key size)"
+        );
 
-            assert_eq!(pair.pk.as_bytes(), reference);
-        });
+        assert_eq!(pair.pk.as_bytes(), reference);
+    });
 }

eth2/utils/lighthouse_metrics/src/lib.rs

@@ -100,7 +100,9 @@ pub fn start_timer(histogram: &Result<Histogram>) -> Option<HistogramTimer> {
 
 /// Stops a timer created with `start_timer(..)`.
 pub fn stop_timer(timer: Option<HistogramTimer>) {
-    timer.map(|t| t.observe_duration());
+    if let Some(t) = timer {
+        t.observe_duration()
+    }
 }
 
 pub fn inc_counter(counter: &Result<IntCounter>) {

eth2/utils/merkle_proof/src/lib.rs

@@ -21,7 +21,7 @@ lazy_static! {
 
     /// Zero nodes to act as "synthetic" left and right subtrees of other zero nodes.
     static ref ZERO_NODES: Vec<MerkleTree> = {
-        (0..MAX_TREE_DEPTH + 1).map(MerkleTree::Zero).collect()
+        (0..=MAX_TREE_DEPTH).map(MerkleTree::Zero).collect()
     };
 }
 
@@ -205,7 +205,7 @@ mod tests {
         let merkle_tree = MerkleTree::create(&leaves, depth);
         let merkle_root = merkle_tree.hash();
 
-        let proofs_ok = (0..leaves.len()).into_iter().all(|i| {
+        let proofs_ok = (0..leaves.len()).all(|i| {
             let (leaf, branch) = merkle_tree.generate_proof(i, depth);
             leaf == leaves[i] && verify_merkle_proof(leaf, &branch, depth, i, merkle_root)
         });

eth2/utils/ssz/examples/large_list.rs

@@ -8,7 +8,6 @@ fn main() {
     let vec: Vec<u64> = vec![4242; 8196];
 
     let output: Vec<Vec<u64>> = (0..40_000)
-        .into_iter()
         .map(|_| Vec::from_ssz_bytes(&vec.as_ssz_bytes()).unwrap())
         .collect();
 

eth2/utils/ssz/examples/large_list_of_structs.rs

@@ -24,7 +24,6 @@ fn main() {
     let vec: Vec<FixedLen> = vec![fixed_len; 8196];
 
     let output: Vec<Vec<u64>> = (0..40_000)
-        .into_iter()
         .map(|_| Vec::from_ssz_bytes(&vec.as_ssz_bytes()).unwrap())
         .collect();
 

eth2/utils/ssz/examples/struct_definition.rs

@@ -57,7 +57,7 @@ impl Decode for Foo {
 }
 
 fn main() {
-    let foo = Foo {
+    let my_foo = Foo {
         a: 42,
         b: vec![0, 1, 2, 3],
         c: 11,
@@ -65,9 +65,9 @@ fn main() {
 
     let bytes = vec![42, 0, 8, 0, 0, 0, 11, 0, 0, 1, 2, 3];
 
-    assert_eq!(foo.as_ssz_bytes(), bytes);
+    assert_eq!(my_foo.as_ssz_bytes(), bytes);
 
     let decoded_foo = Foo::from_ssz_bytes(&bytes).unwrap();
 
-    assert_eq!(foo, decoded_foo);
+    assert_eq!(my_foo, decoded_foo);
 }

eth2/utils/ssz/src/encode/impls.rs

@@ -239,7 +239,7 @@ impl<T: Encode> Encode for Vec<T> {
         if <T as Encode>::is_ssz_fixed_len() {
             <T as Encode>::ssz_fixed_len() * self.len()
         } else {
-            let mut len = self.into_iter().map(|item| item.ssz_bytes_len()).sum();
+            let mut len = self.iter().map(|item| item.ssz_bytes_len()).sum();
             len += BYTES_PER_LENGTH_OFFSET * self.len();
             len
         }