Remove some clippy lints

account-decoder/src/parse_config.rs

@@ -82,7 +82,7 @@ impl From<StakeConfig> for UiStakeConfig {
     }
 }
 
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Serialize, Deserialize, PartialEq, Eq)]
 #[serde(rename_all = "camelCase")]
 pub struct UiConfig<T> {
     pub keys: Vec<UiConfigKey>,

ci/test-checks.sh

@@ -67,7 +67,11 @@ fi
 
 # -Z... is needed because of clippy bug: https://github.com/rust-lang/rust-clippy/issues/4612
 # run nightly clippy for `sdk/` as there's a moderate amount of nightly-only code there
- _ scripts/cargo-for-all-lock-files.sh -- nightly clippy -Zunstable-options --all-targets -- --deny=warnings --deny=clippy::integer_arithmetic
+ _ scripts/cargo-for-all-lock-files.sh -- nightly clippy -Zunstable-options --all-targets -- \
+   --deny=warnings \
+   --deny=clippy::integer_arithmetic \
+   --allow=clippy::significant_drop_in_scrutinee \
+   --allow=clippy::derive_partial_eq_without_eq \
 
 _ scripts/cargo-for-all-lock-files.sh -- nightly fmt --all -- --check
 

cli/src/cluster_query.rs

@@ -1125,7 +1125,7 @@ pub fn process_get_epoch_info(rpc_client: &RpcClient, config: &CliConfig) -> Pro
             let first_block_in_epoch = rpc_client
                 .get_blocks_with_limit(epoch_expected_start_slot, 1)
                 .ok()
-                .and_then(|slot_vec| slot_vec.get(0).cloned())
+                .and_then(|slot_vec| slot_vec.first().cloned())
                 .unwrap_or(epoch_expected_start_slot);
             let start_block_time =
                 rpc_client

cli/src/program.rs

@@ -1621,12 +1621,12 @@ fn process_close(
                         }) = account.state()
                         {
                             if authority_pubkey != Some(authority_signer.pubkey()) {
-                                return Err(format!(
+                                Err(format!(
                                     "Program authority {:?} does not match {:?}",
                                     authority_pubkey,
                                     Some(authority_signer.pubkey())
                                 )
-                                .into());
+                                .into())
                             } else {
                                 close(
                                     rpc_client,
@@ -1645,22 +1645,16 @@ fn process_close(
                                 ))
                             }
                         } else {
-                            return Err(
-                                format!("Program {} has been closed", account_pubkey).into()
-                            );
+                            Err(format!("Program {} has been closed", account_pubkey).into())
                         }
                     } else {
-                        return Err(format!("Program {} has been closed", account_pubkey).into());
+                        Err(format!("Program {} has been closed", account_pubkey).into())
                     }
                 }
-                _ => {
-                    return Err(
-                        format!("{} is not a Program or Buffer account", account_pubkey).into(),
-                    );
-                }
+                _ => Err(format!("{} is not a Program or Buffer account", account_pubkey).into()),
             }
         } else {
-            return Err(format!("Unable to find the account {}", account_pubkey).into());
+            Err(format!("Unable to find the account {}", account_pubkey).into())
         }
     } else {
         let buffers = get_buffers(

client/src/rpc_config.rs

@@ -215,7 +215,7 @@ pub struct RpcSignaturesForAddressConfig {
     pub min_context_slot: Option<Slot>,
 }
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(untagged)]
 pub enum RpcEncodingConfigWrapper<T> {
     Deprecated(Option<UiTransactionEncoding>),

client/src/rpc_response.rs

@@ -73,13 +73,13 @@ impl RpcResponseContext {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct Response<T> {
     pub context: RpcResponseContext,
     pub value: T,
 }
 
-#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct RpcBlockCommitment<T> {
     pub commitment: Option<T>,

core/src/consensus.rs

@@ -439,8 +439,8 @@ impl Tower {
 
     pub fn last_voted_slot_in_bank(bank: &Bank, vote_account_pubkey: &Pubkey) -> Option<Slot> {
         let (_stake, vote_account) = bank.get_vote_account(vote_account_pubkey)?;
-        let slot = vote_account.vote_state().as_ref().ok()?.last_voted_slot();
-        slot
+        let vote_state = vote_account.vote_state();
+        vote_state.as_ref().ok()?.last_voted_slot()
     }
 
     pub fn record_bank_vote(&mut self, bank: &Bank, vote_account_pubkey: &Pubkey) -> Option<Slot> {

core/src/replay_stage.rs

@@ -2881,7 +2881,7 @@ impl ReplayStage {
             let exists = leader_propagated_stats
                 .propagated_node_ids
                 .contains(node_pubkey);
-            leader_propagated_stats.add_node_pubkey(&*node_pubkey, leader_bank);
+            leader_propagated_stats.add_node_pubkey(node_pubkey, leader_bank);
             !exists
         });
 

ledger/src/blockstore.rs

@@ -3520,7 +3520,7 @@ fn handle_chaining(
 
     // Write all the newly changed slots in new_chained_slots to the write_batch
     for (slot, meta) in new_chained_slots.iter() {
-        let meta: &SlotMeta = &RefCell::borrow(&*meta);
+        let meta: &SlotMeta = &RefCell::borrow(meta);
         write_batch.put::<cf::SlotMeta>(*slot, meta)?;
     }
     Ok(())
@@ -3609,8 +3609,8 @@ fn handle_chaining_for_slot(
     // update all child slots with `is_connected` = true because these children are also now newly
     // connected to trunk of the ledger
     let should_propagate_is_connected =
-        is_newly_completed_slot(&RefCell::borrow(&*meta), meta_backup)
-            && RefCell::borrow(&*meta).is_connected;
+        is_newly_completed_slot(&RefCell::borrow(meta), meta_backup)
+            && RefCell::borrow(meta).is_connected;
 
     if should_propagate_is_connected {
         // slot_function returns a boolean indicating whether to explore the children

ledger/src/shred/legacy.rs

@@ -183,6 +183,7 @@ impl ShredDataTrait for ShredData {
 
     fn data(&self) -> Result<&[u8], Error> {
         let size = usize::from(self.data_header.size);
+        #[allow(clippy::manual_range_contains)]
         if size > self.payload.len()
             || size < SIZE_OF_DATA_SHRED_HEADERS
             || size > SIZE_OF_DATA_SHRED_HEADERS + Self::CAPACITY

perf/benches/shrink.rs

@@ -24,7 +24,7 @@ fn test_packet_with_size(size: usize, rng: &mut ThreadRng) -> Vec<u8> {
 fn do_bench_shrink_packets(bencher: &mut Bencher, mut batches: Vec<PacketBatch>) {
     // verify packets
     bencher.iter(|| {
-        let _ans = sigverify::shrink_batches(&mut batches);
+        sigverify::shrink_batches(&mut batches);
         batches.iter_mut().for_each(|b| {
             b.iter_mut()
                 .for_each(|p| p.meta.set_discard(thread_rng().gen()))

program-runtime/src/invoke_context.rs

@@ -1439,7 +1439,7 @@ mod tests {
                     .get(owned_index)
                     .unwrap()
                     .data()
-                    .get(0)
+                    .first()
                     .unwrap(),
                 (MAX_DEPTH + owned_index) as u8
             );
@@ -1451,7 +1451,7 @@ mod tests {
                 .unwrap()
                 .borrow_mut()
                 .data()
-                .get(0)
+                .first()
                 .unwrap();
             *invoke_context
                 .transaction_context
@@ -1471,7 +1471,7 @@ mod tests {
                     .get(not_owned_index)
                     .unwrap()
                     .data()
-                    .get(0)
+                    .first()
                     .unwrap(),
                 data
             );

rpc/src/rpc.rs

@@ -540,7 +540,7 @@ impl JsonRpcRequestProcessor {
         let first_confirmed_block_in_epoch = *self
             .get_blocks_with_limit(first_slot_in_epoch, 1, config.commitment)
             .await?
-            .get(0)
+            .first()
             .ok_or(RpcCustomError::BlockNotAvailable {
                 slot: first_slot_in_epoch,
             })?;

rpc/src/rpc_pubsub_service.rs

@@ -193,10 +193,10 @@ pub struct TestBroadcastReceiver {
 #[cfg(test)]
 impl TestBroadcastReceiver {
     pub fn recv(&mut self) -> String {
-        return match self.recv_timeout(std::time::Duration::from_secs(10)) {
+        match self.recv_timeout(std::time::Duration::from_secs(10)) {
             Err(err) => panic!("broadcast receiver error: {}", err),
             Ok(str) => str,
-        };
+        }
     }
 
     pub fn recv_timeout(&mut self, timeout: std::time::Duration) -> Result<String, String> {

runtime/src/accounts_index.rs

@@ -333,7 +333,7 @@ impl<T: IndexValue> ReadAccountMapEntry<T> {
     }
 
     pub fn slot_list(&self) -> &SlotList<T> {
-        &*self.borrow_slot_list_guard()
+        self.borrow_slot_list_guard()
     }
 
     pub fn ref_count(&self) -> RefCount {

runtime/src/bank.rs

@@ -2602,7 +2602,7 @@ impl Bank {
             .filter_map(|id| self.feature_set.activated_slot(id))
             .collect::<Vec<_>>();
         slots.sort_unstable();
-        slots.get(0).cloned().unwrap_or_else(|| {
+        slots.first().cloned().unwrap_or_else(|| {
             self.feature_set
                 .activated_slot(&feature_set::pico_inflation::id())
                 .unwrap_or(0)
@@ -4699,7 +4699,7 @@ impl Bank {
         // operations being done and treating them like a signature
         for (program_id, instruction) in message.program_instructions_iter() {
             if secp256k1_program::check_id(program_id) || ed25519_program::check_id(program_id) {
-                if let Some(num_verifies) = instruction.data.get(0) {
+                if let Some(num_verifies) = instruction.data.first() {
                     num_signatures = num_signatures.saturating_add(u64::from(*num_verifies));
                 }
             }

runtime/src/hardened_unpack.rs

@@ -83,7 +83,7 @@ fn check_unpack_result(unpack_result: bool, path: String) -> Result<()> {
     Ok(())
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Eq)]
 pub enum UnpackPath<'a> {
     Valid(&'a Path),
     Ignore,

runtime/src/status_cache.rs

@@ -34,7 +34,7 @@ type SlotDeltaMap<T> = HashMap<Slot, Status<T>>;
 // construct a new one. Usually derived from a status cache's `SlotDeltaMap`
 pub type SlotDelta<T> = (Slot, bool, Status<T>);
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Eq)]
 pub struct SignatureConfirmationStatus<T> {
     pub slot: Slot,
     pub confirmations: usize,

sdk/program/src/message/sanitized.rs

@@ -257,7 +257,7 @@ impl SanitizedMessage {
                 )
             })
             .and_then(|ix| {
-                ix.accounts.get(0).and_then(|idx| {
+                ix.accounts.first().and_then(|idx| {
                     let idx = *idx as usize;
                     if nonce_must_be_writable && !self.is_writable(idx) {
                         None

sdk/program/src/sysvar/mod.rs

@@ -137,10 +137,10 @@ macro_rules! impl_sysvar_get {
             let var_addr = &mut var as *mut _ as *mut u8;
 
             #[cfg(target_os = "solana")]
-            let result = unsafe { crate::syscalls::$syscall_name(var_addr) };
+            let result = unsafe { $crate::syscalls::$syscall_name(var_addr) };
 
             #[cfg(not(target_os = "solana"))]
-            let result = crate::program_stubs::$syscall_name(var_addr);
+            let result = $crate::program_stubs::$syscall_name(var_addr);
 
             match result {
                 $crate::entrypoint::SUCCESS => Ok(var),

sdk/src/transaction/mod.rs

@@ -1095,7 +1095,7 @@ pub fn uses_durable_nonce(tx: &Transaction) -> Option<&CompiledInstruction> {
             )
             // Nonce account is writable
             && matches!(
-                instruction.accounts.get(0),
+                instruction.accounts.first(),
                 Some(index) if message.is_writable(*index as usize)
             )
         })
@@ -1106,7 +1106,7 @@ pub fn get_nonce_pubkey_from_instruction<'a>(
     ix: &CompiledInstruction,
     tx: &'a Transaction,
 ) -> Option<&'a Pubkey> {
-    ix.accounts.get(0).and_then(|idx| {
+    ix.accounts.first().and_then(|idx| {
         let idx = *idx as usize;
         tx.message().account_keys.get(idx)
     })

sdk/src/transaction_context.rs

@@ -132,7 +132,7 @@ impl TransactionContext {
     ) -> Result<&InstructionContext, InstructionError> {
         let top_level_index = *self
             .instruction_stack
-            .get(0)
+            .first()
             .ok_or(InstructionError::CallDepth)?;
         let cpi_index = if level == 0 {
             0

validator/src/main.rs

@@ -259,7 +259,7 @@ fn wait_for_restart_window(
                         leader_schedule.pop_front();
                     }
                     while upcoming_idle_windows
-                        .get(0)
+                        .first()
                         .map(|(slot, _)| *slot < epoch_info.absolute_slot)
                         .unwrap_or(false)
                     {
@@ -276,7 +276,7 @@ fn wait_for_restart_window(
                             if idle_slots >= min_idle_slots {
                                 Ok(())
                             } else {
-                                Err(match upcoming_idle_windows.get(0) {
+                                Err(match upcoming_idle_windows.first() {
                                     Some((starting_slot, length_in_slots)) => {
                                         format!(
                                             "Next idle window in {} slots, for {} slots",

zk-token-sdk/src/zk_token_proof_instruction.rs

@@ -73,7 +73,7 @@ impl ProofInstruction {
     }
 
     pub fn decode_type(input: &[u8]) -> Option<Self> {
-        input.get(0).and_then(|x| FromPrimitive::from_u8(*x))
+        input.first().and_then(|x| FromPrimitive::from_u8(*x))
     }
 
     pub fn decode_data<T: Pod>(input: &[u8]) -> Option<&T> {