chore: Apply Clippy vec_init_then_push, map_clone, map_entry, and iter_* lints

clarity/src/vm/tests/datamaps.rs

@@ -642,15 +642,15 @@ fn bad_define_maps() {
         "(define-map lists { name: int } contents 5)",
         "(define-map lists { name: int } { contents: (list 5 0 int) })",
     ];
-    let mut expected: Vec<Error> = vec![
+    let expected: Vec<Error> = vec![
         CheckErrors::BadSyntaxExpectedListOfPairs.into(),
         CheckErrors::UnknownTypeName("contents".to_string()).into(),
         CheckErrors::ExpectedName.into(),
         CheckErrors::IncorrectArgumentCount(3, 4).into(),
         CheckErrors::InvalidTypeDescription.into(),
     ];
 
-    for (test, expected_err) in tests.iter().zip(expected.drain(..)) {
+    for (test, expected_err) in tests.iter().zip(expected.into_iter()) {
         let outcome = execute(test).unwrap_err();
         assert_eq!(outcome, expected_err);
     }
@@ -666,7 +666,7 @@ fn bad_tuples() {
         "(get name five (tuple (name 1)))",
         "(get 1234 (tuple (name 1)))",
     ];
-    let mut expected = vec![
+    let expected = vec![
         CheckErrors::NameAlreadyUsed("name".into()),
         CheckErrors::BadSyntaxBinding,
         CheckErrors::BadSyntaxBinding,
@@ -678,7 +678,7 @@ fn bad_tuples() {
         CheckErrors::ExpectedName,
     ];
 
-    for (test, expected_err) in tests.iter().zip(expected.drain(..)) {
+    for (test, expected_err) in tests.iter().zip(expected.into_iter()) {
         let outcome = execute(test).unwrap_err();
         assert_eq!(outcome, expected_err.into());
     }

stacks-common/src/address/c32_old.rs

@@ -67,7 +67,7 @@ fn c32_encode(input_bytes: &[u8]) -> String {
         }
     }
 
-    let result: Vec<u8> = result.drain(..).rev().collect();
+    let result: Vec<u8> = result.into_iter().rev().collect();
     String::from_utf8(result).unwrap()
 }
 

stacks-common/src/util/chunked_encoding.rs

@@ -504,14 +504,14 @@ mod test {
 
     #[test]
     fn test_segment_reader() {
-        let mut tests = vec![
+        let tests = vec![
             (vec_u8(vec!["a", "b"]), "ab"),
             (vec_u8(vec!["aa", "bbb", "cccc"]), "aabbbcccc"),
             (vec_u8(vec!["aaaa", "bbb", "cc", "d", ""]), "aaaabbbccd"),
             (vec_u8(vec!["", "a", "", "b", ""]), "ab"),
             (vec_u8(vec![""]), ""),
         ];
-        for (input_vec, expected) in tests.drain(..) {
+        for (input_vec, expected) in tests.into_iter() {
             let num_segments = input_vec.len();
             let mut segment_io = SegmentReader::new(input_vec);
             let mut output = vec![0u8; expected.len()];

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/burnchain.rs

@@ -136,7 +136,7 @@ impl BurnchainStateTransition {
             return Some(block_total_burns[0]);
         } else if block_total_burns.len() % 2 != 0 {
             let idx = block_total_burns.len() / 2;
-            return block_total_burns.get(idx).map(|b| *b);
+            return block_total_burns.get(idx).copied();
         } else {
             // NOTE: the `- 1` is safe because block_total_burns.len() >= 2
             let idx_left = block_total_burns.len() / 2 - 1;
@@ -269,8 +269,7 @@ impl BurnchainStateTransition {
                 let mut missed_commits_at_height =
                     SortitionDB::get_missed_commits_by_intended(sort_tx.tx(), &sortition_id)?;
                 if let Some(missed_commit_in_block) = missed_commits_map.remove(&sortition_id) {
-                    missed_commits_at_height
-                        .extend(missed_commit_in_block.into_iter().map(|x| x.clone()));
+                    missed_commits_at_height.extend(missed_commit_in_block.into_iter().cloned());
                 }
 
                 windowed_missed_commits.push(missed_commits_at_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/nakamoto/coordinator/tests.rs

@@ -3234,54 +3234,53 @@ fn test_stacks_on_burnchain_ops() {
         let (mut burn_ops, mut tenure_change, miner_key) =
             peer.begin_nakamoto_tenure(TenureChangeCause::BlockFound);
 
-        let mut new_burn_ops = vec![];
-        new_burn_ops.push(BlockstackOperationType::DelegateStx(DelegateStxOp {
-            sender: addr.clone(),
-            delegate_to: recipient_addr.clone(),
-            reward_addr: None,
-            delegated_ustx: 1,
-            until_burn_height: None,
-
-            // mocked
-            txid: Txid([i; 32]),
-            vtxindex: 11,
-            block_height: block_height + 1,
-            burn_header_hash: BurnchainHeaderHash([0x00; 32]),
-        }));
-        new_burn_ops.push(BlockstackOperationType::StackStx(StackStxOp {
-            sender: addr.clone(),
-            reward_addr: PoxAddress::Standard(
-                recipient_addr.clone(),
-                Some(AddressHashMode::SerializeP2PKH),
-            ),
-            stacked_ustx: 1,
-            num_cycles: 1,
-            signer_key: Some(StacksPublicKeyBuffer::from_public_key(
-                &StacksPublicKey::from_private(&recipient_private_key),
-            )),
-            max_amount: Some(1),
-            auth_id: Some(i as u32),
-
-            // mocked
-            txid: Txid([i | 0x80; 32]),
-            vtxindex: 12,
-            block_height: block_height + 1,
-            burn_header_hash: BurnchainHeaderHash([0x00; 32]),
-        }));
-        new_burn_ops.push(BlockstackOperationType::TransferStx(TransferStxOp {
-            sender: addr.clone(),
-            recipient: recipient_addr.clone(),
-            transfered_ustx: 1,
-            memo: vec![0x2],
-
-            // mocked
-            txid: Txid([i | 0x40; 32]),
-            vtxindex: 13,
-            block_height: block_height + 1,
-            burn_header_hash: BurnchainHeaderHash([0x00; 32]),
-        }));
-        new_burn_ops.push(BlockstackOperationType::VoteForAggregateKey(
-            VoteForAggregateKeyOp {
+        let mut new_burn_ops = vec![
+            BlockstackOperationType::DelegateStx(DelegateStxOp {
+                sender: addr.clone(),
+                delegate_to: recipient_addr.clone(),
+                reward_addr: None,
+                delegated_ustx: 1,
+                until_burn_height: None,
+
+                // mocked
+                txid: Txid([i; 32]),
+                vtxindex: 11,
+                block_height: block_height + 1,
+                burn_header_hash: BurnchainHeaderHash([0x00; 32]),
+            }),
+            BlockstackOperationType::StackStx(StackStxOp {
+                sender: addr.clone(),
+                reward_addr: PoxAddress::Standard(
+                    recipient_addr.clone(),
+                    Some(AddressHashMode::SerializeP2PKH),
+                ),
+                stacked_ustx: 1,
+                num_cycles: 1,
+                signer_key: Some(StacksPublicKeyBuffer::from_public_key(
+                    &StacksPublicKey::from_private(&recipient_private_key),
+                )),
+                max_amount: Some(1),
+                auth_id: Some(i as u32),
+
+                // mocked
+                txid: Txid([i | 0x80; 32]),
+                vtxindex: 12,
+                block_height: block_height + 1,
+                burn_header_hash: BurnchainHeaderHash([0x00; 32]),
+            }),
+            BlockstackOperationType::TransferStx(TransferStxOp {
+                sender: addr.clone(),
+                recipient: recipient_addr.clone(),
+                transfered_ustx: 1,
+                memo: vec![0x2],
+
+                // mocked
+                txid: Txid([i | 0x40; 32]),
+                vtxindex: 13,
+                block_height: block_height + 1,
+                burn_header_hash: BurnchainHeaderHash([0x00; 32]),
+            }),
+            BlockstackOperationType::VoteForAggregateKey(VoteForAggregateKeyOp {
                 sender: addr.clone(),
                 aggregate_key: StacksPublicKeyBuffer::from_public_key(
                     &StacksPublicKey::from_private(&agg_private_key),
@@ -3298,8 +3297,8 @@ fn test_stacks_on_burnchain_ops() {
                 vtxindex: 14,
                 block_height: block_height + 1,
                 burn_header_hash: BurnchainHeaderHash([0x00; 32]),
-            },
-        ));
+            }),
+        ];
 
         extra_burn_ops.push(new_burn_ops.clone());
         burn_ops.append(&mut new_burn_ops);

stackslib/src/chainstate/stacks/db/unconfirmed.rs

@@ -443,7 +443,7 @@ impl UnconfirmedState {
         &self,
         txid: &Txid,
     ) -> Option<(StacksTransaction, BlockHeaderHash, u16)> {
-        self.mined_txs.get(txid).map(|x| x.clone())
+        self.mined_txs.get(txid).cloned()
     }
 
     pub fn num_microblocks(&self) -> u64 {

stackslib/src/chainstate/stacks/index/cache.rs

@@ -151,7 +151,7 @@ impl<T: MarfTrieId> TrieCacheState<T> {
 
     /// Get the block ID, given its hash
     pub fn load_block_id(&self, block_hash: &T) -> Option<u32> {
-        self.block_id_cache.get(block_hash).map(|id| *id)
+        self.block_id_cache.get(block_hash).copied()
     }
 }
 

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/chainstate/stacks/tests/chain_histories.rs

@@ -2857,9 +2857,7 @@ pub fn mine_invalid_token_transfers_block(
     );
     builder.force_mine_tx(clarity_tx, &tx1).unwrap();
 
-    if !miner.spent_at_nonce.contains_key(&1) {
-        miner.spent_at_nonce.insert(1, 11111);
-    }
+    miner.spent_at_nonce.entry(1).or_insert(11111);
 
     let tx2 = make_token_transfer(
         miner,
@@ -2871,9 +2869,7 @@ pub fn mine_invalid_token_transfers_block(
     );
     builder.force_mine_tx(clarity_tx, &tx2).unwrap();
 
-    if !miner.spent_at_nonce.contains_key(&2) {
-        miner.spent_at_nonce.insert(2, 22222);
-    }
+    miner.spent_at_nonce.entry(2).or_insert(22222);
 
     let tx3 = make_token_transfer(
         miner,

stackslib/src/clarity_cli.rs

@@ -1002,7 +1002,7 @@ pub fn invoke_command(invoked_by: &str, args: &[String]) -> (i32, Option<serde_j
 
     match args[0].as_ref() {
         "initialize" => {
-            let mut argv: Vec<String> = args.into_iter().map(|x| x.clone()).collect();
+            let mut argv: Vec<String> = args.into_iter().cloned().collect();
 
             let mainnet = if let Ok(Some(_)) = consume_arg(&mut argv, &["--testnet"], false) {
                 false
@@ -1127,7 +1127,7 @@ pub fn invoke_command(invoked_by: &str, args: &[String]) -> (i32, Option<serde_j
                 panic_test!();
             }
 
-            let mut argv: Vec<String> = args.into_iter().map(|x| x.clone()).collect();
+            let mut argv: Vec<String> = args.into_iter().cloned().collect();
             let contract_id = if let Ok(optarg) = consume_arg(&mut argv, &["--contract_id"], true) {
                 optarg
                     .map(|optarg_str| {
@@ -1253,7 +1253,7 @@ pub fn invoke_command(invoked_by: &str, args: &[String]) -> (i32, Option<serde_j
             (0, Some(result))
         }
         "repl" => {
-            let mut argv: Vec<String> = args.into_iter().map(|x| x.clone()).collect();
+            let mut argv: Vec<String> = args.into_iter().cloned().collect();
             let mainnet = if let Ok(Some(_)) = consume_arg(&mut argv, &["--testnet"], false) {
                 false
             } else {
@@ -1385,7 +1385,7 @@ pub fn invoke_command(invoked_by: &str, args: &[String]) -> (i32, Option<serde_j
             }
         }
         "eval" => {
-            let mut argv: Vec<String> = args.into_iter().map(|x| x.clone()).collect();
+            let mut argv: Vec<String> = args.into_iter().cloned().collect();
 
             let costs = if let Ok(Some(_)) = consume_arg(&mut argv, &["--costs"], false) {
                 true
@@ -1448,7 +1448,7 @@ pub fn invoke_command(invoked_by: &str, args: &[String]) -> (i32, Option<serde_j
             }
         }
         "eval_at_chaintip" => {
-            let mut argv: Vec<String> = args.into_iter().map(|x| x.clone()).collect();
+            let mut argv: Vec<String> = args.into_iter().cloned().collect();
 
             let costs = if let Ok(Some(_)) = consume_arg(&mut argv, &["--costs"], false) {
                 true
@@ -1530,7 +1530,7 @@ pub fn invoke_command(invoked_by: &str, args: &[String]) -> (i32, Option<serde_j
             }
         }
         "eval_at_block" => {
-            let mut argv: Vec<String> = args.into_iter().map(|x| x.clone()).collect();
+            let mut argv: Vec<String> = args.into_iter().cloned().collect();
 
             let costs = if let Ok(Some(_)) = consume_arg(&mut argv, &["--costs"], false) {
                 true
@@ -1612,7 +1612,7 @@ pub fn invoke_command(invoked_by: &str, args: &[String]) -> (i32, Option<serde_j
             }
         }
         "launch" => {
-            let mut argv: Vec<String> = args.into_iter().map(|x| x.clone()).collect();
+            let mut argv: Vec<String> = args.into_iter().cloned().collect();
             let coverage_folder = if let Ok(covarg) = consume_arg(&mut argv, &["--c"], true) {
                 covarg
             } else {
@@ -1767,7 +1767,7 @@ pub fn invoke_command(invoked_by: &str, args: &[String]) -> (i32, Option<serde_j
             }
         }
         "execute" => {
-            let mut argv: Vec<String> = args.into_iter().map(|x| x.clone()).collect();
+            let mut argv: Vec<String> = args.into_iter().cloned().collect();
             let coverage_folder = if let Ok(covarg) = consume_arg(&mut argv, &["--c"], true) {
                 covarg
             } else {

stackslib/src/core/mempool.rs

@@ -520,7 +520,7 @@ impl MemPoolWalkTxTypes {
     }
 
     pub fn only(selected: &[MemPoolWalkTxTypes]) -> HashSet<MemPoolWalkTxTypes> {
-        selected.iter().map(|x| x.clone()).collect()
+        selected.iter().copied().collect()
     }
 }
 

stackslib/src/net/api/tests/getheaders.rs

@@ -295,23 +295,17 @@ fn test_stream_getheaders() {
     let block_expected_headers: Vec<StacksBlockHeader> =
         blocks.iter().rev().map(|blk| blk.header.clone()).collect();
 
-    let block_expected_index_hashes: Vec<StacksBlockId> = blocks_index_hashes
-        .iter()
-        .rev()
-        .map(|idx| idx.clone())
-        .collect();
+    let block_expected_index_hashes: Vec<StacksBlockId> =
+        blocks_index_hashes.iter().rev().copied().collect();
 
     let block_fork_expected_headers: Vec<StacksBlockHeader> = blocks_fork
         .iter()
         .rev()
         .map(|blk| blk.header.clone())
         .collect();
 
-    let block_fork_expected_index_hashes: Vec<StacksBlockId> = blocks_fork_index_hashes
-        .iter()
-        .rev()
-        .map(|idx| idx.clone())
-        .collect();
+    let block_fork_expected_index_hashes: Vec<StacksBlockId> =
+        blocks_fork_index_hashes.iter().rev().copied().collect();
 
     // get them all -- ask for more than there is
     let mut stream =