chore: clean up as usage, MAX

* `as` operator could cause all sorts of surprises, plus constants do not needed it because they can be written as `1_u8` or even `1u8`

Author: nyurik

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"))]

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 b & MSB == 0 || shift > (9 * 7) {
@@ -177,7 +177,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
         }

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,28 +46,25 @@ 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
         );
     }
 
     #[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]
         );
     }
@@ -77,7 +74,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
         );
     }
 
@@ -86,17 +83,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]
@@ -155,7 +149,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());
     }
@@ -203,7 +197,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

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>())
     }
 }