fix: address clippy complaints

halo2_backend/src/poly/domain.rs

@@ -286,7 +286,7 @@ impl<F: WithSmallOrderMulGroup<3>> EvaluationDomain<F> {
         // evaluation domain might be slightly larger than necessary because
         // it always lies on a power-of-two boundary.
         a.values
-            .truncate((&self.n * self.quotient_poly_degree) as usize);
+            .truncate((self.n * self.quotient_poly_degree) as usize);
 
         a.values
     }

halo2_backend/src/poly/ipa/commitment/prover.rs

@@ -112,8 +112,8 @@ pub fn create_proof<
         let value_r_j = compute_inner_product(&p_prime[0..half], &b[half..]);
         let l_j_randomness = C::Scalar::random(&mut rng);
         let r_j_randomness = C::Scalar::random(&mut rng);
-        let l_j = l_j + &best_multiexp(&[value_l_j * &z, l_j_randomness], &[params.u, params.w]);
-        let r_j = r_j + &best_multiexp(&[value_r_j * &z, r_j_randomness], &[params.u, params.w]);
+        let l_j = l_j + best_multiexp(&[value_l_j * z, l_j_randomness], &[params.u, params.w]);
+        let r_j = r_j + best_multiexp(&[value_r_j * z, r_j_randomness], &[params.u, params.w]);
         let l_j = l_j.to_affine();
         let r_j = r_j.to_affine();
 
@@ -127,8 +127,8 @@ pub fn create_proof<
         // Collapse `p_prime` and `b`.
         // TODO: parallelize
         for i in 0..half {
-            p_prime[i] = p_prime[i] + &(p_prime[i + half] * &u_j_inv);
-            b[i] = b[i] + &(b[i + half] * &u_j);
+            p_prime[i] = p_prime[i] + (p_prime[i + half] * u_j_inv);
+            b[i] = b[i] + (b[i + half] * u_j);
         }
         p_prime.truncate(half);
         b.truncate(half);
@@ -138,8 +138,8 @@ pub fn create_proof<
         g_prime.truncate(half);
 
         // Update randomness (the synthetic blinding factor at the end)
-        f += &(l_j_randomness * &u_j_inv);
-        f += &(r_j_randomness * &u_j);
+        f += l_j_randomness * u_j_inv;
+        f += r_j_randomness * u_j;
     }
 
     // We have fully collapsed `p_prime`, `b`, `G'`
@@ -160,7 +160,7 @@ fn parallel_generator_collapse<C: CurveAffine>(g: &mut [C], challenge: C::Scalar
         let g_hi = &g_hi[start..];
         let mut tmp = Vec::with_capacity(g_lo.len());
         for (g_lo, g_hi) in g_lo.iter().zip(g_hi.iter()) {
-            tmp.push(g_lo.to_curve() + &(*g_hi * challenge));
+            tmp.push(g_lo.to_curve() + *g_hi * challenge);
         }
         C::Curve::batch_normalize(&tmp, g_lo);
     });

halo2_backend/src/poly/ipa/commitment/verifier.rs

@@ -75,7 +75,7 @@ pub fn verify_proof<'params, C: CurveAffine, E: EncodedChallenge<C>, T: Transcri
     let f = transcript.read_scalar().map_err(|_| Error::SamplingError)?;
     let b = compute_b(x, &u);
 
-    msm.add_to_u_scalar(neg_c * &b * &z);
+    msm.add_to_u_scalar(neg_c * b * z);
     msm.add_to_w_scalar(-f);
 
     let guard = GuardIPA {
@@ -93,7 +93,7 @@ fn compute_b<F: Field>(x: F, u: &[F]) -> F {
     let mut tmp = F::ONE;
     let mut cur = x;
     for u_j in u.iter().rev() {
-        tmp *= F::ONE + &(*u_j * &cur);
+        tmp *= F::ONE + (*u_j * cur);
         cur *= cur;
     }
     tmp

halo2_backend/src/poly/ipa/msm.rs

@@ -126,8 +126,8 @@ impl<'a, C: CurveAffine> MSM<C> for MSMIPA<'a, C> {
             other.0 *= factor;
         }
 
-        self.w_scalar = self.w_scalar.map(|a| a * &factor);
-        self.u_scalar = self.u_scalar.map(|a| a * &factor);
+        self.w_scalar = self.w_scalar.map(|a| a * factor);
+        self.u_scalar = self.u_scalar.map(|a| a * factor);
     }
 
     fn check(&self) -> bool {
@@ -207,12 +207,12 @@ impl<'a, C: CurveAffine> MSMIPA<'a, C> {
     }
     /// Add to `w_scalar`
     pub fn add_to_w_scalar(&mut self, scalar: C::Scalar) {
-        self.w_scalar = self.w_scalar.map_or(Some(scalar), |a| Some(a + &scalar));
+        self.w_scalar = self.w_scalar.map_or(Some(scalar), |a| Some(a + scalar));
     }
 
     /// Add to `u_scalar`
     pub fn add_to_u_scalar(&mut self, scalar: C::Scalar) {
-        self.u_scalar = self.u_scalar.map_or(Some(scalar), |a| Some(a + &scalar));
+        self.u_scalar = self.u_scalar.map_or(Some(scalar), |a| Some(a + scalar));
     }
 }
 

halo2_backend/src/poly/ipa/multiopen/prover.rs

@@ -112,7 +112,7 @@ impl<'params, C: CurveAffine> Prover<'params, IPACommitmentScheme<C>> for Prover
             |(q_prime_poly, q_prime_blind), (poly, blind)| {
                 (
                     q_prime_poly * *x_4 + &poly.unwrap(),
-                    Blind((q_prime_blind.0 * &(*x_4)) + &blind.0),
+                    Blind((q_prime_blind.0 * (*x_4)) + blind.0),
                 )
             },
         );

halo2_backend/src/poly/ipa/multiopen/verifier.rs

@@ -120,10 +120,10 @@ impl<'params, C: CurveAffine> Verifier<'params, IPACommitmentScheme<C>>
                 |msm_eval, ((points, evals), proof_eval)| {
                     let r_poly = lagrange_interpolate(points, evals);
                     let r_eval = eval_polynomial(&r_poly, *x_3);
-                    let eval = points.iter().fold(*proof_eval - &r_eval, |eval, point| {
-                        eval * &(*x_3 - point).invert().unwrap()
+                    let eval = points.iter().fold(*proof_eval - r_eval, |eval, point| {
+                        eval * (*x_3 - point).invert().unwrap()
                     });
-                    msm_eval * &(*x_2) + &eval
+                    msm_eval * (*x_2) + eval
                 },
             );
 
@@ -138,7 +138,7 @@ impl<'params, C: CurveAffine> Verifier<'params, IPACommitmentScheme<C>>
             |(mut msm, msm_eval), ((q_commitment, _), q_eval)| {
                 msm.scale(*x_4);
                 msm.add_msm(&q_commitment);
-                (msm, msm_eval * &(*x_4) + q_eval)
+                (msm, msm_eval * (*x_4) + q_eval)
             },
         );