add clippy rules for serialize crate (#930)

serialize/Cargo.toml

@@ -13,7 +13,10 @@ edition.workspace = true
 rust-version.workspace = true
 metadata.docs.rs.workspace = true
 package.metadata.release.workspace = true
-keywords = ["cryptography", "serialization" ]
+keywords = ["cryptography", "serialization"]
+
+[lints]
+workspace = true
 
 [dependencies]
 ark-serialize-derive = { workspace = true, optional = true }
@@ -27,11 +30,13 @@ rayon = { workspace = true, optional = true }
 sha2.workspace = true
 sha3.workspace = true
 blake2.workspace = true
-ark-test-curves = { workspace = true, default-features = false, features = [ "bls12_381_curve"] }
+ark-test-curves = { workspace = true, default-features = false, features = [
+    "bls12_381_curve",
+] }
 
 
 [features]
 default = []
-parallel = [ "rayon" ]
-std = [ "ark-std/std" ]
-derive = [ "ark-serialize-derive" ]
+parallel = ["rayon"]
+std = ["ark-std/std"]
+derive = ["ark-serialize-derive"]

serialize/src/error.rs

@@ -17,21 +17,21 @@ pub enum SerializationError {
 impl ark_std::error::Error for SerializationError {}
 
 impl From<io::Error> for SerializationError {
-    fn from(e: io::Error) -> SerializationError {
-        SerializationError::IoError(e)
+    fn from(e: io::Error) -> Self {
+        Self::IoError(e)
     }
 }
 
 impl fmt::Display for SerializationError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
         match self {
-            SerializationError::NotEnoughSpace => write!(
+            Self::NotEnoughSpace => write!(
                 f,
                 "the last byte does not have enough space to encode the extra info bits"
             ),
-            SerializationError::InvalidData => write!(f, "the input buffer contained invalid data"),
-            SerializationError::UnexpectedFlags => write!(f, "the call expects empty flags"),
-            SerializationError::IoError(err) => write!(f, "I/O error: {:?}", err),
+            Self::InvalidData => write!(f, "the input buffer contained invalid data"),
+            Self::UnexpectedFlags => write!(f, "the call expects empty flags"),
+            Self::IoError(err) => write!(f, "I/O error: {:?}", err),
         }
     }
 }

serialize/src/flags.rs

@@ -53,6 +53,6 @@ impl Flags for EmptyFlags {
 
     #[inline]
     fn from_u8(_: u8) -> Option<Self> {
-        Some(EmptyFlags)
+        Some(Self)
     }
 }

serialize/src/impls.rs

@@ -146,7 +146,7 @@ impl CanonicalDeserialize for usize {
     ) -> Result<Self, SerializationError> {
         let mut bytes = [0u8; core::mem::size_of::<u64>()];
         reader.read_exact(&mut bytes)?;
-        Ok(<u64>::from_le_bytes(bytes) as usize)
+        Ok(<u64>::from_le_bytes(bytes) as Self)
     }
 }
 
@@ -173,7 +173,7 @@ impl CanonicalDeserialize for BigUint {
         compress: Compress,
         validate: Validate,
     ) -> Result<Self, SerializationError> {
-        Ok(BigUint::from_bytes_le(&Vec::<u8>::deserialize_with_mode(
+        Ok(Self::from_bytes_le(&Vec::<u8>::deserialize_with_mode(
             reader, compress, validate,
         )?))
     }
@@ -234,7 +234,7 @@ impl<T: Valid> Valid for Option<T> {
     where
         Self: 'a,
     {
-        T::batch_check(batch.map(Option::as_ref).filter(Option::is_some).flatten())
+        T::batch_check(batch.map(Self::as_ref).filter(Option::is_some).flatten())
     }
 }
 
@@ -246,11 +246,9 @@ impl<T: CanonicalDeserialize> CanonicalDeserialize for Option<T> {
         validate: Validate,
     ) -> Result<Self, SerializationError> {
         let is_some = bool::deserialize_with_mode(&mut reader, compress, validate)?;
-        let data = if is_some {
-            Some(T::deserialize_with_mode(&mut reader, compress, validate)?)
-        } else {
-            None
-        };
+        let data = is_some
+            .then(|| T::deserialize_with_mode(&mut reader, compress, validate))
+            .transpose()?;
 
         Ok(data)
     }
@@ -287,7 +285,7 @@ impl<T: Send + Sync> CanonicalDeserialize for PhantomData<T> {
         _compress: Compress,
         _validate: Validate,
     ) -> Result<Self, SerializationError> {
-        Ok(PhantomData)
+        Ok(Self)
     }
 }
 
@@ -352,7 +350,7 @@ impl<T: CanonicalDeserialize + ToOwned + Sync + Send> CanonicalDeserialize
         compress: Compress,
         validate: Validate,
     ) -> Result<Self, SerializationError> {
-        Ok(ark_std::sync::Arc::new(T::deserialize_with_mode(
+        Ok(Self::new(T::deserialize_with_mode(
             reader, compress, validate,
         )?))
     }
@@ -398,7 +396,7 @@ where
 
 impl<T> CanonicalDeserialize for Cow<'_, T>
 where
-    T: ToOwned + Valid + Valid + Sync + Send,
+    T: ToOwned + Valid + Sync + Send,
     <T as ToOwned>::Owned: CanonicalDeserialize + Valid + Send,
 {
     #[inline]
@@ -420,7 +418,7 @@ impl<T: CanonicalSerialize, const N: usize> CanonicalSerialize for [T; N] {
         mut writer: W,
         compress: Compress,
     ) -> Result<(), SerializationError> {
-        for item in self.iter() {
+        for item in self {
             item.serialize_with_mode(&mut writer, compress)?;
         }
         Ok(())
@@ -465,7 +463,7 @@ impl<T: CanonicalDeserialize, const N: usize> CanonicalDeserialize for [T; N] {
                 Validate::No,
             )?);
         }
-        if let Validate::Yes = validate {
+        if validate == Validate::Yes {
             T::batch_check(array.iter())?
         }
         Ok(array.into_inner().ok().unwrap())
@@ -515,7 +513,7 @@ impl<T: CanonicalDeserialize> CanonicalDeserialize for Vec<T> {
         let len = u64::deserialize_with_mode(&mut reader, compress, validate)?
             .try_into()
             .map_err(|_| SerializationError::NotEnoughSpace)?;
-        let mut values = Vec::with_capacity(len);
+        let mut values = Self::with_capacity(len);
         for _ in 0..len {
             values.push(T::deserialize_with_mode(
                 &mut reader,
@@ -524,7 +522,7 @@ impl<T: CanonicalDeserialize> CanonicalDeserialize for Vec<T> {
             )?);
         }
 
-        if let Validate::Yes = validate {
+        if validate == Validate::Yes {
             T::batch_check(values.iter())?
         }
         Ok(values)
@@ -612,7 +610,7 @@ impl<T: CanonicalDeserialize> CanonicalDeserialize for VecDeque<T> {
         let len = u64::deserialize_with_mode(&mut reader, compress, validate)?
             .try_into()
             .map_err(|_| SerializationError::NotEnoughSpace)?;
-        let mut values = VecDeque::with_capacity(len);
+        let mut values = Self::with_capacity(len);
         for _ in 0..len {
             values.push_back(T::deserialize_with_mode(
                 &mut reader,
@@ -621,7 +619,7 @@ impl<T: CanonicalDeserialize> CanonicalDeserialize for VecDeque<T> {
             )?);
         }
 
-        if let Validate::Yes = validate {
+        if validate == Validate::Yes {
             T::batch_check(values.iter())?
         }
         Ok(values)
@@ -674,7 +672,7 @@ impl<T: CanonicalDeserialize> CanonicalDeserialize for LinkedList<T> {
         let len = u64::deserialize_with_mode(&mut reader, compress, validate)?
             .try_into()
             .map_err(|_| SerializationError::NotEnoughSpace)?;
-        let mut values = LinkedList::new();
+        let mut values = Self::new();
         for _ in 0..len {
             values.push_back(T::deserialize_with_mode(
                 &mut reader,
@@ -683,7 +681,7 @@ impl<T: CanonicalDeserialize> CanonicalDeserialize for LinkedList<T> {
             )?);
         }
 
-        if let Validate::Yes = validate {
+        if validate == Validate::Yes {
             T::batch_check(values.iter())?
         }
         Ok(values)
@@ -753,7 +751,7 @@ impl CanonicalDeserialize for String {
         validate: Validate,
     ) -> Result<Self, SerializationError> {
         let bytes = <Vec<u8>>::deserialize_with_mode(reader, compress, validate)?;
-        String::from_utf8(bytes).map_err(|_| SerializationError::InvalidData)
+        Self::from_utf8(bytes).map_err(|_| SerializationError::InvalidData)
     }
 }
 
@@ -822,7 +820,7 @@ where
     ) -> Result<(), SerializationError> {
         let len = self.len() as u64;
         len.serialize_with_mode(&mut writer, compress)?;
-        for (k, v) in self.iter() {
+        for (k, v) in self {
             k.serialize_with_mode(&mut writer, compress)?;
             v.serialize_with_mode(&mut writer, compress)?;
         }

serialize/src/lib.rs

@@ -232,7 +232,7 @@ pub trait CanonicalSerializeHashExt: CanonicalSerialize {
 impl<T: CanonicalSerialize> CanonicalSerializeHashExt for T {}
 
 #[inline]
-pub fn buffer_bit_byte_size(modulus_bits: usize) -> (usize, usize) {
+pub const fn buffer_bit_byte_size(modulus_bits: usize) -> (usize, usize) {
     let byte_size = buffer_byte_size(modulus_bits);
     ((byte_size * 8), byte_size)
 }

serialize/src/test.rs

@@ -50,7 +50,7 @@ impl CanonicalDeserialize for Dummy {
                 assert_eq!(<[u8; 2]>::deserialize_compressed(reader)?, [100u8, 200u8])
             },
         }
-        Ok(Dummy)
+        Ok(Self)
     }
 }
 
@@ -215,6 +215,7 @@ fn test_rc_arc() {
 }
 
 #[test]
+#[allow(clippy::zero_sized_map_values)]
 fn test_btreemap() {
     let mut map = BTreeMap::new();
     map.insert(0u64, Dummy);