fix lint errors

Author: Avaneesh-axiom

crates/circuits/sha-air/src/tests.rs

@@ -1,4 +1,3 @@
-use crate::{Sha384Config, ShaDigestColsRefMut, ShaRoundColsRef, ShaRoundColsRefMut};
 use std::{borrow::BorrowMut, cmp::max, sync::Arc};
 
 use openvm_circuit::arch::{
@@ -22,7 +21,10 @@ use openvm_stark_backend::{
 use openvm_stark_sdk::utils::create_seeded_rng;
 use rand::Rng;
 
-use crate::{compose, small_sig0_field, Sha256Config, Sha2Air, Sha512Config, ShaConfig};
+use crate::{
+    compose, small_sig0_field, Sha256Config, Sha2Air, Sha384Config, Sha512Config, ShaConfig,
+    ShaDigestColsRefMut, ShaRoundColsRef, ShaRoundColsRefMut,
+};
 
 // A wrapper AIR purely for testing purposes
 #[derive(Clone, Debug)]

crates/circuits/sha-macros/Cargo.toml

@@ -11,7 +11,6 @@ syn = { version = "2.0", features = ["full", "extra-traits"] }
 quote = "1.0"
 itertools = "0.14"
 proc-macro2 = "1.0"
-ndarray = "0.16"
 
 [dev-dependencies]
 openvm-sha-air = { workspace = true }
@@ -20,3 +19,6 @@ ndarray.workspace = true
 
 [lib]
 proc-macro = true
+
+[package.metadata.cargo-shear]
+ignored = ["ndarray"]

crates/circuits/sha-macros/src/lib.rs

@@ -25,13 +25,14 @@ pub fn cols_ref(input: TokenStream) -> TokenStream {
 
     let span = derive_input.ident.span();
     let res = cols_ref_impl(derive_input, config);
-    if res.is_err() {
-        syn::Error::new(span, res.err().unwrap().to_string())
-            .to_compile_error()
-            .into()
-    } else {
-        res.unwrap().into()
-    }
+    res.map_or_else(
+        |err| {
+            syn::Error::new(span, err.to_string())
+                .to_compile_error()
+                .into()
+        },
+        |ok| ok.into(),
+    )
 }
 
 fn cols_ref_impl(

crates/circuits/sha-macros/tests/aligned_borrow.rs

@@ -4,6 +4,7 @@ use openvm_sha_macros::ColsRef;
 mod test_config;
 use test_config::{TestConfig, TestConfigImpl};
 
+#[allow(dead_code)]
 #[derive(ColsRef)]
 #[config(TestConfig)]
 struct TestCols<T, const N: usize> {
@@ -47,7 +48,7 @@ fn plain_from_mut() {
     test.a[0] = 1;
     test.b.a = 1;
     test.b.b[0] = 1;
-    let test2: TestColsRef<u32> = TestColsRef::from_mut::<TestConfigImpl>(&mut test);
+    let test2: TestColsRef<u32> = TestColsRef::from_mut::<TestConfigImpl>(&test);
     println!("{}", test2.a);
     println!("{:?}", test2.b);
 }

crates/circuits/sha-macros/tests/arrays.rs

@@ -3,6 +3,7 @@ use openvm_sha_macros::ColsRef;
 mod test_config;
 use test_config::{TestConfig, TestConfigImpl};
 
+#[allow(dead_code)]
 #[derive(ColsRef)]
 #[config(TestConfig)]
 struct ArrayTest<T, const N: usize> {

crates/circuits/sha-macros/tests/const-len-arrays.rs

@@ -7,6 +7,7 @@ const THREE: usize = 3;
 mod test_config;
 use test_config::{TestConfig, TestConfigImpl};
 
+#[allow(dead_code)]
 #[derive(ColsRef)]
 #[config(TestConfig)]
 struct ConstLenArrayTest<T, const N: usize> {
@@ -18,7 +19,7 @@ struct ConstLenArrayTest<T, const N: usize> {
 
 #[test]
 fn const_len_arrays() {
-    let input = [1; 1 + TestConfigImpl::N * 2 + 1 * 2 * 3];
+    let input = [1; 1 + TestConfigImpl::N * 2 + 2 * 3];
     let test: ConstLenArrayTestRef<u32> = ConstLenArrayTestRef::from::<TestConfigImpl>(&input);
     println!("{}", test.a);
     println!("{}", test.b);

crates/circuits/sha-macros/tests/nested.rs

@@ -1,13 +1,15 @@
 use openvm_sha_air::{Sha256Config, ShaConfig};
 use openvm_sha_macros::ColsRef;
 
+#[allow(dead_code)]
 #[derive(ColsRef)]
 #[config(ShaConfig)]
 struct Test1Cols<T, const WORD_BITS: usize> {
     pub a: T,
     pub nested: Test2Cols<T, WORD_BITS>,
 }
 
+#[allow(dead_code)]
 #[derive(ColsRef)]
 #[config(ShaConfig)]
 struct Test2Cols<T, const WORD_BITS: usize> {
@@ -34,8 +36,8 @@ fn nested_mut() {
 #[test]
 fn nested_from_mut() {
     let mut mut_input = [0; 1 + 1 + 32];
-    let mut mut_test: Test1ColsRefMut<u32> = Test1ColsRefMut::from::<Sha256Config>(&mut mut_input);
-    let const_test: Test1ColsRef<u32> = Test1ColsRef::from_mut::<Sha256Config>(&mut mut_test);
+    let mut_test: Test1ColsRefMut<u32> = Test1ColsRefMut::from::<Sha256Config>(&mut mut_input);
+    let const_test: Test1ColsRef<u32> = Test1ColsRef::from_mut::<Sha256Config>(&mut_test);
     println!(
         "{}, {}, {}",
         const_test.a, const_test.nested.b, const_test.nested.c

crates/circuits/sha-macros/tests/simple.rs

@@ -1,6 +1,7 @@
 use openvm_sha_air::{Sha256Config, ShaConfig};
 use openvm_sha_macros::ColsRef;
 
+#[allow(dead_code)]
 #[derive(ColsRef)]
 #[config(ShaConfig)]
 struct Test<T, const WORD_BITS: usize, const ROUNDS_PER_ROW: usize, const WORD_U16S: usize> {

extensions/sha256/circuit/Cargo.toml

@@ -23,8 +23,7 @@ derive_more = { workspace = true, features = ["from"] }
 rand.workspace = true
 serde.workspace = true
 sha2 = { version = "0.10", default-features = false }
-strum = { workspace = true }
-ndarray.workspace = true
+ndarray = { workspace = true, default-features = false }
 
 [dev-dependencies]
 openvm-stark-sdk = { workspace = true }
@@ -39,3 +38,6 @@ mimalloc = ["openvm-circuit/mimalloc"]
 jemalloc = ["openvm-circuit/jemalloc"]
 jemalloc-prof = ["openvm-circuit/jemalloc-prof"]
 nightly-features = ["openvm-circuit/nightly-features"]
+
+[package.metadata.cargo-shear]
+ignored = ["ndarray"]

extensions/sha256/circuit/src/extension.rs

@@ -88,7 +88,6 @@ impl<F: PrimeField32> VmExtension<F> for Sha2 {
             builder.system_config().memory_config.pointer_max_bits,
             bitwise_lu_chip.clone(),
             builder.new_bus_idx(),
-            Rv32Sha2Opcode::CLASS_OFFSET,
             builder.system_base().offline_memory(),
         );
         inventory.add_executor(sha256_chip, vec![Rv32Sha2Opcode::SHA256.global_opcode()])?;
@@ -98,7 +97,6 @@ impl<F: PrimeField32> VmExtension<F> for Sha2 {
             builder.system_config().memory_config.pointer_max_bits,
             bitwise_lu_chip.clone(),
             builder.new_bus_idx(),
-            Rv32Sha2Opcode::CLASS_OFFSET,
             builder.system_base().offline_memory(),
         );
         inventory.add_executor(sha512_chip, vec![Rv32Sha2Opcode::SHA512.global_opcode()])?;
@@ -108,7 +106,6 @@ impl<F: PrimeField32> VmExtension<F> for Sha2 {
             builder.system_config().memory_config.pointer_max_bits,
             bitwise_lu_chip,
             builder.new_bus_idx(),
-            Rv32Sha2Opcode::CLASS_OFFSET,
             builder.system_base().offline_memory(),
         );
         inventory.add_executor(sha384_chip, vec![Rv32Sha2Opcode::SHA384.global_opcode()])?;

extensions/sha256/circuit/src/sha256_chip/air.rs

@@ -1,5 +1,4 @@
-use std::cmp::min;
-use std::convert::TryInto;
+use std::{cmp::min, convert::TryInto};
 
 use openvm_circuit::{
     arch::ExecutionBridge,

extensions/sha256/circuit/src/sha256_chip/mod.rs

@@ -41,7 +41,6 @@ pub struct Sha2VmChip<F: PrimeField32, C: ShaChipConfig> {
     pub records: Vec<Sha2Record<F>>,
     pub offline_memory: Arc<Mutex<OfflineMemory<F>>>,
     pub bitwise_lookup_chip: SharedBitwiseOperationLookupChip<8>,
-    offset: usize,
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
@@ -65,7 +64,6 @@ impl<F: PrimeField32, C: ShaChipConfig> Sha2VmChip<F, C> {
         address_bits: usize,
         bitwise_lookup_chip: SharedBitwiseOperationLookupChip<8>,
         self_bus_idx: BusIndex,
-        offset: usize,
         offline_memory: Arc<Mutex<OfflineMemory<F>>>,
     ) -> Self {
         Self {
@@ -79,7 +77,6 @@ impl<F: PrimeField32, C: ShaChipConfig> Sha2VmChip<F, C> {
             ),
             bitwise_lookup_chip,
             records: Vec::new(),
-            offset,
             offline_memory,
         }
     }

extensions/sha256/circuit/src/sha256_chip/tests.rs

@@ -99,7 +99,6 @@ fn rand_sha_test<C: ShaChipConfig + 'static>(opcode: Rv32Sha2Opcode) {
         tester.address_bits(),
         bitwise_chip.clone(),
         BUS_IDX,
-        Rv32Sha2Opcode::CLASS_OFFSET,
         tester.offline_memory_mutex_arc(),
     );
 
@@ -146,7 +145,6 @@ fn execute_roundtrip_sanity_test<C: ShaChipConfig>(opcode: Rv32Sha2Opcode) {
         tester.address_bits(),
         bitwise_chip.clone(),
         BUS_IDX,
-        Rv32Sha2Opcode::CLASS_OFFSET,
         tester.offline_memory_mutex_arc(),
     );
 

extensions/sha256/circuit/src/sha256_chip/trace.rs

@@ -316,7 +316,7 @@ where
                                         debug_assert_eq!(digest_writes.len(), 2);
                                         debug_assert_eq!(cols.writes_aux_base.len(), 2);
                                         debug_assert_eq!(cols.writes_aux_prev_data.nrows(), 2);
-                                        for i in 0..C::NUM_WRITES {
+                                        for (i, digest_write) in digest_writes.iter().enumerate() {
                                             let prev_data =
                                                 cols.writes_aux_prev_data.row(i).to_vec();
                                             // write to a temporary MemoryWriteAuxCols object and then copy it over to the columns struct
@@ -327,10 +327,8 @@ where
                                                 cols.writes_aux_base[i],
                                                 prev_data.try_into().unwrap(),
                                             );
-                                            memory_aux_cols_factory.generate_write_aux(
-                                                digest_writes[i],
-                                                &mut writes_aux,
-                                            );
+                                            memory_aux_cols_factory
+                                                .generate_write_aux(digest_write, &mut writes_aux);
                                             cols.writes_aux_base[i] = writes_aux.get_base();
                                             cols.writes_aux_prev_data
                                                 .row_mut(i)