chore: Apply Clippy lint iter_kv_map

Author: jbencin

stackslib/src/burnchains/affirmation.rs

@@ -679,7 +679,7 @@ pub fn read_parent_block_commits<B: BurnchainHeaderReader>(
             }
         }
     }
-    let mut parent_list: Vec<_> = parents.into_iter().map(|(_, cmt)| cmt).collect();
+    let mut parent_list: Vec<_> = parents.into_values().collect();
     parent_list.sort_by(|a, b| {
         if a.block_height != b.block_height {
             a.block_height.cmp(&b.block_height)

stackslib/src/burnchains/db.rs

@@ -1245,8 +1245,8 @@ impl BurnchainDB {
 
         ops.extend(
             pre_stx_ops
-                .into_iter()
-                .map(|(_, op)| BlockstackOperationType::PreStx(op)),
+                .into_values()
+                .map(BlockstackOperationType::PreStx),
         );
 
         ops.sort_by_key(|op| op.vtxindex());

stackslib/src/chainstate/stacks/miner.rs

@@ -262,11 +262,7 @@ pub struct MinerEpochInfo<'a> {
 
 impl From<&UnconfirmedState> for MicroblockMinerRuntime {
     fn from(unconfirmed: &UnconfirmedState) -> MicroblockMinerRuntime {
-        let considered = unconfirmed
-            .mined_txs
-            .iter()
-            .map(|(txid, _)| txid.clone())
-            .collect();
+        let considered = unconfirmed.mined_txs.keys().cloned().collect();
         MicroblockMinerRuntime {
             bytes_so_far: unconfirmed.bytes_so_far,
             prev_microblock_header: unconfirmed.last_mblock.clone(),

stackslib/src/net/atlas/download.rs

@@ -533,8 +533,8 @@ impl AttachmentsBatchStateContext {
         }
         let mut events_ids = results
             .faulty_peers
-            .iter()
-            .map(|(k, _)| *k)
+            .keys()
+            .map(|k| *k)
             .collect::<Vec<usize>>();
         self.events_to_deregister.append(&mut events_ids);
 
@@ -567,8 +567,8 @@ impl AttachmentsBatchStateContext {
         }
         let mut events_ids = results
             .faulty_peers
-            .iter()
-            .map(|(k, _)| *k)
+            .keys()
+            .map(|k| *k)
             .collect::<Vec<usize>>();
         self.events_to_deregister.append(&mut events_ids);
 

stackslib/src/net/download/nakamoto/download_state_machine.rs

@@ -1402,8 +1402,7 @@ impl NakamotoDownloadStateMachine {
         let tenure_blocks = coalesced_blocks
             .into_iter()
             .map(|(consensus_hash, block_map)| {
-                let mut block_list: Vec<_> =
-                    block_map.into_iter().map(|(_, block)| block).collect();
+                let mut block_list: Vec<_> = block_map.into_values().collect();
                 block_list.sort_unstable_by_key(|blk| blk.header.chain_length);
                 (consensus_hash, block_list)
             })

stackslib/src/net/inv/nakamoto.rs

@@ -750,8 +750,8 @@ impl<NC: NeighborComms> NakamotoInvStateMachine<NC> {
     /// Highest reward cycle learned
     pub fn highest_reward_cycle(&self) -> u64 {
         self.inventories
-            .iter()
-            .map(|(_, inv)| inv.highest_reward_cycle())
+            .values()
+            .map(|inv| inv.highest_reward_cycle())
             .max()
             .unwrap_or(0)
     }

stackslib/src/net/mod.rs

@@ -1580,8 +1580,8 @@ impl NetworkResult {
 
         let pushed_blocks: HashSet<_> = self
             .pushed_blocks
-            .iter()
-            .map(|(_, block_list)| {
+            .values()
+            .map(|block_list| {
                 block_list
                     .iter()
                     .map(|block_data| {
@@ -1626,8 +1626,8 @@ impl NetworkResult {
 
         let pushed_microblocks: HashSet<_> = self
             .pushed_microblocks
-            .iter()
-            .map(|(_, mblock_list)| {
+            .values()
+            .map(|mblock_list| {
                 mblock_list
                     .iter()
                     .map(|(_, mblock_data)| {
@@ -1657,14 +1657,14 @@ impl NetworkResult {
     fn all_nakamoto_block_ids(&self) -> HashSet<StacksBlockId> {
         let mut naka_block_ids: HashSet<_> = self
             .nakamoto_blocks
-            .iter()
-            .map(|(_, nblk)| nblk.block_id())
+            .values()
+            .map(|nblk| nblk.block_id())
             .collect();
 
         let pushed_nakamoto_blocks: HashSet<_> = self
             .pushed_nakamoto_blocks
-            .iter()
-            .map(|(_, naka_blocks_list)| {
+            .values()
+            .map(|naka_blocks_list| {
                 naka_blocks_list
                     .iter()
                     .map(|(_, naka_blocks)| {
@@ -1705,8 +1705,8 @@ impl NetworkResult {
             .collect();
         let pushed_txids: HashSet<_> = self
             .pushed_transactions
-            .iter()
-            .map(|(_, tx_list)| {
+            .values()
+            .map(|tx_list| {
                 tx_list
                     .iter()
                     .map(|(_, tx)| tx.txid())
@@ -1734,8 +1734,8 @@ impl NetworkResult {
     /// This is unique per message.
     fn all_msg_sigs(&self) -> HashSet<MessageSignature> {
         self.unhandled_messages
-            .iter()
-            .map(|(_, msgs)| {
+            .values()
+            .map(|msgs| {
                 msgs.iter()
                     .map(|msg| msg.preamble.signature.clone())
                     .collect::<HashSet<_>>()

stackslib/src/net/relay.rs

@@ -2607,21 +2607,18 @@ impl Relayer {
         new_microblocks: Vec<(Vec<RelayData>, MicroblocksData)>,
     ) {
         // have the p2p thread tell our neighbors about newly-discovered blocks
-        let new_block_chs = new_blocks.iter().map(|(ch, _)| ch.clone()).collect();
+        let new_block_chs = new_blocks.keys().cloned().collect();
         let available = Relayer::load_blocks_available_data(sortdb, new_block_chs)
             .unwrap_or(BlocksAvailableMap::new());
         if !available.is_empty() {
             debug!("{:?}: Blocks available: {}", &_local_peer, available.len());
             if let Err(e) = self.p2p.advertize_blocks(available, new_blocks) {
-                warn!("Failed to advertize new blocks: {:?}", &e);
+                warn!("Failed to advertize new blocks: {e:?}");
             }
         }
 
         // have the p2p thread tell our neighbors about newly-discovered confirmed microblock streams
-        let new_mblock_chs = new_confirmed_microblocks
-            .iter()
-            .map(|(ch, _)| ch.clone())
-            .collect();
+        let new_mblock_chs = new_confirmed_microblocks.keys().cloned().collect();
         let mblocks_available = Relayer::load_blocks_available_data(sortdb, new_mblock_chs)
             .unwrap_or(BlocksAvailableMap::new());
         if !mblocks_available.is_empty() {
@@ -2634,7 +2631,7 @@ impl Relayer {
                 .p2p
                 .advertize_microblocks(mblocks_available, new_confirmed_microblocks)
             {
-                warn!("Failed to advertize new confirmed microblocks: {:?}", &e);
+                warn!("Failed to advertize new confirmed microblocks: {e:?}");
             }
         }