chore: code clippy (#83)

* chore: remove dead code

* chore: add clippty

* fix: clippy

* fix: clippy

Author: eigmax

.github/workflows/ci.yml

@@ -43,3 +43,16 @@ jobs:
         with:
           command: fmt
           args: --all -- --check
+  clippy:
+    name: Clippy
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: nightly
+          override: true
+      - run: rustup component add clippy
+      - run: cargo clippy --all-targets -- -D warnings
+

Cargo.toml

@@ -7,25 +7,20 @@ edition = "2021"
 
 
 [dependencies]
-#plonky2 = { git = "https://github.com/0xPolygonZero/plonky2", branch = "main" }
 plonky2 = { git = "https://github.com/zkMIPS/plonky2.git", branch = "zkm_dev" }
-plonky2x = { git = "https://github.com/zkMIPS/succinctx.git", package = "plonky2x",  branch = "zkm" }
 starky = { git = "https://github.com/zkMIPS/plonky2.git", branch = "zkm_dev" }
 plonky2_util = { git = "https://github.com/zkMIPS/plonky2.git", branch = "zkm_dev" }
 plonky2_maybe_rayon = { git = "https://github.com/zkMIPS/plonky2.git", branch = "zkm_dev" }
-curta = { git ="https://github.com/zkMIPS/curta.git", branch = "zkm" }
 tokio = { version = "1", features = ["full"] }
 backtrace = "0.3"
 array-macro = "2.1.5"
 #curve25519-dalek = "4.1.1"
 sha2 = "0.10.7"
-plonky2x-derive = { git = "https://github.com/zkMIPS/succinctx.git", package = "plonky2x-derive",  branch = "zkm" }
 reqwest = { version = "0.11.4", features = ["blocking", "json"] }
 uuid = { version = "1.4.1", features = ["serde"] }
 async-trait = "0.1.73"
 futures = "0.3.28"
 serde_with = "3.3.0"
-env_logger = "0.10.0"
 bincode = "1.3.3"
 
 itertools = "0.11.0"
@@ -57,5 +52,8 @@ dotenv = "0.15.0"
 prettytable-rs = "^0.8"
 
 [dev-dependencies]
-#env_logger = { version = "0.9.0", default-features = false }
+env_logger = "0.10.0"
 keccak-hash = "0.10.0"
+plonky2x = { git = "https://github.com/zkMIPS/succinctx.git", package = "plonky2x",  branch = "zkm" }
+plonky2x-derive = { git = "https://github.com/zkMIPS/succinctx.git", package = "plonky2x-derive",  branch = "zkm" }
+curta = { git ="https://github.com/zkMIPS/curta.git", branch = "zkm" }

Makefile

@@ -0,0 +1,24 @@
+CARGO = cargo
+
+UNAME_S := $(shell uname -s)
+ifeq ($(UNAME_S),Darwin)
+	CARGO += --config 'build.rustdocflags = ["-C", "link-args=-framework CoreFoundation -framework Security"]'
+endif
+
+help: ## Display this help screen
+	@grep -h \
+		-E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | \
+		awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}'
+
+clippy: ## Run clippy checks over all workspace members and formatted correctly
+	@cargo check
+	@cargo fmt --all -- --check
+	@cargo clippy --all-targets -- -D warnings
+
+fix: ## Automatically apply lint suggestions. This flag implies `--no-deps` and `--all-targets`
+	@cargo clippy --fix
+
+test: ## Run tests for all the workspace members
+	@cargo test --release --all
+
+.PHONY: clippy fmt test

clippy.toml

@@ -0,0 +1 @@
+large-error-threshold = 1000

examples/zkmips.rs

@@ -82,12 +82,10 @@ fn prove_single_seg() {
     let allproof: proof::AllProof<GoldilocksField, C, D> =
         prove(&allstark, &kernel, &config, &mut timing).unwrap();
     let mut count_bytes = 0;
-    let mut row = 0;
-    for proof in allproof.stark_proofs.clone() {
+    for (row, proof) in allproof.stark_proofs.clone().iter().enumerate() {
         let proof_str = serde_json::to_string(&proof.proof).unwrap();
         log::info!("row:{} proof bytes:{}", row, proof_str.len());
-        row = row + 1;
-        count_bytes = count_bytes + proof_str.len();
+        count_bytes += proof_str.len();
     }
     log::info!("total proof bytes:{}KB", count_bytes / 1024);
     verify_proof(&allstark, allproof, &config).unwrap();
@@ -139,7 +137,7 @@ fn aggregate_proof() -> anyhow::Result<()> {
     // Preprocess all circuits.
     let all_circuits = AllRecursiveCircuits::<F, C, D>::new(
         &all_stark,
-        &[10..20, 15..22, 14..20, 9..20, 12..20, 15..23],
+        &[10..21, 15..22, 14..21, 9..21, 12..21, 15..23],
         &config,
     );
 

src/all_stark.rs

@@ -168,13 +168,6 @@ pub(crate) fn ctl_logic<F: Field>() -> CrossTableLookup<F> {
 }
 
 fn ctl_memory<F: Field>() -> CrossTableLookup<F> {
-    /*
-    let cpu_memory_code_read = TableWithColumns::new(
-        Table::Cpu,
-        cpu_stark::ctl_data_code_memory::<F>(),
-        Some(cpu_stark::ctl_filter_code_memory()),
-    );
-    */
     let cpu_memory_gp_ops = (0..NUM_GP_CHANNELS).map(|channel| {
         TableWithColumns::new(
             Table::Cpu,
@@ -197,7 +190,6 @@ fn ctl_memory<F: Field>() -> CrossTableLookup<F> {
             Some(keccak_sponge_stark::ctl_looking_memory_filter(i)),
         )
     });
-    //let all_lookers = iter::once(cpu_memory_code_read)
     let all_lookers = []
         .into_iter()
         .chain(cpu_memory_gp_ops)

src/arithmetic/addcy.rs

@@ -254,13 +254,11 @@ pub fn eval_ext_circuit<F: RichField + Extendable<D>, const D: usize>(
 #[cfg(test)]
 mod tests {
     use plonky2::field::goldilocks_field::GoldilocksField;
-    use plonky2::field::types::{Field, Sample};
+    use plonky2::field::types::Sample;
     use rand::{Rng, SeedableRng};
     use rand_chacha::ChaCha8Rng;
 
     use super::*;
-    use crate::arithmetic::columns::NUM_ARITH_COLUMNS;
-    use crate::constraint_consumer::ConstraintConsumer;
 
     // TODO: Should be able to refactor this test to apply to all operations.
     #[test]

src/arithmetic/arithmetic_stark.rs

@@ -66,32 +66,32 @@ pub fn ctl_arithmetic_rows<F: Field>() -> TableWithColumns<F> {
     // from the opcode bits matches.
     // FIXME: opcode = op + 2^6 * func
     const COMBINED_OPS: [(usize, u32); 18] = [
-        (columns::IS_ADD, 0b000000 + 0b100000 * (1 << 6)),
-        (columns::IS_ADDU, 0b000000 + 0b100001 * (1 << 6)),
+        (columns::IS_ADD, 0b100000 * (1 << 6)),
+        (columns::IS_ADDU, 0b100001 * (1 << 6)),
         //(columns::IS_ADDI, 0b001000 + 0b000000 * (1 << 6)),
         //(columns::IS_ADDIU, 0b001001 + 0b000000 * (1 << 6)),
-        (columns::IS_SUB, 0b000000 + 0b100010 * (1 << 6)),
-        (columns::IS_SUBU, 0b000000 + 0b100011 * (1 << 6)),
-        (columns::IS_MULT, 0b000000 + 0b011000 * (1 << 6)),
-        (columns::IS_MULTU, 0b000000 + 0b011001 * (1 << 6)),
+        (columns::IS_SUB, 0b100010 * (1 << 6)),
+        (columns::IS_SUBU, 0b100011 * (1 << 6)),
+        (columns::IS_MULT, 0b011000 * (1 << 6)),
+        (columns::IS_MULTU, 0b011001 * (1 << 6)),
         (columns::IS_MUL, 0b011100 + 0b000010 * (1 << 6)),
-        (columns::IS_DIV, 0b000000 + 0b011010 * (1 << 6)),
-        (columns::IS_DIVU, 0b000000 + 0b011011 * (1 << 6)),
-        (columns::IS_SLLV, 0b000000 + 0b000100 * (1 << 6)),
-        (columns::IS_SRLV, 0b000000 + 0b000110 * (1 << 6)),
-        (columns::IS_SRAV, 0b000000 + 0b000111 * (1 << 6)),
+        (columns::IS_DIV, 0b011010 * (1 << 6)),
+        (columns::IS_DIVU, 0b011011 * (1 << 6)),
+        (columns::IS_SLLV, 0b000100 * (1 << 6)),
+        (columns::IS_SRLV, 0b000110 * (1 << 6)),
+        (columns::IS_SRAV, 0b000111 * (1 << 6)),
         //(columns::IS_SLL, 0b000000 + 0b000000 * (1 << 6)),
         //(columns::IS_SRL, 0b000000 + 0b000010 * (1 << 6)),
         //(columns::IS_SRA, 0b000000 + 0b000011 * (1 << 6)),
-        (columns::IS_SLT, 0b000000 + 0b101010 * (1 << 6)),
-        (columns::IS_SLTU, 0b000000 + 0b101011 * (1 << 6)),
+        (columns::IS_SLT, 0b101010 * (1 << 6)),
+        (columns::IS_SLTU, 0b101011 * (1 << 6)),
         // (columns::IS_SLTI, 0b001010 + 0b000000 * (1 << 6)),
         // (columns::IS_SLTIU, 0b001011 + 0b000000 * (1 << 6)),
         // (columns::IS_LUI, 0b001111 + 0b000000 * (1 << 6)),
-        (columns::IS_MFHI, 0b000000 + 0b010000 * (1 << 6)),
-        (columns::IS_MTHI, 0b000000 + 0b010001 * (1 << 6)),
-        (columns::IS_MFLO, 0b000000 + 0b010010 * (1 << 6)),
-        (columns::IS_MTLO, 0b000000 + 0b010011 * (1 << 6)),
+        (columns::IS_MFHI, 0b010000 * (1 << 6)),
+        (columns::IS_MTHI, 0b010001 * (1 << 6)),
+        (columns::IS_MFLO, 0b010010 * (1 << 6)),
+        (columns::IS_MTLO, 0b010011 * (1 << 6)),
     ];
 
     const REGISTER_MAP: [Range<usize>; 3] = [
@@ -123,7 +123,7 @@ const RANGE_MAX: usize = 1usize << 16; // Range check strict upper bound
 
 impl<F: RichField, const D: usize> ArithmeticStark<F, D> {
     /// Expects input in *column*-major layout
-    fn generate_range_checks(&self, cols: &mut Vec<Vec<F>>) {
+    fn generate_range_checks(&self, cols: &mut [Vec<F>]) {
         debug_assert!(cols.len() == columns::NUM_ARITH_COLUMNS);
 
         let n_rows = cols[0].len();
@@ -286,12 +286,11 @@ impl<F: RichField + Extendable<D>, const D: usize> Stark<F, D> for ArithmeticSta
 mod tests {
     use anyhow::Result;
     use itertools::Itertools;
-    use plonky2::field::types::PrimeField64;
     use plonky2::plonk::config::{GenericConfig, PoseidonGoldilocksConfig};
     use rand::{Rng, SeedableRng};
     use rand_chacha::ChaCha8Rng;
 
-    use super::{columns, ArithmeticStark};
+    use crate::arithmetic::arithmetic_stark::ArithmeticStark;
     use crate::arithmetic::columns::OUTPUT_REGISTER;
     use crate::arithmetic::*;
     use crate::stark_testing::{test_stark_circuit_constraints, test_stark_low_degree};

src/arithmetic/div.rs

@@ -82,7 +82,7 @@ pub(crate) fn generate_div<F: PrimeField64>(
 
         debug_assert_eq!(abs_idx.len(), N_LIMBS);
 
-        u32_to_array(&mut lv[abs_idx], (input as i32).abs() as u32);
+        u32_to_array(&mut lv[abs_idx], (input as i32).unsigned_abs());
 
         is_neg
     };
@@ -938,13 +938,11 @@ pub(crate) fn eval_div_ext_circuit<F: RichField + Extendable<D>, const D: usize>
 #[cfg(test)]
 mod tests {
     use plonky2::field::goldilocks_field::GoldilocksField;
-    use plonky2::field::types::{Field, Sample};
+    use plonky2::field::types::Sample;
     use rand::{Rng, SeedableRng};
     use rand_chacha::ChaCha8Rng;
 
     use super::*;
-    use crate::arithmetic::columns::NUM_ARITH_COLUMNS;
-    use crate::constraint_consumer::ConstraintConsumer;
 
     const N_RND_TESTS: usize = 1000;
     const MODULAR_OPS: [usize; 2] = [IS_DIV, IS_DIVU];

src/arithmetic/lo_hi.rs

@@ -59,8 +59,6 @@ mod tests {
     use rand_chacha::ChaCha8Rng;
 
     use super::*;
-    use crate::arithmetic::columns::NUM_ARITH_COLUMNS;
-    use crate::constraint_consumer::ConstraintConsumer;
 
     const OPS: [usize; 4] = [IS_MFHI, IS_MTHI, IS_MFLO, IS_MTLO];
     #[test]

src/arithmetic/mul.rs

@@ -246,13 +246,11 @@ pub fn eval_ext_circuit<F: RichField + Extendable<D>, const D: usize>(
 #[cfg(test)]
 mod tests {
     use plonky2::field::goldilocks_field::GoldilocksField;
-    use plonky2::field::types::{Field, Sample};
+    use plonky2::field::types::Sample;
     use rand::{Rng, SeedableRng};
     use rand_chacha::ChaCha8Rng;
 
     use super::*;
-    use crate::arithmetic::columns::NUM_ARITH_COLUMNS;
-    use crate::constraint_consumer::ConstraintConsumer;
 
     const N_RND_TESTS: usize = 1000;
 

src/arithmetic/mult.rs

@@ -499,13 +499,11 @@ pub fn eval_ext_circuit<F: RichField + Extendable<D>, const D: usize>(
 #[cfg(test)]
 mod tests {
     use plonky2::field::goldilocks_field::GoldilocksField;
-    use plonky2::field::types::{Field, Sample};
+    use plonky2::field::types::Sample;
     use rand::{Rng, SeedableRng};
     use rand_chacha::ChaCha8Rng;
 
     use super::*;
-    use crate::arithmetic::columns::NUM_ARITH_COLUMNS;
-    use crate::constraint_consumer::ConstraintConsumer;
 
     const N_RND_TESTS: usize = 100000;
     const OPS: [usize; 2] = [IS_MULT, IS_MULTU];

src/arithmetic/shift.rs

@@ -188,8 +188,6 @@ pub fn eval_ext_circuit<F: RichField + Extendable<D>, const D: usize>(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::arithmetic::columns::{IS_SLL, IS_SLLV, IS_SRL, IS_SRLV, NUM_ARITH_COLUMNS};
-    use crate::constraint_consumer::ConstraintConsumer;
     use plonky2::field::goldilocks_field::GoldilocksField;
     use plonky2::field::types::{Field, Sample};
     use rand::{Rng, SeedableRng};

src/arithmetic/slt.rs

@@ -1,7 +1,4 @@
 use crate::arithmetic::columns::*;
-use crate::arithmetic::columns::{
-    INPUT_REGISTER_0, INPUT_REGISTER_1, IS_SLT, LIMB_BITS, NUM_ARITH_COLUMNS, OUTPUT_REGISTER,
-};
 use crate::arithmetic::utils::u32_to_array;
 use crate::constraint_consumer::{ConstraintConsumer, RecursiveConstraintConsumer};
 

src/arithmetic/sra.rs

@@ -154,7 +154,7 @@ pub fn eval_packed_generic<P: PackedField>(
     let output = &lv[OUTPUT_REGISTER];
     for (x, (y, z)) in logic_shifted_input
         .iter()
-        .zip((vec![acc_lo, acc_hi].iter()).zip(output.iter()))
+        .zip(([acc_lo, acc_hi].iter()).zip(output.iter()))
     {
         yield_constr.constraint_transition(filter * (*x + *y * is_neg - *z));
     }
@@ -259,7 +259,7 @@ pub fn eval_ext_circuit<F: RichField + Extendable<D>, const D: usize>(
     let output = &lv[OUTPUT_REGISTER];
     for (x, (y, z)) in logic_shifted_input
         .iter()
-        .zip((vec![acc_lo, acc_hi].iter()).zip(output.iter()))
+        .zip(([acc_lo, acc_hi].iter()).zip(output.iter()))
     {
         let t0 = builder.sub_extension(*x, *z);
         let t1 = builder.mul_add_extension(*y, is_neg, t0);
@@ -288,7 +288,7 @@ fn eval_poly<F: Field>(poly: PolynomialCoeffs<F>, x: F) -> Vec<F> {
     let mut results = vec![];
     let mut acc = F::ZERO;
     for chunks in poly.coeffs.chunks(2).rev() {
-        let inter_coeff = chunks.iter().chain([acc].iter()).map(|x| *x).collect_vec();
+        let inter_coeff = chunks.iter().chain([acc].iter()).copied().collect_vec();
         let inter_poly = PolynomialCoeffs::new(inter_coeff);
         acc = inter_poly.eval(x);
         results.push(acc);

src/cpu/bootstrap_kernel.rs

@@ -51,8 +51,8 @@ pub(crate) fn generate_bootstrap_kernel<F: Field>(state: &mut GenerationState<F>
         state.traces.push_cpu(cpu_row);
     }
 
-    for (_i, addr) in page_addr.iter().enumerate() {
-        check_memory_page_hash(state, kernel, *addr);
+    for addr in page_addr {
+        check_memory_page_hash(state, kernel, addr);
     }
 
     check_image_id(state, kernel);
@@ -244,7 +244,7 @@ pub(crate) fn eval_bootstrap_kernel_packed<F: Field, P: PackedField<Scalar = F>>
     // If this is a bootloading row and the i'th memory channel is used, it must have the right
     // address, name context = 0, segment = Code, virt + 4 = next_virt
     let code_segment = F::from_canonical_usize(Segment::Code as usize);
-    for (_i, channel) in local_values.mem_channels.iter().enumerate() {
+    for channel in local_values.mem_channels.iter() {
         let filter = local_is_bootstrap * channel.used;
         yield_constr.constraint(filter * channel.addr_context);
         yield_constr.constraint(filter * (channel.addr_segment - code_segment));
@@ -298,7 +298,7 @@ pub(crate) fn eval_bootstrap_kernel_ext_circuit<F: RichField + Extendable<D>, co
     // address, name context = 0, segment = Code, virt + 4 = next_virt
     let code_segment =
         builder.constant_extension(F::Extension::from_canonical_usize(Segment::Code as usize));
-    for (_i, channel) in local_values.mem_channels.iter().enumerate() {
+    for channel in local_values.mem_channels {
         let filter = builder.mul_extension(local_is_bootstrap, channel.used);
         let constraint = builder.mul_extension(filter, channel.addr_context);
         yield_constr.constraint(builder, constraint);