fix: clippy --fix

crates/mpz-common/Cargo.toml

@@ -25,7 +25,7 @@ serde = { workspace = true, features = ["derive"] }
 pollster.workspace = true
 rayon = { workspace = true, optional = true }
 cfg-if.workspace = true
-tokio = { workspace = true, optional = true, default-features = false }
+tokio = { workspace = true, optional = true }
 
 [dev-dependencies]
 tokio = { workspace = true, features = [

crates/mpz-common/src/cpu.rs

@@ -33,12 +33,12 @@ mod st {
 
         /// Executes a closure on the CPU backend.
         #[inline]
-        pub fn blocking<F, R>(f: F) -> impl Future<Output = R> + Send
+        pub async fn blocking<F, R>(f: F) -> R
         where
             F: FnOnce() -> R + Send + 'static,
             R: Send + 'static,
         {
-            async move { f() }
+            f()
         }
     }
 
@@ -88,18 +88,16 @@ mod rayon_backend {
         }
 
         /// Executes a closure on the CPU backend.
-        pub fn blocking<F, R>(f: F) -> impl Future<Output = R> + Send
+        pub async fn blocking<F, R>(f: F) -> R
         where
             F: FnOnce() -> R + Send + 'static,
             R: Send + 'static,
         {
-            async move {
-                let (sender, receiver) = oneshot::channel();
-                rayon::spawn(move || {
-                    _ = sender.send(f());
-                });
-                receiver.await.expect("worker thread does not drop channel")
-            }
+            let (sender, receiver) = oneshot::channel();
+            rayon::spawn(move || {
+                _ = sender.send(f());
+            });
+            receiver.await.expect("worker thread does not drop channel")
         }
     }
 

crates/mpz-common/src/id.rs

@@ -83,6 +83,7 @@ pub struct Counter(u32);
 
 impl Counter {
     /// Increments the counter in place, returning the previous value.
+    #[allow(clippy::should_implement_trait)]
     pub fn next(&mut self) -> Self {
         let prev = self.0;
         self.0 += 1;

crates/mpz-fields/src/lib.rs

@@ -164,6 +164,6 @@ mod tests {
         assert!(GetBit::<Lsb0>::get_bit(&a, 0));
 
         assert_eq!(b, T::two_pow(T::BIT_SIZE as u32 - 1));
-        assert!(GetBit::<Lsb0>::get_bit(&b, (T::BIT_SIZE - 1) as usize));
+        assert!(GetBit::<Lsb0>::get_bit(&b, T::BIT_SIZE - 1));
     }
 }

crates/mpz-garble-core/src/circuit.rs

@@ -19,7 +19,7 @@ impl EncryptedGate {
         Self(inner)
     }
 
-    pub(crate) fn to_bytes(&self) -> [u8; 32] {
+    pub(crate) fn to_bytes(self) -> [u8; 32] {
         let mut bytes = [0u8; 32];
         bytes[..16].copy_from_slice(&self.0[0].to_bytes());
         bytes[16..].copy_from_slice(&self.0[1].to_bytes());

crates/mpz-garble-core/src/evaluator.rs

@@ -68,20 +68,12 @@ pub struct EvaluatorOutput {
 }
 
 /// Garbled circuit evaluator.
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub struct Evaluator {
     /// Buffer for the active labels.
     buffer: Vec<Label>,
 }
 
-impl Default for Evaluator {
-    fn default() -> Self {
-        Self {
-            buffer: Default::default(),
-        }
-    }
-}
-
 impl Evaluator {
     /// Returns a consumer over the encrypted gates of a circuit.
     ///

crates/mpz-garble-core/src/generator.rs

@@ -77,20 +77,12 @@ pub struct GeneratorOutput {
 }
 
 /// Garbled circuit generator.
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub struct Generator {
     /// Buffer for the 0-bit labels.
     buffer: Vec<Label>,
 }
 
-impl Default for Generator {
-    fn default() -> Self {
-        Self {
-            buffer: Default::default(),
-        }
-    }
-}
-
 impl Generator {
     /// Returns an iterator over the encrypted gates of a circuit.
     ///
@@ -295,7 +287,7 @@ where
                     // If we have generated all AND gates, we can compute
                     // the rest of the "free" gates.
                     if !self.has_gates() {
-                        assert!(matches!(self.next(), None));
+                        assert!(self.next().is_none());
 
                         self.complete = true;
                     }
@@ -356,7 +348,7 @@ where
 
         let mut batch = [EncryptedGate::default(); N];
         let mut i = 0;
-        while let Some(gate) = self.0.next() {
+        for gate in self.0.by_ref() {
             batch[i] = gate;
             i += 1;
 

crates/mpz-garble-core/src/lib.rs

@@ -168,7 +168,7 @@ mod tests {
             .iter()
             .zip(full_outputs)
             .map(|(active_output, full_output)| {
-                full_output.commit().verify(&active_output).unwrap();
+                full_output.commit().verify(active_output).unwrap();
                 active_output.decode(&full_output.decoding()).unwrap()
             })
             .collect();
@@ -234,7 +234,7 @@ mod tests {
             .iter()
             .zip(full_outputs)
             .map(|(active_output, full_output)| {
-                full_output.commit().verify(&active_output).unwrap();
+                full_output.commit().verify(active_output).unwrap();
                 active_output.decode(&full_output.decoding()).unwrap()
             })
             .collect();

crates/mpz-garble/src/protocol/deap/vm.rs

@@ -107,7 +107,7 @@ where
                 deap.finalize(&mut self.ctx, &mut self.ot_recv).await
             }
             State::Child(_) => Err(FinalizationError::NotMainThread.into()),
-            State::Finalized => return Err(FinalizationError::AlreadyFinalized.into()),
+            State::Finalized => Err(FinalizationError::AlreadyFinalized.into()),
         }
     }
 }

crates/mpz-ot-core/src/test.rs

@@ -4,26 +4,28 @@ use mpz_core::Block;
 
 /// Asserts the correctness of correlated oblivious transfer.
 pub fn assert_cot(delta: Block, choices: &[bool], msgs: &[Block], received: &[Block]) {
-    assert!(choices.into_iter().zip(msgs.into_iter().zip(received)).all(
-        |(&choice, (&msg, &received))| {
+    assert!(choices
+        .iter()
+        .zip(msgs.iter().zip(received))
+        .all(|(&choice, (&msg, &received))| {
             if choice {
                 received == msg ^ delta
             } else {
                 received == msg
             }
-        }
-    ));
+        }));
 }
 
 /// Asserts the correctness of random oblivious transfer.
 pub fn assert_rot<T: Copy + PartialEq>(choices: &[bool], msgs: &[[T; 2]], received: &[T]) {
-    assert!(choices.into_iter().zip(msgs.into_iter().zip(received)).all(
-        |(&choice, (&msg, &received))| {
+    assert!(choices
+        .iter()
+        .zip(msgs.iter().zip(received))
+        .all(|(&choice, (&msg, &received))| {
             if choice {
                 received == msg[1]
             } else {
                 received == msg[0]
             }
-        }
-    ));
+        }));
 }

crates/mpz-ot/src/ideal/ot.rs

@@ -143,7 +143,8 @@ impl<Ctx: Context, T: Copy + Send + Sync + 'static> CommittedOTReceiver<Ctx, boo
     for IdealOTReceiver<T>
 {
     async fn reveal_choices(&mut self, ctx: &mut Ctx) -> Result<(), OTError> {
-        Ok(self.0.call(ctx, (), verify).await)
+        self.0.call(ctx, (), verify).await;
+        Ok(())
     }
 }