clippy

jolt-core/src/field/ark.rs

@@ -111,7 +111,7 @@ impl JoltField for ark_bn254::Fr {
             } else if val <= u32::MAX as u64 {
                 -<Self as JoltField>::from_u32(val as u32)
             } else {
-                -<Self as JoltField>::from_u64(val as u64)
+                -<Self as JoltField>::from_u64(val)
             }
         } else {
             let val = val as u64;
@@ -120,7 +120,7 @@ impl JoltField for ark_bn254::Fr {
             } else if val <= u32::MAX as u64 {
                 <Self as JoltField>::from_u32(val as u32)
             } else {
-                <Self as JoltField>::from_u64(val as u64)
+                <Self as JoltField>::from_u64(val)
             }
         }
     }

jolt-core/src/field/binius.rs

@@ -142,7 +142,7 @@ impl<F: BiniusSpecific> JoltField for BiniusField<F> {
             <Self as JoltField>::from_u64(-val as u64)
         }
     }
-    fn from_i128(val: i128) -> Self {
+    fn from_i128(_val: i128) -> Self {
         todo!()
     }
 

jolt-core/src/jolt/vm/instruction_lookups.rs

@@ -928,7 +928,7 @@ where
 
         let dim: Vec<MultilinearPolynomial<F>> = subtable_lookup_indices
             .into_par_iter()
-            .map(|access_sequence| MultilinearPolynomial::from(access_sequence))
+            .map(MultilinearPolynomial::from)
             .collect();
 
         let mut instruction_flag_bitvectors: Vec<Vec<u8>> =
@@ -941,7 +941,7 @@ where
 
         let instruction_flag_polys: Vec<MultilinearPolynomial<F>> = instruction_flag_bitvectors
             .into_par_iter()
-            .map(|flag_bitvector| MultilinearPolynomial::from(flag_bitvector))
+            .map(MultilinearPolynomial::from)
             .collect();
 
         let mut lookup_outputs = Self::compute_lookup_outputs(ops);

jolt-core/src/jolt/vm/read_write_memory.rs

@@ -243,7 +243,7 @@ fn map_to_polys<F: JoltField, const N: usize>(
     vals: [Vec<u32>; N],
 ) -> [MultilinearPolynomial<F>; N] {
     vals.into_par_iter()
-        .map(|vals| MultilinearPolynomial::from(vals))
+        .map(MultilinearPolynomial::from)
         .collect::<Vec<MultilinearPolynomial<F>>>()
         .try_into()
         .unwrap()
@@ -473,7 +473,9 @@ impl<F: JoltField> ReadWriteMemoryPolynomials<F> {
                 v_init,
             ]);
 
-        let polynomials = ReadWriteMemoryPolynomials {
+
+
+        ReadWriteMemoryPolynomials {
             a_ram,
             v_read_rd,
             v_read_rs1,
@@ -490,9 +492,7 @@ impl<F: JoltField> ReadWriteMemoryPolynomials<F> {
             v_init: Some(v_init),
             a_init_final: None,
             identity: None,
-        };
-
-        polynomials
+        }
     }
 
     /// Computes the shape of all commitments.

jolt-core/src/jolt/vm/timestamp_range_check.rs

@@ -1,5 +1,5 @@
 use super::{JoltCommitments, JoltPolynomials, JoltStuff};
-use crate::field::{JoltField, OptimizedMul};
+use crate::field::JoltField;
 use crate::lasso::memory_checking::{
     ExogenousOpenings, Initializable, StructuredPolynomialData, VerifierComputedOpening,
 };
@@ -711,7 +711,7 @@ where
             .chain(timestamp_openings.openings_mut().into_iter())
             .collect();
         let (read_write_evals, chis) =
-            MultilinearPolynomial::batch_evaluate(&read_write_polys, &r_opening);
+            MultilinearPolynomial::batch_evaluate(&read_write_polys, r_opening);
         for (opening, eval) in read_write_openings.into_iter().zip(read_write_evals.iter()) {
             *opening = *eval;
         }

jolt-core/src/lasso/memory_checking.rs

@@ -363,7 +363,7 @@ where
         let read_write_openings: Vec<&mut F> = openings
             .read_write_values_mut()
             .into_iter()
-            .chain(exogenous_openings.openings_mut().into_iter())
+            .chain(exogenous_openings.openings_mut())
             .collect();
 
         for (opening, eval) in read_write_openings.into_iter().zip(read_write_evals.iter()) {

jolt-core/src/msm/mod.rs

@@ -713,32 +713,6 @@ where
     result
 }
 
-fn make_digits_u64(scalar: u64, w: usize, num_bits: usize) -> impl Iterator<Item = i64> {
-    let radix: u64 = 1 << w;
-    let window_mask: u64 = radix - 1;
-    let mut carry = 0u64;
-
-    let digits_count = num_bits.div_ceil(w);
-    (0..digits_count).map(move |i| {
-        // Construct a buffer of bits of the scalar, starting at `bit_offset`.
-        let bit_offset = i * w;
-        let bit_idx = bit_offset % 64;
-        // Read the bits from the scalar
-        let bit_buf = scalar >> bit_idx;
-        // Read the actual coefficient value from the window
-        let coef = carry + (bit_buf & window_mask); // coef = [0, 2^r)
-
-        // Recenter coefficients from [0,2^w) to [-2^w/2, 2^w/2)
-        carry = (coef + radix / 2) >> w;
-        let mut digit = (coef as i64) - (carry << w) as i64;
-
-        if i == digits_count - 1 {
-            digit += (carry << w) as i64;
-        }
-        digit
-    })
-}
-
 /// The result of this function is only approximately `ln(a)`
 /// [`Explanation of usage`]
 ///

jolt-core/src/poly/commitment/hyperkzg.rs

@@ -133,39 +133,6 @@ where
     h
 }
 
-fn scalar_vector_muladd<P: Pairing>(
-    a: &mut [P::ScalarField],
-    v: &[P::ScalarField],
-    s: P::ScalarField,
-) where
-    <P as Pairing>::ScalarField: field::JoltField,
-    <P as Pairing>::G1: Icicle,
-{
-    assert!(a.len() >= v.len());
-    for i in 0..v.len() {
-        a[i] += s * v[i];
-    }
-}
-
-fn kzg_compute_batch_polynomial<P: Pairing>(
-    f: &[Vec<P::ScalarField>],
-    q_powers: Vec<P::ScalarField>,
-) -> Vec<P::ScalarField>
-where
-    <P as Pairing>::ScalarField: field::JoltField,
-    <P as Pairing>::G1: Icicle,
-{
-    let k = f.len(); // Number of polynomials we're batching
-
-    // Compute B(x) = f[0] + q*f[1] + q^2 * f[2] + ... q^(k-1) * f[k-1]
-    let mut B = f[0].clone();
-    for i in 1..k {
-        scalar_vector_muladd::<P>(&mut B, &f[i], q_powers[i]); // B += q_powers[i] * f[i]
-    }
-
-    B
-}
-
 fn kzg_open_batch<P: Pairing, ProofTranscript: Transcript>(
     f: &[MultilinearPolynomial<P::ScalarField>],
     u: &[P::ScalarField],

jolt-core/src/poly/commitment/kzg.rs

@@ -205,7 +205,7 @@ where
     pub fn commit_batch_with_mode(
         pk: &KZGProverKey<P>,
         polys: &[&MultilinearPolynomial<P::ScalarField>],
-        mode: CommitMode,
+        _mode: CommitMode,
     ) -> Result<Vec<P::G1Affine>, ProofVerifyError> {
         let g1_powers = &pk.g1_powers();
         let gpu_g1 = pk.gpu_g1();
@@ -283,7 +283,7 @@ where
         pk: &KZGProverKey<P>,
         coeffs: &[P::ScalarField],
         offset: usize,
-        mode: CommitMode,
+        _mode: CommitMode,
     ) -> Result<P::G1Affine, ProofVerifyError> {
         if pk.g1_powers().len() < coeffs.len() {
             return Err(ProofVerifyError::KeyLengthError(

jolt-core/src/poly/compact_polynomial.rs

@@ -2,7 +2,9 @@ use std::ops::Index;
 
 use crate::utils::math::Math;
 use crate::{field::JoltField, utils};
-use ark_serialize::{CanonicalDeserialize, CanonicalSerialize, Valid};
+use ark_serialize::{
+    CanonicalDeserialize, CanonicalSerialize, Compress, SerializationError, Valid, Validate,
+};
 use num_integer::Integer;
 
 use super::multilinear_polynomial::{BindingOrder, PolynomialBinding};
@@ -54,31 +56,31 @@ pub struct CompactPolynomial<T: SmallScalar, F: JoltField> {
 }
 
 impl<T: SmallScalar, F: JoltField> Valid for CompactPolynomial<T, F> {
-    fn check(&self) -> Result<(), ark_serialize::SerializationError> {
+    fn check(&self) -> Result<(), SerializationError> {
         unimplemented!("")
     }
 }
 
 impl<T: SmallScalar, F: JoltField> CanonicalDeserialize for CompactPolynomial<T, F> {
     fn deserialize_with_mode<R: std::io::Read>(
-        reader: R,
-        compress: ark_serialize::Compress,
-        validate: ark_serialize::Validate,
-    ) -> Result<Self, ark_serialize::SerializationError> {
+        _reader: R,
+        _compress: Compress,
+        _validate: Validate,
+    ) -> Result<Self, SerializationError> {
         unimplemented!("")
     }
 }
 
 impl<T: SmallScalar, F: JoltField> CanonicalSerialize for CompactPolynomial<T, F> {
     fn serialize_with_mode<W: std::io::Write>(
         &self,
-        writer: W,
-        compress: ark_serialize::Compress,
-    ) -> Result<(), ark_serialize::SerializationError> {
+        _writer: W,
+        _compress: Compress,
+    ) -> Result<(), SerializationError> {
         unimplemented!("")
     }
 
-    fn serialized_size(&self, compress: ark_serialize::Compress) -> usize {
+    fn serialized_size(&self, _compress: Compress) -> usize {
         unimplemented!("")
     }
 }
@@ -166,10 +168,6 @@ impl<T: SmallScalar, F: JoltField> PolynomialBinding<F> for CompactPolynomial<T,
         self.len = n;
     }
 
-    fn bind_parallel(&mut self, r: F, order: BindingOrder) {
-        todo!()
-    }
-
     fn final_sumcheck_claim(&self) -> F {
         assert_eq!(self.len, 1);
         self.bound_coeffs[0]

jolt-core/src/poly/multilinear_polynomial.rs

@@ -1,6 +1,6 @@
 use crate::utils::math::Math;
 use ark_serialize::{
-    CanonicalDeserialize, CanonicalSerialize, Compress, SerializationError, Valid,
+    CanonicalDeserialize, CanonicalSerialize, Compress, SerializationError, Valid, Validate,
 };
 use rayon::prelude::*;
 use strum_macros::EnumIter;
@@ -366,22 +366,22 @@ impl<'a, F: JoltField> TryFrom<&'a MultilinearPolynomial<F>> for &'a CompactPoly
 impl<F: JoltField> CanonicalSerialize for MultilinearPolynomial<F> {
     fn serialize_with_mode<W: std::io::Write>(
         &self,
-        mut writer: W,
-        compress: Compress,
+        _writer: W,
+        _compress: Compress,
     ) -> Result<(), SerializationError> {
         unimplemented!("")
     }
 
-    fn serialized_size(&self, compress: Compress) -> usize {
+    fn serialized_size(&self, _compress: Compress) -> usize {
         unimplemented!("")
     }
 }
 
 impl<F: JoltField> CanonicalDeserialize for MultilinearPolynomial<F> {
     fn deserialize_with_mode<R: std::io::Read>(
-        mut reader: R,
-        compress: Compress,
-        validate: ark_serialize::Validate,
+        _reader: R,
+        _compress: Compress,
+        _validate: Validate,
     ) -> Result<Self, SerializationError> {
         unimplemented!("")
     }
@@ -396,7 +396,6 @@ impl<F: JoltField> Valid for MultilinearPolynomial<F> {
 pub trait PolynomialBinding<F: JoltField> {
     fn is_bound(&self) -> bool;
     fn bind(&mut self, r: F, order: BindingOrder);
-    fn bind_parallel(&mut self, r: F, order: BindingOrder);
     fn final_sumcheck_claim(&self) -> F;
 }
 
@@ -433,11 +432,6 @@ impl<F: JoltField> PolynomialBinding<F> for MultilinearPolynomial<F> {
         }
     }
 
-    #[tracing::instrument(skip_all, name = "MultilinearPolynomial::bind_parallel")]
-    fn bind_parallel(&mut self, r: F, order: BindingOrder) {
-        todo!()
-    }
-
     fn final_sumcheck_claim(&self) -> F {
         match self {
             MultilinearPolynomial::LargeScalars(poly) => {
@@ -459,39 +453,39 @@ impl<F: JoltField> PolynomialEvaluation<F> for MultilinearPolynomial<F> {
         match self {
             MultilinearPolynomial::LargeScalars(poly) => poly.evaluate(r),
             MultilinearPolynomial::U8Scalars(poly) => {
-                let chis = EqPolynomial::evals_with_r2(&r);
+                let chis = EqPolynomial::evals_with_r2(r);
                 assert_eq!(chis.len(), poly.coeffs.len());
                 chis.par_iter()
                     .zip(poly.coeffs.par_iter())
                     .map(|(a_i, b_i)| b_i.field_mul(*a_i))
                     .sum()
             }
             MultilinearPolynomial::U16Scalars(poly) => {
-                let chis = EqPolynomial::evals_with_r2(&r);
+                let chis = EqPolynomial::evals_with_r2(r);
                 assert_eq!(chis.len(), poly.coeffs.len());
                 chis.par_iter()
                     .zip(poly.coeffs.par_iter())
                     .map(|(a_i, b_i)| b_i.field_mul(*a_i))
                     .sum()
             }
             MultilinearPolynomial::U32Scalars(poly) => {
-                let chis = EqPolynomial::evals_with_r2(&r);
+                let chis = EqPolynomial::evals_with_r2(r);
                 assert_eq!(chis.len(), poly.coeffs.len());
                 chis.par_iter()
                     .zip(poly.coeffs.par_iter())
                     .map(|(a_i, b_i)| b_i.field_mul(*a_i))
                     .sum()
             }
             MultilinearPolynomial::U64Scalars(poly) => {
-                let chis = EqPolynomial::evals_with_r2(&r);
+                let chis = EqPolynomial::evals_with_r2(r);
                 assert_eq!(chis.len(), poly.coeffs.len());
                 chis.par_iter()
                     .zip(poly.coeffs.par_iter())
                     .map(|(a_i, b_i)| b_i.field_mul(*a_i))
                     .sum()
             }
             MultilinearPolynomial::I64Scalars(poly) => {
-                let chis = EqPolynomial::evals_with_r2(&r);
+                let chis = EqPolynomial::evals_with_r2(r);
                 assert_eq!(chis.len(), poly.coeffs.len());
                 chis.par_iter()
                     .zip(poly.coeffs.par_iter())
@@ -505,10 +499,10 @@ impl<F: JoltField> PolynomialEvaluation<F> for MultilinearPolynomial<F> {
     fn batch_evaluate(polys: &[&Self], r: &[F]) -> (Vec<F>, Vec<F>) {
         let eq = EqPolynomial::evals(r);
 
-        if polys.iter().any(|poly| match poly {
-            MultilinearPolynomial::LargeScalars(_) => false,
-            _ => true,
-        }) {
+        if polys
+            .iter()
+            .any(|poly| !matches!(poly, MultilinearPolynomial::LargeScalars(_)))
+        {
             let eq_r2 = EqPolynomial::evals_with_r2(r);
             let evals: Vec<F> = polys
                 .into_par_iter()

jolt-core/src/poly/spartan_interleaved_poly.rs

@@ -1,5 +1,4 @@
 use super::{
-    dense_mlpoly::DensePolynomial,
     multilinear_polynomial::MultilinearPolynomial,
     sparse_interleaved_poly::SparseCoefficient,
     split_eq_poly::SplitEqPolynomial,
@@ -405,6 +404,7 @@ impl<F: JoltField> SpartanInterleavedPolynomial<F> {
 
         let total_output_len = output_sizes.iter().sum();
         self.bound_coeffs = Vec::with_capacity(total_output_len);
+        #[allow(clippy::uninit_vec)]
         unsafe {
             self.bound_coeffs.set_len(total_output_len);
         }