Pacify clippy

account-decoder/src/lib.rs

@@ -136,16 +136,13 @@ impl UiAccount {
             UiAccountData::Binary(blob, encoding) => match encoding {
                 UiAccountEncoding::Base58 => bs58::decode(blob).into_vec().ok(),
                 UiAccountEncoding::Base64 => base64::decode(blob).ok(),
-                UiAccountEncoding::Base64Zstd => base64::decode(blob)
-                    .ok()
-                    .map(|zstd_data| {
-                        let mut data = vec![];
-                        zstd::stream::read::Decoder::new(zstd_data.as_slice())
-                            .and_then(|mut reader| reader.read_to_end(&mut data))
-                            .map(|_| data)
-                            .ok()
-                    })
-                    .flatten(),
+                UiAccountEncoding::Base64Zstd => base64::decode(blob).ok().and_then(|zstd_data| {
+                    let mut data = vec![];
+                    zstd::stream::read::Decoder::new(zstd_data.as_slice())
+                        .and_then(|mut reader| reader.read_to_end(&mut data))
+                        .map(|_| data)
+                        .ok()
+                }),
                 UiAccountEncoding::Binary | UiAccountEncoding::JsonParsed => None,
             },
         }?;

accounts-cluster-bench/src/main.rs

@@ -116,7 +116,7 @@ fn make_create_message(
 
     let instructions: Vec<_> = (0..num_instructions)
         .into_iter()
-        .map(|_| {
+        .flat_map(|_| {
             let program_id = if mint.is_some() {
                 inline_spl_token::id()
             } else {
@@ -148,7 +148,6 @@ fn make_create_message(
 
             instructions
         })
-        .flatten()
         .collect();
 
     Message::new(&instructions, Some(&keypair.pubkey()))

clap-utils/src/input_validators.rs

@@ -328,7 +328,7 @@ pub fn is_derivation<T>(value: T) -> Result<(), String>
 where
     T: AsRef<str> + Display,
 {
-    let value = value.as_ref().replace("'", "");
+    let value = value.as_ref().replace('\'', "");
     let mut parts = value.split('/');
     let account = parts.next().unwrap();
     account

cli-output/src/cli_output.rs

@@ -2285,6 +2285,7 @@ impl fmt::Display for CliBlock {
                 let sign = if reward.lamports < 0 { "-" } else { "" };
 
                 total_rewards += reward.lamports;
+                #[allow(clippy::format_in_format_args)]
                 writeln!(
                     f,
                     "  {:<44}  {:^15}  {:>15}  {}  {}",

cli/tests/program.rs

@@ -78,7 +78,7 @@ fn test_cli_program_deploy_non_upgradeable() {
     assert_eq!(account0.lamports, minimum_balance_for_rent_exemption);
     assert_eq!(account0.owner, bpf_loader::id());
     assert!(account0.executable);
-    let mut file = File::open(noop_path.to_str().unwrap().to_string()).unwrap();
+    let mut file = File::open(noop_path.to_str().unwrap()).unwrap();
     let mut elf = Vec::new();
     file.read_to_end(&mut elf).unwrap();
     assert_eq!(account0.data, elf);

client/src/mock_sender.rs

@@ -435,7 +435,7 @@ impl RpcSender for MockSender {
                 value: vec![Value::Null, Value::Null]
             })?,
             "getProgramAccounts" => {
-                let pubkey = Pubkey::from_str(&PUBKEY.to_string()).unwrap();
+                let pubkey = Pubkey::from_str(PUBKEY).unwrap();
                 let account = Account {
                     lamports: 1_000_000,
                     data: vec![],

client/src/perf_utils.rs

@@ -43,18 +43,16 @@ pub fn sample_txs<T>(
         total_elapsed = start_time.elapsed();
         let elapsed = now.elapsed();
         now = Instant::now();
-        let mut txs;
-        match client.get_transaction_count_with_commitment(CommitmentConfig::processed()) {
-            Err(e) => {
-                // ThinClient with multiple options should pick a better one now.
-                info!("Couldn't get transaction count {:?}", e);
-                sleep(Duration::from_secs(sample_period));
-                continue;
-            }
-            Ok(tx_count) => {
-                txs = tx_count;
-            }
-        }
+        let mut txs =
+            match client.get_transaction_count_with_commitment(CommitmentConfig::processed()) {
+                Err(e) => {
+                    // ThinClient with multiple options should pick a better one now.
+                    info!("Couldn't get transaction count {:?}", e);
+                    sleep(Duration::from_secs(sample_period));
+                    continue;
+                }
+                Ok(tx_count) => tx_count,
+            };
 
         if txs < last_txs {
             info!("Expected txs({}) >= last_txs({})", txs, last_txs);

core/src/banking_stage.rs

@@ -490,79 +490,82 @@ impl BankingStage {
         let mut proc_start = Measure::start("consume_buffered_process");
         let mut reached_end_of_slot = None;
 
-        RetainMut::retain_mut(buffered_packet_batches, |buffered_packet_batch_and_offsets| {
-            let (packet_batch, ref mut original_unprocessed_indexes, _forwarded) =
-                buffered_packet_batch_and_offsets;
-            if let Some((next_leader, bank)) = &reached_end_of_slot {
-                // We've hit the end of this slot, no need to perform more processing,
-                // just filter the remaining packets for the invalid (e.g. too old) ones
-                let new_unprocessed_indexes = Self::filter_unprocessed_packets(
-                    bank,
-                    packet_batch,
-                    original_unprocessed_indexes,
-                    my_pubkey,
-                    *next_leader,
-                    banking_stage_stats,
-                );
-                Self::update_buffered_packets_with_new_unprocessed(
-                    original_unprocessed_indexes,
-                    new_unprocessed_indexes,
-                )
-            } else {
-                let bank_start = poh_recorder.lock().unwrap().bank_start();
-                if let Some(BankStart {
-                    working_bank,
-                    bank_creation_time,
-                }) = bank_start
-                {
-                    let (processed, verified_txs_len, new_unprocessed_indexes) =
-                        Self::process_packets_transactions(
-                            &working_bank,
-                            &bank_creation_time,
-                            recorder,
-                            packet_batch,
-                            original_unprocessed_indexes.to_owned(),
-                            transaction_status_sender.clone(),
-                            gossip_vote_sender,
-                            banking_stage_stats,
-                            qos_service,
-                        );
-                    if processed < verified_txs_len
-                        || !Bank::should_bank_still_be_processing_txs(
-                            &bank_creation_time,
-                            max_tx_ingestion_ns,
-                        )
+        RetainMut::retain_mut(
+            buffered_packet_batches,
+            |buffered_packet_batch_and_offsets| {
+                let (packet_batch, ref mut original_unprocessed_indexes, _forwarded) =
+                    buffered_packet_batch_and_offsets;
+                if let Some((next_leader, bank)) = &reached_end_of_slot {
+                    // We've hit the end of this slot, no need to perform more processing,
+                    // just filter the remaining packets for the invalid (e.g. too old) ones
+                    let new_unprocessed_indexes = Self::filter_unprocessed_packets(
+                        bank,
+                        packet_batch,
+                        original_unprocessed_indexes,
+                        my_pubkey,
+                        *next_leader,
+                        banking_stage_stats,
+                    );
+                    Self::update_buffered_packets_with_new_unprocessed(
+                        original_unprocessed_indexes,
+                        new_unprocessed_indexes,
+                    )
+                } else {
+                    let bank_start = poh_recorder.lock().unwrap().bank_start();
+                    if let Some(BankStart {
+                        working_bank,
+                        bank_creation_time,
+                    }) = bank_start
                     {
-                        reached_end_of_slot = Some((
-                            poh_recorder.lock().unwrap().next_slot_leader(),
-                            working_bank,
+                        let (processed, verified_txs_len, new_unprocessed_indexes) =
+                            Self::process_packets_transactions(
+                                &working_bank,
+                                &bank_creation_time,
+                                recorder,
+                                packet_batch,
+                                original_unprocessed_indexes.to_owned(),
+                                transaction_status_sender.clone(),
+                                gossip_vote_sender,
+                                banking_stage_stats,
+                                qos_service,
+                            );
+                        if processed < verified_txs_len
+                            || !Bank::should_bank_still_be_processing_txs(
+                                &bank_creation_time,
+                                max_tx_ingestion_ns,
+                            )
+                        {
+                            reached_end_of_slot = Some((
+                                poh_recorder.lock().unwrap().next_slot_leader(),
+                                working_bank,
+                            ));
+                        }
+                        new_tx_count += processed;
+
+                        // Out of the buffered packets just retried, collect any still unprocessed
+                        // transactions in this batch for forwarding
+                        rebuffered_packet_count += new_unprocessed_indexes.len();
+                        let has_more_unprocessed_transactions =
+                            Self::update_buffered_packets_with_new_unprocessed(
+                                original_unprocessed_indexes,
+                                new_unprocessed_indexes,
+                            );
+                        if let Some(test_fn) = &test_fn {
+                            test_fn();
+                        }
+                        has_more_unprocessed_transactions
+                    } else {
+                        rebuffered_packet_count += original_unprocessed_indexes.len();
+                        // `original_unprocessed_indexes` must have remaining packets to process
+                        // if not yet processed.
+                        assert!(Self::packet_has_more_unprocessed_transactions(
+                            original_unprocessed_indexes
                         ));
+                        true
                     }
-                    new_tx_count += processed;
-
-                    // Out of the buffered packets just retried, collect any still unprocessed
-                    // transactions in this batch for forwarding
-                    rebuffered_packet_count += new_unprocessed_indexes.len();
-                    let has_more_unprocessed_transactions =
-                        Self::update_buffered_packets_with_new_unprocessed(
-                            original_unprocessed_indexes,
-                            new_unprocessed_indexes,
-                        );
-                    if let Some(test_fn) = &test_fn {
-                        test_fn();
-                    }
-                    has_more_unprocessed_transactions
-                } else {
-                    rebuffered_packet_count += original_unprocessed_indexes.len();
-                    // `original_unprocessed_indexes` must have remaining packets to process
-                    // if not yet processed.
-                    assert!(Self::packet_has_more_unprocessed_transactions(
-                        original_unprocessed_indexes
-                    ));
-                    true
                 }
-            }
-        });
+            },
+        );
 
         proc_start.stop();
 

core/src/replay_stage.rs

@@ -4327,9 +4327,9 @@ pub mod tests {
         for i in 0..std::cmp::max(new_vote_pubkeys.len(), new_node_pubkeys.len()) {
             propagated_stats.is_propagated = false;
             let len = std::cmp::min(i, new_vote_pubkeys.len());
-            let mut voted_pubkeys = new_vote_pubkeys[..len].iter().copied().collect();
+            let mut voted_pubkeys = new_vote_pubkeys[..len].to_vec();
             let len = std::cmp::min(i, new_node_pubkeys.len());
-            let mut node_pubkeys = new_node_pubkeys[..len].iter().copied().collect();
+            let mut node_pubkeys = new_node_pubkeys[..len].to_vec();
             let did_newly_reach_threshold =
                 ReplayStage::update_slot_propagated_threshold_from_votes(
                     &mut voted_pubkeys,

genesis/src/main.rs

@@ -60,7 +60,7 @@ fn pubkey_from_str(key_str: &str) -> Result<Pubkey, Box<dyn error::Error>> {
 
 pub fn load_genesis_accounts(file: &str, genesis_config: &mut GenesisConfig) -> io::Result<u64> {
     let mut lamports = 0;
-    let accounts_file = File::open(file.to_string())?;
+    let accounts_file = File::open(file)?;
 
     let genesis_accounts: HashMap<String, Base64Account> =
         serde_yaml::from_reader(accounts_file)

gossip/src/cluster_info.rs

@@ -708,9 +708,9 @@ impl ClusterInfo {
                 Some(format!(
                     "{:15} {:2}| {:5} | {:44} |{:^9}| {:5}| {:5}| {}\n",
                     rpc_addr.to_string(),
-                    if node.id == my_pubkey { "me" } else { "" }.to_string(),
+                    if node.id == my_pubkey { "me" } else { "" },
                     now.saturating_sub(last_updated),
-                    node.id.to_string(),
+                    node.id,
                     if let Some(node_version) = node_version {
                         node_version.to_string()
                     } else {
@@ -778,9 +778,9 @@ impl ClusterInfo {
                         } else {
                             "none".to_string()
                         },
-                        if node.id == my_pubkey { "me" } else { "" }.to_string(),
+                        if node.id == my_pubkey { "me" } else { "" },
                         now.saturating_sub(last_updated),
-                        node.id.to_string(),
+                        node.id,
                         if let Some(node_version) = node_version {
                             node_version.to_string()
                         } else {

install/src/config.rs

@@ -45,7 +45,7 @@ impl Config {
     }
 
     fn _load(config_file: &str) -> Result<Self, io::Error> {
-        let file = File::open(config_file.to_string())?;
+        let file = File::open(config_file)?;
         let config = serde_yaml::from_reader(file)
             .map_err(|err| io::Error::new(io::ErrorKind::Other, format!("{:?}", err)))?;
         Ok(config)