Fix remaining lints

interop/src/main.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::mutex_atomic)]
+
 use std::{
     net::{SocketAddr, ToSocketAddrs},
     sync::{Arc, Mutex},

quinn-h3/examples/h3_client.rs

@@ -70,7 +70,7 @@ async fn request(client: Client, url: &Url) -> Result<()> {
     let remote = (url.host_str().unwrap(), url.port().unwrap_or(4433))
         .to_socket_addrs()?
         .next()
-        .ok_or(anyhow!("couldn't resolve to an address"))?;
+        .ok_or_else(|| anyhow!("couldn't resolve to an address"))?;
     let (quic_driver, h3_driver, conn) = client
         .connect(&remote, url.host_str().unwrap_or("localhost"))?
         .await

quinn-h3/src/frame.rs

@@ -228,7 +228,7 @@ mod tests {
         buf.truncate(buf.len() - 1);
 
         let mut decoder = FrameDecoder::default();
-        assert_matches!(decoder.decode(&mut buf.into()), Ok(None));
+        assert_matches!(decoder.decode(&mut buf), Ok(None));
     }
 
     #[test]

quinn-h3/src/lib.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::identity_op)]
+
 #[macro_use]
 extern crate lazy_static;
 

quinn-h3/src/proto/frame.rs

@@ -387,7 +387,7 @@ mod tests {
 
     #[test]
     fn buffer_too_short() {
-        let mut buf = Cursor::new(&[04, 0x4, 0, 255, 128]);
+        let mut buf = Cursor::new(&[4, 4, 0, 255, 128]);
         let decoded = HttpFrame::decode(&mut buf);
         assert_eq!(decoded, Err(Error::Incomplete(6)));
     }

quinn-h3/src/qpack/dynamic.rs

@@ -854,10 +854,10 @@ mod tests {
         let field_map = encoder.table.field_map.as_ref().unwrap();
         assert_eq!(name_map.len(), 2);
         assert_eq!(field_map.len(), 2);
-        assert_eq!(name_map.get(&field_a.name).map(|x| *x), Some(1));
-        assert_eq!(name_map.get(&field_b.name).map(|x| *x), Some(2));
-        assert_eq!(field_map.get(&field_a).map(|x| *x), Some(1));
-        assert_eq!(field_map.get(&field_b).map(|x| *x), Some(2));
+        assert_eq!(name_map.get(&field_a.name).copied(), Some(1));
+        assert_eq!(name_map.get(&field_b.name).copied(), Some(2));
+        assert_eq!(field_map.get(&field_a).copied(), Some(1));
+        assert_eq!(field_map.get(&field_b).copied(), Some(2));
     }
 
     #[test]
@@ -963,20 +963,16 @@ mod tests {
                 field_c
             ]
         );
-        assert_eq!(name_map.get(&field_a.name).map(|x| *x), Some(3));
-        assert_eq!(name_map.get(&field_b.name).map(|x| *x), Some(5));
-        assert_eq!(field_map.get(&field_a).map(|x| *x), Some(3));
-        assert_eq!(field_map.get(&field_b).map(|x| *x), Some(2));
+        assert_eq!(name_map.get(&field_a.name).copied(), Some(3));
+        assert_eq!(name_map.get(&field_b.name).copied(), Some(5));
+        assert_eq!(field_map.get(&field_a).copied(), Some(3));
+        assert_eq!(field_map.get(&field_b).copied(), Some(2));
         assert_eq!(
-            field_map
-                .get(&field_b.with_value("New Value-B"))
-                .map(|x| *x),
+            field_map.get(&field_b.with_value("New Value-B")).copied(),
             Some(4)
         );
         assert_eq!(
-            field_map
-                .get(&field_b.with_value("Newer Value-B"))
-                .map(|x| *x),
+            field_map.get(&field_b.with_value("Newer Value-B")).copied(),
             Some(5)
         );
     }
@@ -999,8 +995,8 @@ mod tests {
         let name_map = encoder.table.name_map.as_ref().unwrap();
         let field_map = encoder.table.field_map.as_ref().unwrap();
         assert_eq!(encoder.table.fields, &[field_a.clone()]);
-        assert_eq!(name_map.get(&field_a.name).map(|x| *x), Some(1));
-        assert_eq!(field_map.get(&field_a).map(|x| *x), Some(1));
+        assert_eq!(name_map.get(&field_a.name).copied(), Some(1));
+        assert_eq!(field_map.get(&field_a).copied(), Some(1));
     }
 
     #[test]
@@ -1116,16 +1112,10 @@ mod tests {
             })
         );
         assert_eq!(
-            encoder
-                .table
-                .track_map
-                .as_ref()
-                .unwrap()
-                .get(&1)
-                .map(|x| *x),
+            encoder.table.track_map.as_ref().unwrap().get(&1).copied(),
             Some(1)
         );
-        assert_eq!(encoder.block_refs.get(&1).map(|x| *x), Some(1));
+        assert_eq!(encoder.block_refs.get(&1).copied(), Some(1));
     }
 
     #[test]

quinn-h3/src/qpack/prefix_int.rs

@@ -92,10 +92,10 @@ mod test {
 
     #[test]
     fn codec_5_bits() {
-        check_codec(5, 0b101, 10, &[0b10101010]);
-        check_codec(5, 0b101, 0, &[0b10100000]);
-        check_codec(5, 0b010, 1337, &[0b01011111, 154, 10]);
-        check_codec(5, 0b010, 31, &[0b01011111, 0]);
+        check_codec(5, 0b101, 10, &[0b1010_1010]);
+        check_codec(5, 0b101, 0, &[0b1010_0000]);
+        check_codec(5, 0b010, 1337, &[0b0101_1111, 154, 10]);
+        check_codec(5, 0b010, 31, &[0b0101_1111, 0]);
         check_codec(
             5,
             0b010,
@@ -106,8 +106,8 @@ mod test {
 
     #[test]
     fn codec_8_bits() {
-        check_codec(8, 0, 42, &[0b00101010]);
-        check_codec(8, 0, 424242, &[255, 179, 240, 25]);
+        check_codec(8, 0, 42, &[0b0010_1010]);
+        check_codec(8, 0, 424_242, &[255, 179, 240, 25]);
         check_codec(
             8,
             0,

quinn-h3/src/qpack/prefix_string/encode.rs

@@ -394,6 +394,7 @@ mod tests {
      * Appendix B.  Huffman Code
      */
     #[test]
+    #[allow(clippy::cognitive_complexity)]
     fn test_encode_single_value() {
         encoding![
              48 => (0b0000_0000 << 3) | /* padding */ 0b0000_0111; // '0'
@@ -1727,7 +1728,7 @@ mod tests {
                 // end filler
                 + 0b0011_1111,
         ];
-        let values: Vec<u8> = (0..=255).into_iter().collect();
+        let values: Vec<u8> = (0..=255).collect();
         let res = values.hpack_encode();
         assert_eq!(res, Ok(bytes));
     }

quinn-proto/src/frame.rs

@@ -813,6 +813,7 @@ mod test {
     use super::*;
 
     #[test]
+    #[allow(clippy::range_plus_one)]
     fn ack_coding() {
         const PACKETS: &[u64] = &[1, 2, 3, 5, 10, 11, 14];
         let mut ranges = RangeSet::new();
@@ -830,7 +831,7 @@ mod test {
         assert_eq!(frames.len(), 1);
         match frames[0] {
             Frame::Ack(ref ack) => {
-                let mut packets = ack.iter().flat_map(|x| x).collect::<Vec<_>>();
+                let mut packets = ack.iter().flatten().collect::<Vec<_>>();
                 packets.sort_unstable();
                 assert_eq!(&packets[..], PACKETS);
                 assert_eq!(ack.ecn, Some(ECN));

quinn-proto/src/tests/mod.rs

@@ -363,7 +363,7 @@ fn zero_rtt_happypath() {
         CLIENT_PORTS.lock().unwrap().next().unwrap(),
     );
     info!("resuming session");
-    let client_ch = pair.begin_connect(config.clone());
+    let client_ch = pair.begin_connect(config);
     assert!(pair.client_conn_mut(client_ch).has_0rtt());
     let s = pair.client_conn_mut(client_ch).open(Dir::Uni).unwrap();
     const MSG: &[u8] = b"Hello, 0-RTT!";
@@ -455,7 +455,7 @@ fn alpn_success() {
         .set_protocols(&["bar".into(), "quux".into(), "corge".into()]);
 
     // Establish normal connection
-    let client_conn = pair.begin_connect(client_config.clone());
+    let client_conn = pair.begin_connect(client_config);
     pair.drive();
     let server_conn = pair.server.assert_accept();
     assert_matches!(
@@ -757,7 +757,7 @@ fn server_hs_retransmit() {
     let mut pair = Pair::default();
     let client_ch = pair.begin_connect(client_config());
     pair.step();
-    assert!(pair.client.inbound.len() > 0); // Initial + Handshakes
+    assert!(!pair.client.inbound.is_empty()); // Initial + Handshakes
     pair.client.inbound.clear();
     pair.drive();
     assert_matches!(

quinn-proto/src/tests/util.rs

@@ -229,7 +229,7 @@ impl TestEndpoint {
                     DatagramEvent::ConnectionEvent(event) => {
                         self.conn_events
                             .entry(ch)
-                            .or_insert_with(|| VecDeque::new())
+                            .or_insert_with(VecDeque::new)
                             .push_back(event);
                     }
                 }
@@ -386,7 +386,6 @@ pub fn client_config() -> ClientConfig {
     ClientConfig {
         transport: Default::default(),
         crypto,
-        ..Default::default()
     }
 }
 

quinn/examples/client.rs

@@ -62,7 +62,7 @@ fn run(options: Opt) -> Result<()> {
     let remote = (url.host_str().unwrap(), url.port().unwrap_or(4433))
         .to_socket_addrs()?
         .next()
-        .ok_or(anyhow!("couldn't resolve to an address"))?;
+        .ok_or_else(|| anyhow!("couldn't resolve to an address"))?;
 
     let mut endpoint = quinn::Endpoint::builder();
     let mut client_config = quinn::ClientConfigBuilder::default();
@@ -102,7 +102,7 @@ fn run(options: Opt) -> Result<()> {
         .host
         .as_ref()
         .map_or_else(|| url.host_str(), |x| Some(&x))
-        .ok_or(anyhow!("no hostname specified"))?;
+        .ok_or_else(|| anyhow!("no hostname specified"))?;
     let r: Result<()> = runtime.block_on(async {
         let new_conn = endpoint
             .connect(&remote, &host)?