Merge pull request #39 from nyurik/cleanup

dermesser · web-flow · commit af91eaadfcee · 2025-10-28T20:35:51.000+01:00
chore: clean up `as` usage, MAX
diff --git a/src/fixed_tests.rs b/src/fixed_tests.rs
@@ -12,63 +12,63 @@ mod tests {
 
     #[test]
     fn test_u32_enc() {
-        let result = (32 as u32).encode_fixed_vec();
+        let result = 32_u32.encode_fixed_vec();
         assert_eq!(result, vec![32, 0, 0, 0]);
     }
     #[test]
     fn test_u16_enc() {
-        let result = (256 as u16).encode_fixed_vec();
+        let result = 256_u16.encode_fixed_vec();
         assert_eq!(result, vec![0, 1]);
     }
     #[test]
     fn test_u16_endian() {
-        let le = 1 as u16;
+        let le = 1_u16;
         let be = le.switch_endianness();
         assert_eq!(be, 256);
     }
     #[test]
     fn test_u32_endian() {
-        let le = 1 as u32;
+        let le = 1_u32;
         let be = le.switch_endianness();
         assert_eq!(be, 1 << 24);
         assert_eq!(be.switch_endianness(), 1);
     }
     #[test]
-    fn test_allones_endian() {
+    fn test_all_ones_endian() {
         assert_eq!(u64::MAX.switch_endianness(), u64::MAX);
     }
     #[test]
     fn test_signed_endian() {
         // x86: two's complement, LE.
-        let le = -2 as i16;
+        let le = -2_i16;
         let be = le.switch_endianness();
         assert_eq!(be, -257);
     }
     #[test]
     fn test_u8_enc() {
-        let result = (255 as u8).encode_fixed_vec();
+        let result = 255_u8.encode_fixed_vec();
         assert_eq!(result, vec![255]);
     }
     #[test]
     fn test_i8_enc() {
-        let result = (-1 as i8).encode_fixed_vec();
+        let result = (-1_i8).encode_fixed_vec();
         assert_eq!(result, vec![255]);
     }
     #[test]
     fn test_i16_enc() {
-        let result = (-32768 as i16).encode_fixed_vec();
+        let result = (-32768_i16).encode_fixed_vec();
         assert_eq!(result, vec![0, 128]);
     }
     #[test]
     fn test_i32_enc() {
-        let result = (-32767 as i32).encode_fixed_vec();
+        let result = (-32767_i32).encode_fixed_vec();
         assert_eq!(result, vec![1, 128, 255, 255]);
     }
 
     // This must fail to compile:
     /*
     fn test() -> &'static [u8] {
-        let int = -32767 as i32;
+        let int = -32767_i32;
         let result = int.encode_fixed_light();
         assert_eq!(result, &[1, 128, 255, 255]);
         result
@@ -77,7 +77,7 @@ mod tests {
 
     #[test]
     fn test_i32_enc_light() {
-        let int = -32767 as i32;
+        let int = -32767_i32;
         let result = int.encode_fixed_light();
         assert_eq!(result, [1, 128, 255, 255]);
     }
@@ -137,8 +137,8 @@ mod tests {
     #[should_panic]
     #[test]
     fn test_invalid_encode_size() {
-        let mut buf = [0 as u8; 4];
-        (11 as u64).encode_fixed(&mut buf).unwrap();
+        let mut buf = [0_u8; 4];
+        11_u64.encode_fixed(&mut buf).unwrap();
     }
 
     #[cfg(any(feature = "tokio_async", feature = "futures_async"))]
diff --git a/src/varint.rs b/src/varint.rs
@@ -2,7 +2,7 @@ use std::mem::size_of;
 
 /// Most-significant byte, == 0x80
 pub const MSB: u8 = 0b1000_0000;
-/// All bits except for the most significant. Can be used as bitmask to drop the most-signficant
+/// All bits except for the most significant. Can be used as bitmask to drop the most-significant
 /// bit using `&` (binary-and).
 const DROP_MSB: u8 = 0b0111_1111;
 
@@ -134,9 +134,9 @@ impl VarInt for u64 {
         let mut shift = 0;
 
         let mut success = false;
-        for b in src.iter() {
+        for b in src {
             let msb_dropped = b & DROP_MSB;
-            result |= (msb_dropped as u64) << shift;
+            result |= u64::from(msb_dropped) << shift;
             shift += 7;
 
             if shift > (9 * 7) {
@@ -180,7 +180,7 @@ impl VarInt for i64 {
     #[inline]
     fn decode_var(src: &[u8]) -> Option<(Self, usize)> {
         if let Some((result, size)) = u64::decode_var(src) {
-            Some((zigzag_decode(result) as Self, size))
+            Some((zigzag_decode(result), size))
         } else {
             None
         }
diff --git a/src/varint_tests.rs b/src/varint_tests.rs
@@ -11,29 +11,29 @@ mod tests {
 
     #[test]
     fn test_required_space() {
-        assert_eq!((0 as u32).required_space(), 1);
-        assert_eq!((1 as u32).required_space(), 1);
-        assert_eq!((128 as u32).required_space(), 2);
-        assert_eq!((16384 as u32).required_space(), 3);
-        assert_eq!((2097151 as u32).required_space(), 3);
-        assert_eq!((2097152 as u32).required_space(), 4);
+        assert_eq!(0_u32.required_space(), 1);
+        assert_eq!(1_u32.required_space(), 1);
+        assert_eq!(128_u32.required_space(), 2);
+        assert_eq!(16384_u32.required_space(), 3);
+        assert_eq!(2097151_u32.required_space(), 3);
+        assert_eq!(2097152_u32.required_space(), 4);
     }
 
     #[test]
     fn test_encode_u64() {
-        assert_eq!((0 as u32).encode_var_vec(), vec![0b00000000]);
-        assert_eq!((300 as u32).encode_var_vec(), vec![0b10101100, 0b00000010]);
+        assert_eq!(0_u32.encode_var_vec(), vec![0b00000000]);
+        assert_eq!(300_u32.encode_var_vec(), vec![0b10101100, 0b00000010]);
     }
 
     #[test]
     fn test_identity_u64() {
-        for i in 1 as u64..100 {
+        for i in 1_u64..100 {
             assert_eq!(
                 u64::decode_var(i.encode_var_vec().as_slice()).unwrap(),
                 (i, 1)
             );
         }
-        for i in 16400 as u64..16500 {
+        for i in 16400_u64..16500 {
             assert_eq!(
                 u64::decode_var(i.encode_var_vec().as_slice()).unwrap(),
                 (i, 3)
@@ -46,7 +46,7 @@ mod tests {
         let max_vec_encoded = vec![0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01];
         assert_eq!(
             u64::decode_var(max_vec_encoded.as_slice()).unwrap().0,
-            u64::max_value()
+            u64::MAX
         );
     }
 
@@ -58,22 +58,19 @@ mod tests {
 
     #[test]
     fn test_encode_i64() {
-        assert_eq!((0 as i64).encode_var_vec(), (0 as u32).encode_var_vec());
-        assert_eq!((150 as i64).encode_var_vec(), (300 as u32).encode_var_vec());
+        assert_eq!(0_i64.encode_var_vec(), 0_u32.encode_var_vec());
+        assert_eq!(150_i64.encode_var_vec(), 300_u32.encode_var_vec());
+        assert_eq!((-150_i64).encode_var_vec(), 299_u32.encode_var_vec());
         assert_eq!(
-            (-150 as i64).encode_var_vec(),
-            (299 as u32).encode_var_vec()
+            (-2147483648_i64).encode_var_vec(),
+            4294967295_u64.encode_var_vec()
         );
         assert_eq!(
-            (-2147483648 as i64).encode_var_vec(),
-            (4294967295 as u64).encode_var_vec()
-        );
-        assert_eq!(
-            (i64::max_value() as i64).encode_var_vec(),
+            i64::MAX.encode_var_vec(),
             &[0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01]
         );
         assert_eq!(
-            (i64::min_value() as i64).encode_var_vec(),
+            i64::MIN.encode_var_vec(),
             &[0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01]
         );
     }
@@ -83,7 +80,7 @@ mod tests {
         let min_vec_encoded = vec![0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01];
         assert_eq!(
             i64::decode_var(min_vec_encoded.as_slice()).unwrap().0,
-            i64::min_value()
+            i64::MIN
         );
     }
 
@@ -92,17 +89,14 @@ mod tests {
         let max_vec_encoded = vec![0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01];
         assert_eq!(
             i64::decode_var(max_vec_encoded.as_slice()).unwrap().0,
-            i64::max_value()
+            i64::MAX
         );
     }
 
     #[test]
     fn test_encode_i16() {
-        assert_eq!((150 as i16).encode_var_vec(), (300 as u32).encode_var_vec());
-        assert_eq!(
-            (-150 as i16).encode_var_vec(),
-            (299 as u32).encode_var_vec()
-        );
+        assert_eq!(150_i16.encode_var_vec(), 300_u32.encode_var_vec());
+        assert_eq!((-150_i16).encode_var_vec(), 299_u32.encode_var_vec());
     }
 
     #[test]
@@ -161,7 +155,7 @@ mod tests {
 
     #[test]
     fn test_unterminated_varint() {
-        let buf = vec![0xff as u8; 12];
+        let buf = vec![0xff_u8; 12];
         let mut read = buf.as_slice();
         assert!(read.read_varint::<u64>().is_err());
     }
@@ -209,7 +203,7 @@ mod tests {
 
     #[test]
     fn test_regression_22() {
-        let encoded: Vec<u8> = (0x112233 as u64).encode_var_vec();
+        let encoded: Vec<u8> = 0x112233_u64.encode_var_vec();
         assert_eq!(
             encoded.as_slice().read_varint::<i8>().unwrap_err().kind(),
             std::io::ErrorKind::InvalidData
diff --git a/src/writer.rs b/src/writer.rs
@@ -60,18 +60,18 @@ pub trait FixedIntAsyncWriter {
 impl<AW: AsyncWrite + Unpin> FixedIntAsyncWriter for AW {
     async fn write_fixedint_async<FI: FixedInt>(&mut self, n: FI) -> Result<usize> {
         let mut buf = [0_u8; 8];
-        n.encode_fixed(&mut buf[..std::mem::size_of::<FI>()]);
-        self.write_all(&buf[..std::mem::size_of::<FI>()]).await?;
-        Ok(std::mem::size_of::<FI>())
+        n.encode_fixed(&mut buf[..size_of::<FI>()]);
+        self.write_all(&buf[..size_of::<FI>()]).await?;
+        Ok(size_of::<FI>())
     }
 }
 
 impl<W: Write> FixedIntWriter for W {
     fn write_fixedint<FI: FixedInt>(&mut self, n: FI) -> Result<usize> {
         let mut buf = [0_u8; 8];
-        n.encode_fixed(&mut buf[..std::mem::size_of::<FI>()]);
+        n.encode_fixed(&mut buf[..size_of::<FI>()]);
 
-        self.write_all(&buf[..std::mem::size_of::<FI>()])?;
-        Ok(std::mem::size_of::<FI>())
+        self.write_all(&buf[..size_of::<FI>()])?;
+        Ok(size_of::<FI>())
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -60,18 +60,18 @@ pub trait FixedIntAsyncWriter {`
`60`	`60`	`impl<AW: AsyncWrite + Unpin> FixedIntAsyncWriter for AW {`
`61`	`61`	`async fn write_fixedint_async<FI: FixedInt>(&mut self, n: FI) -> Result<usize> {`
`62`	`62`	`let mut buf = [0_u8; 8];`
`63`		`- n.encode_fixed(&mut buf[..std::mem::size_of::<FI>()]);`
`64`		`- self.write_all(&buf[..std::mem::size_of::<FI>()]).await?;`
`65`		`- Ok(std::mem::size_of::<FI>())`
	`63`	`+ n.encode_fixed(&mut buf[..size_of::<FI>()]);`
	`64`	`+ self.write_all(&buf[..size_of::<FI>()]).await?;`
	`65`	`+ Ok(size_of::<FI>())`
`66`	`66`	`}`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`impl<W: Write> FixedIntWriter for W {`
`70`	`70`	`fn write_fixedint<FI: FixedInt>(&mut self, n: FI) -> Result<usize> {`
`71`	`71`	`let mut buf = [0_u8; 8];`
`72`		`- n.encode_fixed(&mut buf[..std::mem::size_of::<FI>()]);`
	`72`	`+ n.encode_fixed(&mut buf[..size_of::<FI>()]);`
`73`	`73`
`74`		`- self.write_all(&buf[..std::mem::size_of::<FI>()])?;`
`75`		`- Ok(std::mem::size_of::<FI>())`
	`74`	`+ self.write_all(&buf[..size_of::<FI>()])?;`
	`75`	`+ Ok(size_of::<FI>())`
`76`	`76`	`}`
`77`	`77`	`}`