chore: Apply Clippy lint iter_with_drain

Author: jbencin

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/net/chat.rs

@@ -6459,7 +6459,7 @@ mod test {
         }];
 
         // allowed
-        let mut relayers = vec![
+        let relayers = vec![
             RelayData {
                 peer: NeighborAddress {
                     addrbytes: PeerAddress([0u8; 16]),
@@ -6488,7 +6488,7 @@ mod test {
         let relayer_map = convo.stats.take_relayers();
         assert_eq!(convo.stats.relayed_messages.len(), 0);
 
-        for r in relayers.drain(..) {
+        for r in relayers.into_iter() {
             assert!(relayer_map.contains_key(&r.peer));
 
             let stats = relayer_map.get(&r.peer).unwrap();

stackslib/src/net/connection.rs

@@ -1811,7 +1811,7 @@ mod test {
 
         test_debug!("Received {} bytes in total", total_bytes);
 
-        let mut flushed_handles = rx.recv().unwrap();
+        let flushed_handles = rx.recv().unwrap();
 
         match shared_state.lock() {
             Ok(ref mut conn) => {
@@ -1838,15 +1838,15 @@ mod test {
                 assert_eq!(recved.len(), 0);
             }
             Err(e) => {
-                assert!(false, "{:?}", &e);
+                assert!(false, "{e:?}");
                 unreachable!();
             }
         }
 
         // got all messages
         let mut recved = vec![];
-        for (i, rh) in flushed_handles.drain(..).enumerate() {
-            test_debug!("recv {}", i);
+        for (i, rh) in flushed_handles.into_iter().enumerate() {
+            test_debug!("recv {i}");
             let res = rh.recv(0).unwrap();
             recved.push(res);
         }

stackslib/src/net/http/request.rs

@@ -117,7 +117,7 @@ impl HttpRequestPreamble {
         hostname: String,
         port: u16,
         keep_alive: bool,
-        mut keys: Vec<String>,
+        keys: Vec<String>,
         values: Vec<String>,
     ) -> HttpRequestPreamble {
         assert_eq!(keys.len(), values.len());
@@ -130,7 +130,7 @@ impl HttpRequestPreamble {
             keep_alive,
         );
 
-        for (k, v) in keys.drain(..).zip(values) {
+        for (k, v) in keys.into_iter().zip(values) {
             req.add_header(k, v);
         }
         req

stackslib/src/net/http/response.rs

@@ -259,7 +259,7 @@ impl HttpResponsePreamble {
         keep_alive: bool,
         content_length: Option<u32>,
         content_type: HttpContentType,
-        mut keys: Vec<String>,
+        keys: Vec<String>,
         values: Vec<String>,
     ) -> HttpResponsePreamble {
         assert_eq!(keys.len(), values.len());
@@ -272,7 +272,7 @@ impl HttpResponsePreamble {
             keep_alive,
         );
 
-        for (k, v) in keys.drain(..).zip(values) {
+        for (k, v) in keys.into_iter().zip(values) {
             res.add_header(k, v);
         }
         res

stackslib/src/net/server.rs

@@ -753,7 +753,7 @@ mod test {
             client_requests.push(request);
         }
 
-        for (i, request) in client_requests.drain(..).enumerate() {
+        for (i, request) in client_requests.into_iter().enumerate() {
             let (client_sx, client_rx) = sync_channel(1);
             let client = thread::spawn(move || {
                 let mut sock = TcpStream::connect(
@@ -799,7 +799,7 @@ mod test {
             client_handles.push(client_rx);
         }
 
-        for (i, client_thread) in client_threads.drain(..).enumerate() {
+        for (i, client_thread) in client_threads.into_iter().enumerate() {
             test_debug!("Client join {}", i);
             client_thread.join().unwrap();
             let resp = client_handles[i].recv().unwrap();

stackslib/src/net/tests/download/epoch2x.rs

@@ -280,11 +280,7 @@ where
 
     make_topology(&mut peer_configs);
 
-    let mut peers = vec![];
-    for conf in peer_configs.drain(..) {
-        let peer = TestPeer::new(conf);
-        peers.push(peer);
-    }
+    let mut peers: Vec<_> = peer_configs.into_iter().map(TestPeer::new).collect();
 
     let mut num_blocks = 10;
     let first_stacks_block_height = {
@@ -511,7 +507,7 @@ where
     }
 
     drop(dns_clients);
-    for handle in dns_threads.drain(..) {
+    for handle in dns_threads.into_iter() {
         handle.join().unwrap();
     }
 
@@ -904,7 +900,7 @@ pub fn test_get_blocks_and_microblocks_5_peers_star() {
                     peer_configs[i].add_neighbor(&peer_0);
                 }
 
-                for n in neighbors.drain(..) {
+                for n in neighbors.into_iter() {
                     peer_configs[0].add_neighbor(&n);
                 }
             },
@@ -1060,7 +1056,7 @@ pub fn test_get_blocks_and_microblocks_overwhelmed_connections() {
                     peer_configs[i].connection_opts.max_http_clients = 1;
                 }
 
-                for n in neighbors.drain(..) {
+                for n in neighbors.into_iter() {
                     peer_configs[0].add_neighbor(&n);
                 }
             },
@@ -1139,7 +1135,7 @@ pub fn test_get_blocks_and_microblocks_overwhelmed_sockets() {
                     peer_configs[i].connection_opts.max_sockets = 10;
                 }
 
-                for n in neighbors.drain(..) {
+                for n in neighbors.into_iter() {
                     peer_configs[0].add_neighbor(&n);
                 }
             },
@@ -1175,12 +1171,9 @@ pub fn test_get_blocks_and_microblocks_overwhelmed_sockets() {
             |peer| {
                 // check peer health
                 // nothing should break
-                match peer.network.block_downloader {
-                    Some(ref dl) => {
-                        assert_eq!(dl.broken_peers.len(), 0);
-                        assert_eq!(dl.dead_peers.len(), 0);
-                    }
-                    None => {}
+                if let Some(ref dl) = peer.network.block_downloader {
+                    assert_eq!(dl.broken_peers.len(), 0);
+                    assert_eq!(dl.dead_peers.len(), 0);
                 }
                 true
             },