Apply suggestions from clippy to clean up code

src/codec.rs

@@ -29,12 +29,16 @@ impl Codec for VarLen {
         let first = buf.get_u8();
         let be_val = first & 0x3f;
         let val = match first >> 6 {
-            0 => be_val as u64,
-            1 => (be_val as u64) << 8 | (buf.get_u8() as u64),
-            2 => (be_val as u64) << 24 | (buf.get_u8() as u64) << 16 | (buf.get_u16_be() as u64),
+            0 => u64::from(be_val),
+            1 => u64::from(be_val) << 8 | u64::from(buf.get_u8()),
+            2 => {
+                u64::from(be_val) << 24 | u64::from(buf.get_u8()) << 16
+                    | u64::from(buf.get_u16_be())
+            }
             3 => {
-                (be_val as u64) << 56 | (buf.get_u8() as u64) << 48
-                    | (buf.get_u16_be() as u64) << 32 | (buf.get_u32_be() as u64)
+                u64::from(be_val) << 56 | u64::from(buf.get_u8()) << 48
+                    | u64::from(buf.get_u16_be()) << 32
+                    | u64::from(buf.get_u32_be())
             }
             v => panic!("impossible variable length encoding: {}", v),
         };

src/crypto.rs

@@ -99,7 +99,7 @@ impl PacketKey {
         let out = {
             let mut write = Cursor::new(out);
             write.put_u32_be(0);
-            write.put_u64_be(number as u64);
+            write.put_u64_be(u64::from(number));
             debug_assert_eq!(write.remaining(), 0);
             write.into_inner()
         };

src/endpoint.rs

@@ -169,6 +169,7 @@ where
         })
     }
 
+    #[allow(needless_pass_by_value)]
     pub fn queue_packet(&mut self, packet: Packet) -> QuicResult<()> {
         let key = self.encode_key(&packet.header);
         let len = packet.buf_len() + key.algorithm().tag_len();
@@ -187,6 +188,7 @@ where
         self.handle_packet(partial.finish(&key)?)
     }
 
+    #[allow(needless_pass_by_value)]
     fn handle_packet(&mut self, p: Packet) -> QuicResult<()> {
         match p.ptype() {
             Some(LongType::Initial) | Some(LongType::Handshake) => self.handle_handshake(&p),
@@ -230,7 +232,7 @@ where
         ];
 
         let mut wrote_handshake = false;
-        for frame in p.payload.iter() {
+        for frame in &p.payload {
             match frame {
                 Frame::Stream(f) if f.id == 0 => {
                     let (handshake, new_secret) =
@@ -280,7 +282,7 @@ where
                     }
                 }
                 Frame::PathChallenge(PathFrame(token)) => {
-                    payload.push(Frame::PathResponse(PathFrame(token.clone())));
+                    payload.push(Frame::PathResponse(PathFrame(*token)));
                 }
                 Frame::ApplicationClose(CloseFrame { code, reason }) => {
                     return Err(QuicError::ApplicationClose(*code, reason.clone()));

src/frame.rs

@@ -140,7 +140,7 @@ impl Codec for StreamFrame {
         buf.copy_to_slice(&mut data);
 
         StreamFrame {
-            id: id,
+            id,
             fin: first & 0x01 > 0,
             offset,
             len: if first & 0x02 > 0 { Some(len) } else { None },
@@ -158,7 +158,7 @@ pub struct AckFrame {
 
 impl BufLen for AckFrame {
     fn buf_len(&self) -> usize {
-        1 + VarLen(self.largest as u64).buf_len() + VarLen(self.ack_delay).buf_len()
+        1 + VarLen(u64::from(self.largest)).buf_len() + VarLen(self.ack_delay).buf_len()
             + VarLen((self.blocks.len() - 1) as u64).buf_len()
             + self.blocks
                 .iter()
@@ -170,10 +170,10 @@ impl BufLen for AckFrame {
 impl Codec for AckFrame {
     fn encode<T: BufMut>(&self, buf: &mut T) {
         buf.put_u8(0x0d);
-        VarLen(self.largest as u64).encode(buf);
+        VarLen(u64::from(self.largest)).encode(buf);
         VarLen(self.ack_delay).encode(buf);
         VarLen((self.blocks.len() - 1) as u64).encode(buf);
-        for ack in self.blocks.iter() {
+        for ack in &self.blocks {
             VarLen(ack.value()).encode(buf);
         }
     }

src/lib.rs

@@ -73,4 +73,4 @@ impl From<rustls::TLSError> for QuicError {
 
 pub type QuicResult<O> = std::result::Result<O, QuicError>;
 
-pub const QUIC_VERSION: u32 = 0xff00000b;
+pub const QUIC_VERSION: u32 = 0xff00_000b;

src/packet.rs

@@ -41,7 +41,7 @@ impl Packet {
             debug_assert_eq!(header_len, self.header.buf_len());
 
             let mut expected = header_len;
-            for frame in self.payload.iter() {
+            for frame in &self.payload {
                 frame.encode(&mut write);
                 expected += frame.buf_len();
             }
@@ -56,9 +56,8 @@ impl Packet {
             key.encrypt(self.header.number(), &header_buf, in_out, tag_len)?
         };
 
-        match self.header {
-            Header::Long { len, .. } => debug_assert_eq!(len, out_len as u64),
-            _ => {}
+        if let Header::Long { len, .. } = self.header {
+            debug_assert_eq!(len, out_len as u64);
         }
         Ok(header_len + out_len)
     }
@@ -241,15 +240,14 @@ impl Codec for Header {
             let key_phase = first & 0x40 == 0x40;
             let dst_cid = {
                 let bytes = buf.bytes();
-                let cid = ConnectionId::new(&bytes[..GENERATED_CID_LENGTH as usize]);
-                cid
+                ConnectionId::new(&bytes[..GENERATED_CID_LENGTH as usize])
             };
             buf.advance(GENERATED_CID_LENGTH as usize);
 
             let ptype = ShortType::from_byte(first & 3);
             let number = match ptype {
-                ShortType::One => buf.get_u8() as u32,
-                ShortType::Two => buf.get_u16_be() as u32,
+                ShortType::One => u32::from(buf.get_u8()),
+                ShortType::Two => u32::from(buf.get_u16_be()),
                 ShortType::Four => buf.get_u32_be(),
             };
 

src/parameters.rs

@@ -53,7 +53,7 @@ impl Codec for ServerTransportParameters {
     fn encode<T: BufMut>(&self, buf: &mut T) {
         buf.put_u32_be(self.negotiated_version);
         buf.put_u8((4 * self.supported_versions.len()) as u8);
-        for v in self.supported_versions.iter() {
+        for v in &self.supported_versions {
             buf.put_u32_be(*v);
         }
         self.parameters.encode(buf);
@@ -205,11 +205,11 @@ pub struct TransportParameters {
 impl Default for TransportParameters {
     fn default() -> Self {
         Self {
-            max_stream_data: 131072,
-            max_data: 1048576,
+            max_stream_data: 131_072,
+            max_data: 1_048_576,
             max_streams_bidi: 4,
             idle_timeout: 300,
-            max_packet_size: 65527,
+            max_packet_size: 65_527,
             stateless_reset_token: None,
             ack_delay_exponent: 3,
             max_stream_id_uni: 20,

src/streams.rs

@@ -66,9 +66,9 @@ impl Streams {
             }),
             None => {
                 let dir = Dir::from_id(id);
-                if Dir::Bidi == dir && id > me.max_recv_bidi {
-                    None
-                } else if Dir::Uni == dir && id > me.max_recv_uni {
+                if (Dir::Bidi == dir && id > me.max_recv_bidi)
+                    || (Dir::Uni == dir && id > me.max_recv_uni)
+                {
                     None
                 } else {
                     me.streams.insert(id, Stream::new());
@@ -90,7 +90,7 @@ pub struct StreamRef {
 impl StreamRef {
     pub fn get_offset(&self) -> u64 {
         let me = self.inner.lock().unwrap();
-        me.streams.get(&self.id).unwrap().offset
+        me.streams[&self.id].offset
     }
 
     pub fn set_offset(&mut self, new: u64) {
@@ -137,9 +137,10 @@ pub enum Dir {
 
 impl Dir {
     pub fn from_id(id: u64) -> Self {
-        match id & 2 == 2 {
-            true => Dir::Uni,
-            false => Dir::Bidi,
+        if id & 2 == 2 {
+            Dir::Uni
+        } else {
+            Dir::Bidi
         }
     }
 }

src/tls.rs

@@ -22,7 +22,7 @@ pub fn client_session(
     let pki_server_name = DNSNameRef::try_from_ascii_str(hostname)
         .map_err(|_| QuicError::InvalidDnsName(hostname.into()))?;
     Ok(ClientSession::new_quic(
-        &Arc::new(config.unwrap_or(build_client_config(None))),
+        &Arc::new(config.unwrap_or_else(|| build_client_config(None))),
         pki_server_name,
         to_vec(params),
     ))
@@ -106,4 +106,4 @@ fn to_vec<T: Codec>(val: &T) -> Vec<u8> {
     bytes
 }
 
-const ALPN_PROTOCOL: &'static str = "hq-11";
+const ALPN_PROTOCOL: &str = "hq-11";

src/types.rs

@@ -29,7 +29,7 @@ impl Copy for ConnectionId {}
 
 impl ConnectionId {
     pub fn new(bytes: &[u8]) -> Self {
-        debug_assert!(bytes.len() == 0 || (bytes.len() > 3 && bytes.len() < 19));
+        debug_assert!(bytes.is_empty() || (bytes.len() > 3 && bytes.len() < 19));
         let mut res = Self {
             len: bytes.len() as u8,
             bytes: [0; 18],