fix clippy

core/src/bank_forks.rs

@@ -47,6 +47,7 @@ impl BankForks {
     }
 
     /// Create a map of bank slot id to the set of all of its descendants
+    #[allow(clippy::or_fun_call)]
     pub fn descendants(&self) -> HashMap<u64, HashSet<u64>> {
         let mut descendants = HashMap::new();
         for bank in self.banks.values() {
@@ -214,8 +215,8 @@ mod tests {
         let bank = Bank::new_from_parent(&bank0, &Pubkey::default(), 2);
         bank_forks.insert(bank);
         let descendants = bank_forks.descendants();
-        let children: Vec<u64> = descendants[&0].iter().cloned().collect();
-        assert_eq!(children, vec![2, 1]);
+        let children: HashSet<u64> = [1u64, 2u64].to_vec().into_iter().collect();
+        assert_eq!(children, *descendants.get(&0).unwrap());
         assert!(descendants[&1].is_empty());
         assert!(descendants[&2].is_empty());
     }

core/src/replay_stage.rs

@@ -492,7 +492,7 @@ impl ReplayStage {
         let bank_slot = bank.slot();
         let bank_progress = &mut progress
             .entry(bank_slot)
-            .or_insert(ForkProgress::new(bank.last_blockhash()));
+            .or_insert_with(|| ForkProgress::new(bank.last_blockhash()));
         blocktree.get_slot_entries_with_blob_count(bank_slot, bank_progress.num_blobs as u64, None)
     }
 
@@ -505,7 +505,7 @@ impl ReplayStage {
     ) -> Result<()> {
         let bank_progress = &mut progress
             .entry(bank.slot())
-            .or_insert(ForkProgress::new(bank.last_blockhash()));
+            .or_insert_with(|| ForkProgress::new(bank.last_blockhash()));
         let result = Self::verify_and_process_entries(&bank, &entries, &bank_progress.last_entry);
         bank_progress.num_blobs += num;
         if let Some(last_entry) = entries.last() {

runtime/src/accounts.rs

@@ -451,7 +451,7 @@ mod tests {
 
     use super::*;
     use bincode::{deserialize_from, serialize_into, serialized_size};
-    use rand::{Rng, thread_rng};
+    use rand::{thread_rng, Rng};
     use solana_sdk::account::Account;
     use solana_sdk::hash::Hash;
     use solana_sdk::instruction::CompiledInstruction;

runtime/src/accounts_index.rs

@@ -1,6 +1,6 @@
 use log::*;
-use solana_sdk::pubkey::Pubkey;
 use serde::{Deserialize, Serialize};
+use solana_sdk::pubkey::Pubkey;
 use std::collections::{HashMap, HashSet};
 
 pub type Fork = u64;
@@ -36,7 +36,7 @@ impl<T: Clone> AccountsIndex<T> {
         let mut rv = vec![];
         let mut fork_vec: Vec<(Fork, T)> = vec![];
         {
-            let entry = self.account_maps.entry(*pubkey).or_insert(vec![]);
+            let entry = self.account_maps.entry(*pubkey).or_insert_with(|| vec![]);
             std::mem::swap(entry, &mut fork_vec);
         };
 
@@ -55,7 +55,7 @@ impl<T: Clone> AccountsIndex<T> {
         );
         fork_vec.retain(|(fork, _)| !self.is_purged(*fork));
         {
-            let entry = self.account_maps.entry(*pubkey).or_insert(vec![]);
+            let entry = self.account_maps.entry(*pubkey).or_insert_with(|| vec![]);
             std::mem::swap(entry, &mut fork_vec);
         };
         rv

runtime/src/append_vec.rs

@@ -61,6 +61,7 @@ impl<'a> StoredAccount<'a> {
 }
 
 #[derive(Debug)]
+#[allow(clippy::mutex_atomic)]
 pub struct AppendVec {
     path: PathBuf,
     map: MmapMut,
@@ -291,11 +292,8 @@ impl Serialize for AppendVec {
         let mut buf = vec![0u8; len as usize];
         let mut wr = Cursor::new(&mut buf[..]);
         serialize_into(&mut wr, &self.path).map_err(Error::custom)?;
-        serialize_into(
-            &mut wr,
-            &(self.current_len.load(Ordering::Relaxed) as u64),
-        )
-        .map_err(Error::custom)?;
+        serialize_into(&mut wr, &(self.current_len.load(Ordering::Relaxed) as u64))
+            .map_err(Error::custom)?;
         serialize_into(&mut wr, &self.file_size).map_err(Error::custom)?;
         let len = wr.position() as usize;
         serializer.serialize_bytes(&wr.into_inner()[..len])
@@ -311,6 +309,7 @@ impl<'a> serde::de::Visitor<'a> for AppendVecVisitor {
         formatter.write_str("Expecting AppendVec")
     }
 
+    #[allow(clippy::mutex_atomic)]
     fn visit_bytes<E>(self, data: &[u8]) -> std::result::Result<Self::Value, E>
     where
         E: serde::de::Error,
@@ -422,7 +421,7 @@ pub mod tests {
     fn test_append_vec_serialize() {
         let path = Path::new("append_vec_serialize");
         let av: AppendVec = AppendVec::new(path, true, 1024 * 1024);
-        let account1 = create_test_account(1); 
+        let account1 = create_test_account(1);
         let index1 = av.append_account_test(&account1).unwrap();
         assert_eq!(index1, 0);
         assert_eq!(av.get_account_test(index1).unwrap(), account1);

runtime/src/status_cache.rs

@@ -84,7 +84,7 @@ impl<T: Clone> StatusCache<T> {
             .entry(*transaction_blockhash)
             .or_insert((fork, HashMap::new()));
         sig_map.0 = std::cmp::max(fork, sig_map.0);
-        let sig_forks = sig_map.1.entry(*sig).or_insert(vec![]);
+        let sig_forks = sig_map.1.entry(*sig).or_insert_with(|| vec![]);
         sig_forks.push((fork, res));
     }