Merge pull request #11 from hero78119/feat/upgrade_toolchain

hero78119 · web-flow · commit 859a252aec0b · 2025-09-29T17:53:54.000+08:00
upgrade toolchain and clippy fix
diff --git a/.github/workflows/lints.yml b/.github/workflows/lints.yml
@@ -25,7 +25,7 @@ jobs:
           components: rustfmt, clippy
           targets: riscv32im-unknown-none-elf
           # TODO: figure out way to keep this in sync with rust-toolchain.toml automatically
-          toolchain: nightly-2025-03-25
+          toolchain: nightly-2025-08-18
       - name: Cargo cache
         uses: actions/cache@v4
         with:
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
@@ -24,7 +24,7 @@ jobs:
         with:
           targets: riscv32im-unknown-none-elf
           # TODO: figure out way to keep this in sync with rust-toolchain.toml automatically
-          toolchain: nightly-2025-03-25
+          toolchain: nightly-2025-08-18
       - name: Cargo cache
         uses: actions/cache@v4
         with:
diff --git a/crates/multilinear_extensions/src/lib.rs b/crates/multilinear_extensions/src/lib.rs
@@ -1,6 +1,5 @@
 #![deny(clippy::cargo)]
 #![feature(decl_macro)]
-#![feature(strict_overflow_ops)]
 pub mod expression;
 pub use expression::{utils::monomialize_expr_to_wit_terms, *};
 pub mod macros;
diff --git a/crates/multilinear_extensions/src/mle.rs b/crates/multilinear_extensions/src/mle.rs
@@ -469,7 +469,7 @@ impl<'a, E: ExtensionField> MultilinearExtension<'a, E> {
         nv: usize,
         degree: usize,
         rng: &mut R,
-    ) -> Vec<ArcMultilinearExtension<E>> {
+    ) -> Vec<ArcMultilinearExtension<'_, E>> {
         let start = entered_span!("sample random zero mle list");
 
         let mut multiplicands = Vec::with_capacity(degree);
@@ -682,11 +682,11 @@ impl<'a, E: ExtensionField> MultilinearExtension<'a, E> {
         self.num_vars = nv - partial_point.len();
     }
 
-    pub fn evaluations(&self) -> &FieldType<E> {
+    pub fn evaluations(&self) -> &FieldType<'_, E> {
         &self.evaluations
     }
 
-    pub fn as_evaluations_view(&self) -> FieldType<E> {
+    pub fn as_evaluations_view(&self) -> FieldType<'_, E> {
         self.evaluations.as_borrowed_view()
     }
 
@@ -738,7 +738,7 @@ impl<'a, E: ExtensionField> MultilinearExtension<'a, E> {
         let chunk_size = total_len / num_chunks;
         assert!(
             num_chunks > 0
-                && total_len % num_chunks == 0
+                && total_len.is_multiple_of(num_chunks)
                 && chunk_size > 0
                 && chunk_index < num_chunks,
             "invalid num_chunks: {num_chunks} total_len: {total_len}, chunk_index {chunk_index} parameter set"
@@ -775,7 +775,7 @@ impl<'a, E: ExtensionField> MultilinearExtension<'a, E> {
         let chunk_size = total_len / num_chunks;
         assert!(
             num_chunks > 0
-                && total_len % num_chunks == 0
+                && total_len.is_multiple_of(num_chunks)
                 && chunk_size > 0
                 && chunk_index < num_chunks,
             "invalid num_chunks: {num_chunks} total_len: {total_len}, chunk_index {chunk_index} parameter set"
@@ -825,7 +825,7 @@ impl<'a, E: ExtensionField> MultilinearExtension<'a, E> {
         let total_len = self.evaluations.len();
         let chunk_size = total_len / num_chunks;
         assert!(
-            num_chunks > 0 && total_len % num_chunks == 0 && chunk_size > 0,
+            num_chunks > 0 && total_len.is_multiple_of(num_chunks) && chunk_size > 0,
             "invalid num_chunks: {num_chunks} total_len: {total_len} parameter set"
         );
         let num_vars_per_chunk = self.num_vars - ceil_log2(num_chunks);
@@ -888,7 +888,7 @@ impl<'a, E: ExtensionField> MultilinearExtension<'a, E> {
         let total_len = self.evaluations.len();
         let chunk_size = total_len / num_chunks;
         assert!(
-            num_chunks > 0 && total_len % num_chunks == 0 && chunk_size > 0,
+            num_chunks > 0 && total_len.is_multiple_of(num_chunks) && chunk_size > 0,
             "invalid num_chunks: {num_chunks} total_len: {total_len} parameter set"
         );
         let num_vars_per_chunk = self.num_vars - ceil_log2(num_chunks);
@@ -1041,7 +1041,7 @@ impl<'a, T> IntoInstanceIter<'a, T> for &'a [T] {
     type IntoIter = InstanceIntoIterator<'a, T>;
 
     fn into_instance_iter(&self, n_instances: usize) -> Self::IntoIter {
-        assert!(self.len() % n_instances == 0);
+        assert!(self.len().is_multiple_of(n_instances));
         let offset = self.len() / n_instances;
         InstanceIntoIterator {
             evaluations: self,
@@ -1056,7 +1056,7 @@ impl<'a, T: 'a> IntoInstanceIterMut<'a, T> for Vec<T> {
     type IntoIterMut = InstanceIntoIteratorMut<'a, T>;
 
     fn into_instance_iter_mut<'b>(&'a mut self, n_instances: usize) -> Self::IntoIterMut {
-        assert!(self.len() % n_instances == 0);
+        assert!(self.len().is_multiple_of(n_instances));
         let offset = self.len() / n_instances;
         let origin_len = self.len();
         InstanceIntoIteratorMut {
diff --git a/crates/multilinear_extensions/src/test.rs b/crates/multilinear_extensions/src/test.rs
@@ -28,7 +28,7 @@ fn test_eq_xr() {
 //      eq(x,y) = \prod_i=1^num_var (x_i * y_i + (1-x_i)*(1-y_i))
 // over r, which is
 //      eq(x,y) = \prod_i=1^num_var (x_i * r_i + (1-x_i)*(1-r_i))
-fn build_eq_x_r_for_test<E: ExtensionField>(r: &[E]) -> ArcMultilinearExtension<E> {
+fn build_eq_x_r_for_test<E: ExtensionField>(r: &[E]) -> ArcMultilinearExtension<'_, E> {
     // we build eq(x,r) from its evaluations
     // we want to evaluate eq(x,r) over x \in {0, 1}^num_vars
     // for example, with num_vars = 4, x is a binary vector of 4, then
diff --git a/crates/multilinear_extensions/src/util.rs b/crates/multilinear_extensions/src/util.rs
@@ -28,7 +28,11 @@ pub fn create_uninit_vec<T: Sized>(len: usize) -> Vec<MaybeUninit<T>> {
 
 #[inline(always)]
 pub fn largest_even_below(n: usize) -> usize {
-    if n % 2 == 0 { n } else { n.saturating_sub(1) }
+    if n.is_multiple_of(2) {
+        n
+    } else {
+        n.saturating_sub(1)
+    }
 }
 
 fn prev_power_of_two(n: usize) -> usize {
diff --git a/crates/multilinear_extensions/src/virtual_poly.rs b/crates/multilinear_extensions/src/virtual_poly.rs
@@ -313,7 +313,7 @@ pub fn eq_eval<F: Field>(x: &[F], y: &[F]) -> F {
 ///      eq(x,y) = \prod_i=1^num_var (x_i * y_i + (1-x_i)*(1-y_i))
 /// over r, which is
 ///      eq(x,y) = \prod_i=1^num_var (x_i * r_i + (1-x_i)*(1-r_i))
-pub fn build_eq_x_r_sequential<E: ExtensionField>(r: &[E]) -> ArcMultilinearExtension<E> {
+pub fn build_eq_x_r_sequential<E: ExtensionField>(r: &[E]) -> ArcMultilinearExtension<'_, E> {
     let evals = build_eq_x_r_vec_sequential(r);
     let mle = MultilinearExtension::from_evaluations_ext_vec(r.len(), evals);
 
@@ -386,7 +386,7 @@ fn build_eq_x_r_helper_sequential<E: ExtensionField>(r: &[E], buf: &mut [MaybeUn
 ///      eq(x,y) = \prod_i=1^num_var (x_i * y_i + (1-x_i)*(1-y_i))
 /// over r, which is
 ///      eq(x,y) = \prod_i=1^num_var (x_i * r_i + (1-x_i)*(1-r_i))
-pub fn build_eq_x_r<E: ExtensionField>(r: &[E]) -> ArcMultilinearExtension<E> {
+pub fn build_eq_x_r<E: ExtensionField>(r: &[E]) -> ArcMultilinearExtension<'_, E> {
     let evals = build_eq_x_r_vec(r);
     let mle = MultilinearExtension::from_evaluations_ext_vec(r.len(), evals);
 
diff --git a/crates/poseidon/src/digest.rs b/crates/poseidon/src/digest.rs
diff --git a/crates/poseidon/src/lib.rs b/crates/poseidon/src/lib.rs
@@ -2,6 +2,3 @@
 extern crate core;
 
 pub mod challenger;
-pub(crate) mod constants;
-pub use constants::DIGEST_WIDTH;
-pub(crate) mod digest;
diff --git a/crates/transcript/src/lib.rs b/crates/transcript/src/lib.rs
@@ -1,7 +1,6 @@
 #![deny(clippy::cargo)]
 //! This repo is not properly implemented
 //! Transcript APIs are placeholders; the actual logic is to be implemented later.
-#![feature(generic_arg_infer)]
 
 pub mod basic;
 
diff --git a/crates/whir/src/ntt/ntt_impl.rs b/crates/whir/src/ntt/ntt_impl.rs
@@ -127,21 +127,21 @@ impl<F: TwoAdicField> NttEngine<F> {
             omega_16_9: F::ZERO,
             roots: RwLock::new(Vec::new()),
         };
-        if order % 3 == 0 {
+        if order.is_multiple_of(3) {
             let omega_3_1 = res.root(3);
             let omega_3_2 = omega_3_1 * omega_3_1;
             // Note: char F cannot be 2 and so division by 2 works, because primitive roots of unity with even order exist.
             res.half_omega_3_1_min_2 = (omega_3_1 - omega_3_2) / F::from_canonical_u64(2u64);
             res.half_omega_3_1_plus_2 = (omega_3_1 + omega_3_2) / F::from_canonical_u64(2u64);
         }
-        if order % 4 == 0 {
+        if order.is_multiple_of(4) {
             res.omega_4_1 = res.root(4);
         }
-        if order % 8 == 0 {
+        if order.is_multiple_of(8) {
             res.omega_8_1 = res.root(8);
             res.omega_8_3 = res.omega_8_1.exp_u64(3);
         }
-        if order % 16 == 0 {
+        if order.is_multiple_of(16) {
             res.omega_16_1 = res.root(16);
             res.omega_16_3 = res.omega_16_1.exp_u64(3);
             res.omega_16_9 = res.omega_16_1.exp_u64(9);
@@ -154,7 +154,7 @@ impl<F: TwoAdicField> NttEngine<F> {
     }
 
     pub fn ntt_batch(&self, values: &mut [F], size: usize) {
-        assert!(values.len() % size == 0);
+        assert!(values.len().is_multiple_of(size));
         let roots = self.roots_table(size);
         self.ntt_dispatch(values, &roots, size);
     }
@@ -173,7 +173,7 @@ impl<F: TwoAdicField> NttEngine<F> {
 
     /// Inverse batch NTT. Does not aply 1/n scaling factor.
     pub fn intt_batch(&self, values: &mut [F], size: usize) {
-        assert!(values.len() % size == 0);
+        assert!(values.len().is_multiple_of(size));
 
         #[cfg(not(feature = "parallel"))]
         values.chunks_exact_mut(size).for_each(|values| {
@@ -228,7 +228,7 @@ impl<F: TwoAdicField> NttEngine<F> {
 
     pub fn root(&self, order: usize) -> F {
         assert!(
-            self.order % order == 0,
+            self.order.is_multiple_of(order),
             "Subgroup of requested order {} does not exist. Total order is {}.",
             order,
             self.order
@@ -237,15 +237,15 @@ impl<F: TwoAdicField> NttEngine<F> {
     }
 
     /// Returns a cached table of roots of unity of the given order.
-    fn roots_table(&self, order: usize) -> RwLockReadGuard<Vec<F>> {
+    fn roots_table(&self, order: usize) -> RwLockReadGuard<'_, Vec<F>> {
         // Precompute more roots of unity if requested.
         let roots = self.roots.read().unwrap();
-        if roots.is_empty() || roots.len() % order != 0 {
+        if roots.is_empty() || !roots.len().is_multiple_of(order) {
             // Obtain write lock to update the cache.
             drop(roots);
             let mut roots = self.roots.write().unwrap();
             // Race condition: check if another thread updated the cache.
-            if roots.is_empty() || roots.len() % order != 0 {
+            if roots.is_empty() || !roots.len().is_multiple_of(order) {
                 // Compute minimal size to support all sizes seen so far.
                 // TODO: Do we really need all of these? Can we leverage omege_2 = -1?
                 let size = if roots.is_empty() {
diff --git a/crates/whir/src/ntt/utils.rs b/crates/whir/src/ntt/utils.rs
@@ -93,7 +93,7 @@ mod tests {
                 unsafe { sqrt_x.to_int_unchecked() }
             };
             for i in 1..=isqrt_of_x {
-                if x % i == 0 {
+                if x.is_multiple_of(i) {
                     result = i;
                 }
             }
diff --git a/crates/whir/src/sumcheck/mod.rs b/crates/whir/src/sumcheck/mod.rs
@@ -195,7 +195,10 @@ mod tests {
             combination_randomness[0],
             &folding_randomness_1,
         );
-        prover.add_new_equality(&[fold_point.clone()], &combination_randomness[1..]);
+        prover.add_new_equality(
+            std::slice::from_ref(&fold_point),
+            &combination_randomness[1..],
+        );
 
         let sumcheck_poly_2 = prover.compute_sumcheck_polynomial(folding_factor);
 
@@ -305,7 +308,10 @@ mod tests {
             combination_randomness_2[0],
             &folding_randomness_2,
         );
-        prover.add_new_equality(&[fold_point_2.clone()], &combination_randomness_2[1..]);
+        prover.add_new_equality(
+            std::slice::from_ref(&fold_point_2),
+            &combination_randomness_2[1..],
+        );
 
         let sumcheck_poly_3 = prover.compute_sumcheck_polynomial(folding_factor);
         let final_coeff = match folded_poly_2
diff --git a/crates/whir/src/sumcheck/prover_not_skipping.rs b/crates/whir/src/sumcheck/prover_not_skipping.rs
@@ -230,7 +230,11 @@ mod tests {
             folded_poly_1,
         )
         .evaluate(&fold_point);
-        prover.add_new_equality(&[fold_point.clone()], &combination_randomness, &[fold_eval]);
+        prover.add_new_equality(
+            std::slice::from_ref(&fold_point),
+            &combination_randomness,
+            &[fold_eval],
+        );
 
         let folding_randomness_2 = prover.compute_sumcheck_polynomials::<T>(
             &mut transcript,
diff --git a/crates/whir/src/utils.rs b/crates/whir/src/utils.rs
@@ -85,7 +85,7 @@ pub fn dedup<T: Ord>(v: impl IntoIterator<Item = T>) -> Vec<T> {
 /// and folds them into a vector of such that folded_evals[i] = [f(omega^(i + k * j)) for j in 0..folding_factor]
 pub fn stack_evaluations<F: Field>(mut evals: Vec<F>, folding_factor: usize) -> Vec<F> {
     let folding_factor_exp = 1 << folding_factor;
-    assert!(evals.len() % folding_factor_exp == 0);
+    assert!(evals.len().is_multiple_of(folding_factor_exp));
     let size_of_new_domain = evals.len() / folding_factor_exp;
 
     // interpret evals as (folding_factor_exp x size_of_new_domain)-matrix and transpose in-place
@@ -95,7 +95,7 @@ pub fn stack_evaluations<F: Field>(mut evals: Vec<F>, folding_factor: usize) ->
 
 pub fn stack_evaluations_mut<F: Field>(evals: &mut [F], folding_factor: usize) {
     let folding_factor_exp = 1 << folding_factor;
-    assert!(evals.len() % folding_factor_exp == 0);
+    assert!(evals.len().is_multiple_of(folding_factor_exp));
     let size_of_new_domain = evals.len() / folding_factor_exp;
 
     // interpret evals as (folding_factor_exp x size_of_new_domain)-matrix and transpose in-place
@@ -119,7 +119,7 @@ pub fn stack_evaluations_bench_allocate<F: Field>(
     folding_factor: usize,
 ) -> Vec<F> {
     let folding_factor_exp = 1 << folding_factor;
-    assert!(evals.len() % folding_factor_exp == 0);
+    assert!(evals.len().is_multiple_of(folding_factor_exp));
     let size_of_new_domain = evals.len() / folding_factor_exp;
 
     // interpret evals as (folding_factor_exp x size_of_new_domain)-matrix and transpose in-place
diff --git a/crates/whir/src/whir/batch/prover.rs b/crates/whir/src/whir/batch/prover.rs
@@ -540,7 +540,7 @@ where
         let mut result = self.simple_batch_prove(
             transcript,
             &[folded_point],
-            &[folded_evals.clone()],
+            std::slice::from_ref(&folded_evals),
             witness,
         )?;
         sumcheck_polys.extend(result.sumcheck_poly_evals);
diff --git a/crates/whir/src/whir/batch/utils.rs b/crates/whir/src/whir/batch/utils.rs
@@ -12,7 +12,7 @@ pub fn stack_evaluations<E: ExtensionField>(
     row_size: usize,
     buffer: &mut [E],
 ) -> Vec<E> {
-    assert!(evals.len() % row_size == 0);
+    assert!(evals.len().is_multiple_of(row_size));
     let size_of_new_domain = evals.len() / row_size;
 
     // interpret evals as (folding_factor_exp x size_of_new_domain)-matrix and transpose in-place
@@ -25,7 +25,7 @@ pub fn stack_evaluations<E: ExtensionField>(
 /// This function will mutate the function without return
 pub fn stack_evaluations_mut<E: ExtensionField>(evals: &mut [E], folding_factor: usize) {
     let folding_factor_exp = 1 << folding_factor;
-    assert!(evals.len() % folding_factor_exp == 0);
+    assert!(evals.len().is_multiple_of(folding_factor_exp));
     let size_of_new_domain = evals.len() / folding_factor_exp;
 
     // interpret evals as (folding_factor_exp x size_of_new_domain)-matrix and transpose in-place
diff --git a/crates/whir/src/whir/batch/verifier.rs b/crates/whir/src/whir/batch/verifier.rs
@@ -121,7 +121,7 @@ where
             transcript,
             num_polys,
             &[folded_points],
-            &[folded_evals.clone()],
+            std::slice::from_ref(&folded_evals),
             parsed_commitment,
             whir_proof,
             &mut sumcheck_poly_evals_iter,
diff --git a/crates/witness/src/lib.rs b/crates/witness/src/lib.rs
@@ -150,16 +150,16 @@ impl<T: Sized + Sync + Clone + Send + Copy + Default + FieldAlgebra> RowMajorMat
         self.num_rows
     }
 
-    pub fn iter_rows(&self) -> Chunks<T> {
+    pub fn iter_rows(&self) -> Chunks<'_, T> {
         self.inner.values[..self.num_instances() * self.n_col()].chunks(self.inner.width)
     }
 
-    pub fn iter_mut(&mut self) -> ChunksMut<T> {
+    pub fn iter_mut(&mut self) -> ChunksMut<'_, T> {
         let max_range = self.num_instances() * self.n_col();
         self.inner.values[..max_range].chunks_mut(self.inner.width)
     }
 
-    pub fn par_batch_iter_mut(&mut self, num_rows: usize) -> rayon::slice::ChunksMut<T> {
+    pub fn par_batch_iter_mut(&mut self, num_rows: usize) -> rayon::slice::ChunksMut<'_, T> {
         let max_range = self.num_instances() * self.n_col();
         self.inner.values[..max_range].par_chunks_mut(num_rows * self.inner.width)
     }
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
@@ -1,5 +1,5 @@
 [toolchain]
-channel = "nightly-2025-03-25"
+channel = "nightly-2025-08-18"
 targets = ["riscv32im-unknown-none-elf"]
 # We need the sources for build-std.
 components = ["rust-src"]
