chore: remove all #[allow(unused)] in co-circom

co-circom/co-circom/examples/groth16/cleanup.sh

@@ -1,4 +1,4 @@
 # rm all proof files
-rm proof.0.json proof.1.json proof.2.json
+rm -rf proof.0.json proof.1.json proof.2.json
 # delete all shared files
 find . -name "*.shared" -type f -delete

co-circom/co-circom/examples/plonk/cleanup.sh

@@ -1,4 +1,4 @@
 # rm all proof files
-rm proof.0.json proof.1.json proof.2.json
+rm -rf proof.0.json proof.1.json proof.2.json
 # delete all shared files
 find . -name "*.shared" -type f -delete

co-circom/co-groth16/src/groth16.rs

@@ -263,7 +263,6 @@ where
             c_domain.ifft_in_place(&mut ab);
             ifft_span.exit();
             let dist_pows_span = tracing::debug_span!("c: dist pows").entered();
-            #[allow(unused_mut)]
             ab.par_iter_mut()
                 .zip_eq(c_roots.par_iter())
                 .with_min_len(512)

co-circom/co-groth16/src/mpc/plain.rs

@@ -71,8 +71,7 @@ impl<P: Pairing> CircomGroth16Prover<P> for PlainGroth16Driver {
         coeffs: &mut [Self::ArithmeticShare],
         roots: &[P::ScalarField],
     ) {
-        #[allow(unused_mut)]
-        for (mut c, pow) in coeffs.iter_mut().zip(roots) {
+        for (c, pow) in coeffs.iter_mut().zip(roots) {
             *c *= pow;
         }
     }

co-circom/co-plonk/src/lib.rs

@@ -167,11 +167,10 @@ mod plonk_utils {
         poly: &mut Vec<T::ArithmeticShare>,
         coeff_rev: &[T::ArithmeticShare],
     ) {
-        #[allow(unused_mut)]
         poly.par_iter_mut()
             .zip(coeff_rev.par_iter().rev())
             .with_min_len(512)
-            .for_each(|(mut p, c)| {
+            .for_each(|(p, c)| {
                 *p = T::sub(*p, *c);
             });
         // Extend

co-circom/co-plonk/src/mpc/plain.rs

@@ -54,8 +54,7 @@ impl<P: Pairing> CircomPlonkProver<P> for PlainPlonkDriver {
     }
 
     fn neg_vec_in_place(&mut self, a: &mut [Self::ArithmeticShare]) {
-        #[allow(unused_mut)]
-        for mut a in a.iter_mut() {
+        for a in a.iter_mut() {
             *a = -*a;
         }
     }

co-circom/co-plonk/src/mpc/rep3.rs

@@ -61,8 +61,7 @@ impl<P: Pairing, N: Rep3Network> CircomPlonkProver<P> for Rep3PlonkDriver<N> {
     }
 
     fn neg_vec_in_place(&mut self, vec: &mut [Self::ArithmeticShare]) {
-        #[allow(unused_mut)]
-        for mut a in vec.iter_mut() {
+        for a in vec.iter_mut() {
             *a = arithmetic::neg(*a);
         }
     }

co-circom/co-plonk/src/round1.rs

@@ -71,8 +71,7 @@ impl<P: Pairing> std::fmt::Display for Round1Proof<P> {
 impl<P: Pairing, T: CircomPlonkProver<P>> Round1Challenges<P, T> {
     pub(super) fn random(driver: &mut T) -> PlonkProofResult<Self> {
         let mut b = core::array::from_fn(|_| T::ArithmeticShare::default());
-        #[allow(unused_mut)]
-        for mut x in b.iter_mut() {
+        for x in b.iter_mut() {
             *x = driver.rand()?;
         }
         Ok(Self { b })

co-circom/co-plonk/src/round5.rs

@@ -84,8 +84,7 @@ where
         let inv_beta = beta.inverse().expect("Highly unlikely to be zero");
         let inv_beta_neg = -inv_beta;
 
-        #[allow(unused_mut)]
-        for mut el in inout.iter_mut().take(n) {
+        for el in inout.iter_mut().take(n) {
             *el = T::mul_with_public(*el, inv_beta_neg);
         }
         for i in n..inout.len() {
@@ -101,8 +100,7 @@ where
             inout.resize(add_poly.len(), P::ScalarField::zero());
         }
 
-        #[allow(unused_mut)]
-        for (mut inout, add) in inout.iter_mut().zip(add_poly.iter()) {
+        for (inout, add) in inout.iter_mut().zip(add_poly.iter()) {
             *inout += *add;
         }
     }
@@ -116,8 +114,7 @@ where
             inout.resize(add_poly.len(), P::ScalarField::zero());
         }
 
-        #[allow(unused_mut)]
-        for (mut inout, add) in inout.iter_mut().zip(add_poly.iter()) {
+        for (inout, add) in inout.iter_mut().zip(add_poly.iter()) {
             *inout += *add * factor;
         }
     }
@@ -160,8 +157,8 @@ where
         let e24 = e2 + e4;
 
         let mut poly_r = zkey.qm_poly.coeffs.clone();
-        #[allow(unused_mut)]
-        for mut coeff in poly_r.iter_mut() {
+
+        for coeff in poly_r.iter_mut() {
             *coeff *= coef_ab;
         }
         Self::add_factor_poly(&mut poly_r.coeffs, &zkey.ql_poly.coeffs, proof.eval_a);
@@ -178,41 +175,33 @@ where
 
         let mut poly_r_shared = vec![T::ArithmeticShare::default(); len];
 
-        #[allow(unused_mut)]
-        for (mut inout, add) in poly_r_shared
+        for (inout, add) in poly_r_shared
             .iter_mut()
             .zip(polys.z.poly.clone().into_iter())
         {
             *inout = T::mul_with_public(add, e24);
         }
 
-        #[allow(unused_mut)]
-        for (mut inout, add) in poly_r_shared.iter_mut().zip(poly_r.iter()) {
+        for (inout, add) in poly_r_shared.iter_mut().zip(poly_r.iter()) {
             *inout = T::add_with_public(party_id, *inout, *add);
         }
 
         let mut tmp_poly = vec![T::ArithmeticShare::default(); len];
         let xin2 = xin.square();
-        #[allow(unused_mut)]
-        for (mut inout, add) in tmp_poly.iter_mut().zip(polys.t3.clone().into_iter()) {
+        for (inout, add) in tmp_poly.iter_mut().zip(polys.t3.clone().into_iter()) {
             *inout = T::mul_with_public(add, xin2);
         }
-        #[allow(unused_mut)]
-        for (mut inout, add) in tmp_poly.iter_mut().zip(polys.t2.clone().into_iter()) {
+        for (inout, add) in tmp_poly.iter_mut().zip(polys.t2.clone().into_iter()) {
             let tmp = T::mul_with_public(add, xin);
             *inout = T::add(*inout, tmp);
         }
-        #[allow(unused_mut)]
-        for (mut inout, add) in tmp_poly.iter_mut().zip(polys.t1.clone().into_iter()) {
+        for (inout, add) in tmp_poly.iter_mut().zip(polys.t1.clone().into_iter()) {
             *inout = T::add(*inout, add);
         }
-        #[allow(unused_mut)]
-        for mut inout in tmp_poly.iter_mut() {
+        for inout in tmp_poly.iter_mut() {
             *inout = T::mul_with_public(*inout, zh);
         }
-
-        #[allow(unused_mut)]
-        for (mut inout, sub) in poly_r_shared.iter_mut().zip(tmp_poly.iter()) {
+        for (inout, sub) in poly_r_shared.iter_mut().zip(tmp_poly.iter()) {
             *inout = T::sub(*inout, *sub);
         }