Address Clippy lints (#543)

.github/workflows/workspace.yml

@@ -65,7 +65,7 @@ jobs:
     - uses: dtolnay/rust-toolchain@nightly
       with:
         components: clippy
-    - run: cargo clippy --target x86_64-unknown-linux-gnu
+    - run: cargo clippy --target x86_64-unknown-linux-gnu --all-features
 
   rustfmt:
     name: Check formatting

curve25519-dalek-derive/tests/tests.rs

@@ -83,9 +83,7 @@ impl<T: Copy + core::ops::Sub> StructWithGenericsNoWhere<T> {
 #[unsafe_target_feature("sse2")]
 #[allow(dead_code)]
 impl<'a> From<&'a Struct> for () {
-    fn from(_: &'a Struct) -> Self {
-        ()
-    }
+    fn from(_: &'a Struct) -> Self {}
 }
 
 #[unsafe_target_feature("sse2")]
@@ -97,8 +95,6 @@ mod inner {
 
 #[unsafe_target_feature_specialize("sse2", "avx2", conditional("avx512ifma", disabled))]
 mod inner_spec {
-    use std;
-
     #[for_target_feature("sse2")]
     const CONST: u32 = 1;
 

curve25519-dalek/benches/dalek_benchmarks.rs

@@ -147,14 +147,14 @@ mod multiscalar_benches {
                     let static_size = total_size;
 
                     let static_points = construct_points(static_size);
-                    let precomp = VartimeEdwardsPrecomputation::new(&static_points);
+                    let precomp = VartimeEdwardsPrecomputation::new(static_points);
                     // Rerandomize the scalars for every call to prevent
                     // false timings from better caching (e.g., the CPU
                     // cache lifts exactly the right table entries for the
                     // benchmark into the highest cache levels).
                     b.iter_batched(
                         || construct_scalars(static_size),
-                        |scalars| precomp.vartime_multiscalar_mul(&scalars),
+                        |scalars| precomp.vartime_multiscalar_mul(scalars),
                         BatchSize::SmallInput,
                     );
                 },
@@ -182,7 +182,7 @@ mod multiscalar_benches {
 
                 let static_points = construct_points(static_size);
                 let dynamic_points = construct_points(dynamic_size);
-                let precomp = VartimeEdwardsPrecomputation::new(&static_points);
+                let precomp = VartimeEdwardsPrecomputation::new(static_points);
                 // Rerandomize the scalars for every call to prevent
                 // false timings from better caching (e.g., the CPU
                 // cache lifts exactly the right table entries for the

curve25519-dalek/src/edwards.rs

@@ -276,6 +276,7 @@ impl<'de> Deserialize<'de> for EdwardsPoint {
                 A: serde::de::SeqAccess<'de>,
             {
                 let mut bytes = [0u8; 32];
+                #[allow(clippy::needless_range_loop)]
                 for i in 0..32 {
                     bytes[i] = seq
                         .next_element()?
@@ -311,6 +312,7 @@ impl<'de> Deserialize<'de> for CompressedEdwardsY {
                 A: serde::de::SeqAccess<'de>,
             {
                 let mut bytes = [0u8; 32];
+                #[allow(clippy::needless_range_loop)]
                 for i in 0..32 {
                     bytes[i] = seq
                         .next_element()?

curve25519-dalek/src/ristretto.rs

@@ -388,6 +388,7 @@ impl<'de> Deserialize<'de> for RistrettoPoint {
                 A: serde::de::SeqAccess<'de>,
             {
                 let mut bytes = [0u8; 32];
+                #[allow(clippy::needless_range_loop)]
                 for i in 0..32 {
                     bytes[i] = seq
                         .next_element()?
@@ -423,6 +424,7 @@ impl<'de> Deserialize<'de> for CompressedRistretto {
                 A: serde::de::SeqAccess<'de>,
             {
                 let mut bytes = [0u8; 32];
+                #[allow(clippy::needless_range_loop)]
                 for i in 0..32 {
                     bytes[i] = seq
                         .next_element()?
@@ -1270,7 +1272,7 @@ mod test {
         let bp_compressed_ristretto = constants::RISTRETTO_BASEPOINT_POINT.compress();
         let bp_recaf = bp_compressed_ristretto.decompress().unwrap().0;
         // Check that bp_recaf differs from bp by a point of order 4
-        let diff = &constants::RISTRETTO_BASEPOINT_POINT.0 - bp_recaf;
+        let diff = constants::RISTRETTO_BASEPOINT_POINT.0 - bp_recaf;
         let diff4 = diff.mul_by_pow_2(2);
         assert_eq!(diff4.compress(), CompressedEdwardsY::identity());
     }
@@ -1681,7 +1683,7 @@ mod test {
         ];
         // Check that onewaymap(input) == output for all the above vectors
         for (input, output) in test_vectors {
-            let Q = RistrettoPoint::from_uniform_bytes(&input);
+            let Q = RistrettoPoint::from_uniform_bytes(input);
             assert_eq!(&Q.compress(), output);
         }
     }

curve25519-dalek/src/scalar.rs

@@ -436,13 +436,14 @@ impl<'de> Deserialize<'de> for Scalar {
                 A: serde::de::SeqAccess<'de>,
             {
                 let mut bytes = [0u8; 32];
+                #[allow(clippy::needless_range_loop)]
                 for i in 0..32 {
                     bytes[i] = seq
                         .next_element()?
                         .ok_or_else(|| serde::de::Error::invalid_length(i, &"expected 32 bytes"))?;
                 }
                 Option::from(Scalar::from_canonical_bytes(bytes))
-                    .ok_or_else(|| serde::de::Error::custom(&"scalar was not canonically encoded"))
+                    .ok_or_else(|| serde::de::Error::custom("scalar was not canonically encoded"))
             }
         }
 
@@ -1476,13 +1477,13 @@ pub(crate) mod test {
     #[cfg(feature = "alloc")]
     fn impl_product() {
         // Test that product works for non-empty iterators
-        let X_Y_vector = vec![X, Y];
+        let X_Y_vector = [X, Y];
         let should_be_X_times_Y: Scalar = X_Y_vector.iter().product();
         assert_eq!(should_be_X_times_Y, X_TIMES_Y);
 
         // Test that product works for the empty iterator
         let one = Scalar::ONE;
-        let empty_vector = vec![];
+        let empty_vector = [];
         let should_be_one: Scalar = empty_vector.iter().product();
         assert_eq!(should_be_one, one);
 
@@ -1507,13 +1508,13 @@ pub(crate) mod test {
     fn impl_sum() {
         // Test that sum works for non-empty iterators
         let two = Scalar::from(2u64);
-        let one_vector = vec![Scalar::ONE, Scalar::ONE];
+        let one_vector = [Scalar::ONE, Scalar::ONE];
         let should_be_two: Scalar = one_vector.iter().sum();
         assert_eq!(should_be_two, two);
 
         // Test that sum works for the empty iterator
         let zero = Scalar::ZERO;
-        let empty_vector = vec![];
+        let empty_vector = [];
         let should_be_zero: Scalar = empty_vector.iter().sum();
         assert_eq!(should_be_zero, zero);
 

ed25519-dalek/benches/ed25519_benchmarks.rs

@@ -64,8 +64,7 @@ mod ed25519_benches {
                     .collect();
                 let msg: &[u8] = b"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
                 let messages: Vec<&[u8]> = (0..size).map(|_| msg).collect();
-                let signatures: Vec<Signature> =
-                    keypairs.iter().map(|key| key.sign(&msg)).collect();
+                let signatures: Vec<Signature> = keypairs.iter().map(|key| key.sign(msg)).collect();
                 let verifying_keys: Vec<_> =
                     keypairs.iter().map(|key| key.verifying_key()).collect();
 

ed25519-dalek/src/batch.rs

@@ -176,7 +176,7 @@ pub fn verify_batch(
             let mut h: Sha512 = Sha512::default();
             h.update(signatures[i].r_bytes());
             h.update(verifying_keys[i].as_bytes());
-            h.update(&messages[i]);
+            h.update(messages[i]);
             *h.finalize().as_ref()
         })
         .collect();

ed25519-dalek/src/context.rs

@@ -80,6 +80,8 @@ impl<'k, 'v, K> Context<'k, 'v, K> {
 
 #[cfg(all(test, feature = "digest"))]
 mod test {
+    #![allow(clippy::unwrap_used)]
+
     use crate::{Signature, SigningKey, VerifyingKey};
     use curve25519_dalek::digest::Digest;
     use ed25519::signature::{DigestSigner, DigestVerifier};

ed25519-dalek/src/hazmat.rs

@@ -156,11 +156,11 @@ where
 /// [rfc8032]: https://tools.ietf.org/html/rfc8032#section-5.1
 #[cfg(feature = "digest")]
 #[allow(non_snake_case)]
-pub fn raw_sign_prehashed<'a, CtxDigest, MsgDigest>(
+pub fn raw_sign_prehashed<CtxDigest, MsgDigest>(
     esk: &ExpandedSecretKey,
     prehashed_message: MsgDigest,
     verifying_key: &VerifyingKey,
-    context: Option<&'a [u8]>,
+    context: Option<&[u8]>,
 ) -> Result<Signature, SignatureError>
 where
     MsgDigest: Digest<OutputSize = U64>,
@@ -204,6 +204,8 @@ where
 
 #[cfg(test)]
 mod test {
+    #![allow(clippy::unwrap_used)]
+
     use super::*;
 
     use rand::{rngs::OsRng, CryptoRng, RngCore};
@@ -226,8 +228,8 @@ mod test {
     #[test]
     fn sign_verify_nonspec() {
         // Generate the keypair
-        let mut rng = OsRng;
-        let esk = ExpandedSecretKey::random(&mut rng);
+        let rng = OsRng;
+        let esk = ExpandedSecretKey::random(rng);
         let vk = VerifyingKey::from(&esk);
 
         let msg = b"Then one day, a piano fell on my head";
@@ -245,8 +247,8 @@ mod test {
         use curve25519_dalek::digest::Digest;
 
         // Generate the keypair
-        let mut rng = OsRng;
-        let esk = ExpandedSecretKey::random(&mut rng);
+        let rng = OsRng;
+        let esk = ExpandedSecretKey::random(rng);
         let vk = VerifyingKey::from(&esk);
 
         // Hash the message

ed25519-dalek/src/signing.rs

@@ -700,14 +700,15 @@ impl<'d> Deserialize<'d> for SigningKey {
                 self,
                 bytes: &'de [u8],
             ) -> Result<Self::Value, E> {
-                SigningKey::try_from(bytes.as_ref()).map_err(E::custom)
+                SigningKey::try_from(bytes).map_err(E::custom)
             }
 
             fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
             where
                 A: serde::de::SeqAccess<'de>,
             {
                 let mut bytes = [0u8; 32];
+                #[allow(clippy::needless_range_loop)]
                 for i in 0..32 {
                     bytes[i] = seq
                         .next_element()?
@@ -797,11 +798,11 @@ impl ExpandedSecretKey {
     #[cfg(feature = "digest")]
     #[allow(non_snake_case)]
     #[inline(always)]
-    pub(crate) fn raw_sign_prehashed<'a, CtxDigest, MsgDigest>(
+    pub(crate) fn raw_sign_prehashed<CtxDigest, MsgDigest>(
         &self,
         prehashed_message: MsgDigest,
         verifying_key: &VerifyingKey,
-        context: Option<&'a [u8]>,
+        context: Option<&[u8]>,
     ) -> Result<Signature, SignatureError>
     where
         CtxDigest: Digest<OutputSize = U64>,

ed25519-dalek/src/verifying.rs

@@ -640,7 +640,7 @@ impl<'d> Deserialize<'d> for VerifyingKey {
                 self,
                 bytes: &'de [u8],
             ) -> Result<Self::Value, E> {
-                VerifyingKey::try_from(bytes.as_ref()).map_err(E::custom)
+                VerifyingKey::try_from(bytes).map_err(E::custom)
             }
 
             fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
@@ -649,6 +649,7 @@ impl<'d> Deserialize<'d> for VerifyingKey {
             {
                 let mut bytes = [0u8; 32];
 
+                #[allow(clippy::needless_range_loop)]
                 for i in 0..32 {
                     bytes[i] = seq
                         .next_element()?