fixed lints

irakliyk · irakliyk · commit 376b93408789 · 2025-07-19T14:11:08.000-07:00
diff --git a/air/src/air/assertions/mod.rs b/air/src/air/assertions/mod.rs
@@ -191,7 +191,7 @@ impl<E: FieldElement> Assertion<E> {
                 return false;
             }
             if other.is_single() || self.stride < other.stride {
-                (other.first_step - self.first_step) % self.stride == 0
+                (other.first_step - self.first_step).is_multiple_of(self.stride)
             } else {
                 false
             }
@@ -200,7 +200,7 @@ impl<E: FieldElement> Assertion<E> {
                 return false;
             }
             if self.is_single() || other.stride < self.stride {
-                (self.first_step - other.first_step) % other.stride == 0
+                (self.first_step - other.first_step).is_multiple_of(other.stride)
             } else {
                 false
             }
diff --git a/air/src/air/divisor.rs b/air/src/air/divisor.rs
@@ -253,7 +253,7 @@ mod tests {
             let expected = polynom::eval(&poly, g.exp((i as u32).into()));
             let actual = divisor.evaluate_at(g.exp((i as u32).into()));
             assert_eq!(expected, actual);
-            if i % (j as usize) == 0 {
+            if i.is_multiple_of(j as usize) {
                 assert_eq!(BaseElement::ZERO, actual);
             }
         }
diff --git a/crypto/src/hash/rescue/rp62_248/mod.rs b/crypto/src/hash/rescue/rp62_248/mod.rs
@@ -98,7 +98,7 @@ impl Hasher for Rp62_248 {
         // compute the number of elements required to represent the string; we will be processing
         // the string in 7-byte chunks, thus the number of elements will be equal to the number
         // of such chunks (including a potential partial chunk at the end).
-        let num_elements = if bytes.len() % 7 == 0 {
+        let num_elements = if bytes.len().is_multiple_of(7) {
             bytes.len() / 7
         } else {
             bytes.len() / 7 + 1
@@ -134,7 +134,7 @@ impl Hasher for Rp62_248 {
             // again from zero index.
             state[i] += BaseElement::new(u64::from_le_bytes(buf));
             i += 1;
-            if i % RATE_WIDTH == 0 {
+            if i.is_multiple_of(RATE_WIDTH) {
                 apply_permutation(&mut state);
                 i = 0;
             }
@@ -212,7 +212,7 @@ impl ElementHasher for Rp62_248 {
         for &element in elements.iter() {
             state[i] += element;
             i += 1;
-            if i % RATE_WIDTH == 0 {
+            if i.is_multiple_of(RATE_WIDTH) {
                 apply_permutation(&mut state);
                 i = 0;
             }
diff --git a/crypto/src/hash/rescue/rp64_256/mod.rs b/crypto/src/hash/rescue/rp64_256/mod.rs
@@ -124,7 +124,7 @@ impl Hasher for Rp64_256 {
         // compute the number of elements required to represent the string; we will be processing
         // the string in 7-byte chunks, thus the number of elements will be equal to the number
         // of such chunks (including a potential partial chunk at the end).
-        let num_elements = if bytes.len() % 7 == 0 {
+        let num_elements = if bytes.len().is_multiple_of(7) {
             bytes.len() / 7
         } else {
             bytes.len() / 7 + 1
@@ -160,7 +160,7 @@ impl Hasher for Rp64_256 {
             // again from zero index.
             state[RATE_RANGE.start + i] += BaseElement::new(u64::from_le_bytes(buf));
             i += 1;
-            if i % RATE_WIDTH == 0 {
+            if i.is_multiple_of(RATE_WIDTH) {
                 Self::apply_permutation(&mut state);
                 i = 0;
             }
@@ -238,7 +238,7 @@ impl ElementHasher for Rp64_256 {
         for &element in elements.iter() {
             state[RATE_RANGE.start + i] += element;
             i += 1;
-            if i % RATE_WIDTH == 0 {
+            if i.is_multiple_of(RATE_WIDTH) {
                 Self::apply_permutation(&mut state);
                 i = 0;
             }
diff --git a/crypto/src/hash/rescue/rp64_256_jive/mod.rs b/crypto/src/hash/rescue/rp64_256_jive/mod.rs
@@ -120,7 +120,7 @@ impl Hasher for RpJive64_256 {
         // compute the number of elements required to represent the string; we will be processing
         // the string in 7-byte chunks, thus the number of elements will be equal to the number
         // of such chunks (including a potential partial chunk at the end).
-        let num_elements = if bytes.len() % 7 == 0 {
+        let num_elements = if bytes.len().is_multiple_of(7) {
             bytes.len() / 7
         } else {
             bytes.len() / 7 + 1
@@ -129,7 +129,7 @@ impl Hasher for RpJive64_256 {
         // initialize state to all zeros, except for the first element of the capacity part, which
         // is set to 1 if the number of elements is not a multiple of RATE_WIDTH.
         let mut state = [BaseElement::ZERO; STATE_WIDTH];
-        if num_elements % RATE_WIDTH != 0 {
+        if !num_elements.is_multiple_of(RATE_WIDTH) {
             state[CAPACITY_RANGE.start] = BaseElement::ONE;
         }
 
@@ -157,7 +157,7 @@ impl Hasher for RpJive64_256 {
             // absorbing again from zero index.
             state[RATE_RANGE.start + i] += BaseElement::new(u64::from_le_bytes(buf));
             i += 1;
-            if i % RATE_WIDTH == 0 {
+            if i.is_multiple_of(RATE_WIDTH) {
                 Self::apply_permutation(&mut state);
                 i = 0;
             }
@@ -236,7 +236,7 @@ impl ElementHasher for RpJive64_256 {
         // initialize state to all zeros, except for the first element of the capacity part, which
         // is set to 1 if the number of elements is not a multiple of RATE_WIDTH.
         let mut state = [BaseElement::ZERO; STATE_WIDTH];
-        if elements.len() % RATE_WIDTH != 0 {
+        if !elements.len().is_multiple_of(RATE_WIDTH) {
             state[CAPACITY_RANGE.start] = BaseElement::ONE;
         }
 
@@ -247,7 +247,7 @@ impl ElementHasher for RpJive64_256 {
         for &element in elements.iter() {
             state[RATE_RANGE.start + i] += element;
             i += 1;
-            if i % RATE_WIDTH == 0 {
+            if i.is_multiple_of(RATE_WIDTH) {
                 Self::apply_permutation(&mut state);
                 i = 0;
             }
diff --git a/examples/src/lamport/aggregate/air.rs b/examples/src/lamport/aggregate/air.rs
@@ -181,7 +181,7 @@ impl Air for LamportAggregateAir {
         for (i, value) in powers_of_two.iter_mut().enumerate().skip(1) {
             // we switch to a new power of two once every 8 steps this. is so that a
             // new power of two is available for every hash cycle
-            if i % HASH_CYCLE_LEN == 0 {
+            if i.is_multiple_of(HASH_CYCLE_LEN) {
                 current_power_of_two *= TWO;
             }
             *value = current_power_of_two;
diff --git a/examples/src/lamport/threshold/air.rs b/examples/src/lamport/threshold/air.rs
@@ -216,7 +216,7 @@ impl Air for LamportThresholdAir {
         for (i, value) in powers_of_two.iter_mut().enumerate().skip(1) {
             // we switch to a new power of two once every 8 steps this. is so that a
             // new power of two is available for every hash cycle
-            if i % HASH_CYCLE_LEN == 0 {
+            if i.is_multiple_of(HASH_CYCLE_LEN) {
                 current_power_of_two *= TWO;
             }
             *value = current_power_of_two;
diff --git a/examples/src/utils/mod.rs b/examples/src/utils/mod.rs
@@ -69,7 +69,7 @@ pub fn print_trace<E: StarkField>(
 
     let mut state = vec![E::ZERO; trace_width];
     for i in 0..trace.length() {
-        if (i.wrapping_sub(offset)) % multiples_of != 0 {
+        if !(i.wrapping_sub(offset)).is_multiple_of(multiples_of) {
             continue;
         }
         trace.read_row_into(i, &mut state);
diff --git a/examples/src/utils/rescue.rs b/examples/src/utils/rescue.rs
@@ -61,7 +61,7 @@ impl Rescue128 {
         for &element in data {
             self.state[self.idx] += element;
             self.idx += 1;
-            if self.idx % RATE_WIDTH == 0 {
+            if self.idx.is_multiple_of(RATE_WIDTH) {
                 apply_permutation(&mut self.state);
                 self.idx = 0;
             }
@@ -86,7 +86,7 @@ impl Rescue128 {
         for &element in data.iter() {
             state[i] += element;
             i += 1;
-            if i % RATE_WIDTH == 0 {
+            if i.is_multiple_of(RATE_WIDTH) {
                 apply_permutation(&mut state);
                 i = 0;
             }
diff --git a/fri/src/proof.rs b/fri/src/proof.rs
@@ -298,7 +298,7 @@ impl FriProofLayer {
     {
         // make sure the number of value bytes can be parsed into a whole number of queries
         let num_query_bytes = E::ELEMENT_BYTES * folding_factor;
-        if self.values.len() % num_query_bytes != 0 {
+        if !self.values.len().is_multiple_of(num_query_bytes) {
             return Err(DeserializationError::InvalidValue(format!(
                 "number of value bytes ({}) does not divide into whole number of queries",
                 self.values.len(),
diff --git a/fri/src/verifier/mod.rs b/fri/src/verifier/mod.rs
@@ -128,7 +128,7 @@ where
             // make sure the degree can be reduced by the folding factor at all layers
             // but the remainder layer
             if depth != layer_commitments.len() - 1
-                && max_degree_plus_1 % options.folding_factor() != 0
+                && !max_degree_plus_1.is_multiple_of(options.folding_factor())
             {
                 return Err(VerifierError::DegreeTruncation(
                     max_degree_plus_1 - 1,
@@ -293,7 +293,7 @@ where
             evaluations = row_polys.iter().map(|p| polynom::eval(p, alpha)).collect();
 
             // make sure next degree reduction does not result in degree truncation
-            if max_degree_plus_1 % N != 0 {
+            if !max_degree_plus_1.is_multiple_of(N) {
                 return Err(VerifierError::DegreeTruncation(max_degree_plus_1 - 1, N, depth));
             }
 
diff --git a/math/src/fft/concurrent.rs b/math/src/fft/concurrent.rs
@@ -184,7 +184,7 @@ fn transpose_square_stretch<T>(matrix: &mut [T], size: usize, stretch: usize) {
 
 fn transpose_square_1<T>(matrix: &mut [T], size: usize) {
     debug_assert_eq!(matrix.len(), size * size);
-    if size % 2 != 0 {
+    if !size.is_multiple_of(2) {
         unimplemented!("odd sizes are not supported");
     }
 
diff --git a/math/src/field/extensions/cubic.rs b/math/src/field/extensions/cubic.rs
@@ -122,7 +122,7 @@ impl<B: ExtensibleField<3>> FieldElement for CubeExtension<B> {
 
     fn slice_from_base_elements(elements: &[Self::BaseField]) -> &[Self] {
         assert!(
-            elements.len() % Self::EXTENSION_DEGREE == 0,
+            elements.len().is_multiple_of(Self::EXTENSION_DEGREE),
             "number of base elements must be divisible by 3, but was {}",
             elements.len()
         );
@@ -145,7 +145,7 @@ impl<B: ExtensibleField<3>> FieldElement for CubeExtension<B> {
     }
 
     unsafe fn bytes_as_elements(bytes: &[u8]) -> Result<&[Self], DeserializationError> {
-        if bytes.len() % Self::ELEMENT_BYTES != 0 {
+        if !bytes.len().is_multiple_of(Self::ELEMENT_BYTES) {
             return Err(DeserializationError::InvalidValue(format!(
                 "number of bytes ({}) does not divide into whole number of field elements",
                 bytes.len(),
@@ -156,7 +156,7 @@ impl<B: ExtensibleField<3>> FieldElement for CubeExtension<B> {
         let len = bytes.len() / Self::ELEMENT_BYTES;
 
         // make sure the bytes are aligned on the boundary consistent with base element alignment
-        if (p as usize) % Self::BaseField::ELEMENT_BYTES != 0 {
+        if !(p as usize).is_multiple_of(Self::BaseField::ELEMENT_BYTES) {
             return Err(DeserializationError::InvalidValue(
                 "slice memory alignment is not valid for this field element type".to_string(),
             ));
diff --git a/math/src/field/extensions/quadratic.rs b/math/src/field/extensions/quadratic.rs
@@ -118,7 +118,7 @@ impl<B: ExtensibleField<2>> FieldElement for QuadExtension<B> {
 
     fn slice_from_base_elements(elements: &[Self::BaseField]) -> &[Self] {
         assert!(
-            elements.len() % Self::EXTENSION_DEGREE == 0,
+            elements.len().is_multiple_of(Self::EXTENSION_DEGREE),
             "number of base elements must be divisible by 2, but was {}",
             elements.len()
         );
@@ -141,7 +141,7 @@ impl<B: ExtensibleField<2>> FieldElement for QuadExtension<B> {
     }
 
     unsafe fn bytes_as_elements(bytes: &[u8]) -> Result<&[Self], DeserializationError> {
-        if bytes.len() % Self::ELEMENT_BYTES != 0 {
+        if !bytes.len().is_multiple_of(Self::ELEMENT_BYTES) {
             return Err(DeserializationError::InvalidValue(format!(
                 "number of bytes ({}) does not divide into whole number of field elements",
                 bytes.len(),
@@ -152,7 +152,7 @@ impl<B: ExtensibleField<2>> FieldElement for QuadExtension<B> {
         let len = bytes.len() / Self::ELEMENT_BYTES;
 
         // make sure the bytes are aligned on the boundary consistent with base element alignment
-        if (p as usize) % Self::BaseField::ELEMENT_BYTES != 0 {
+        if !(p as usize).is_multiple_of(Self::BaseField::ELEMENT_BYTES) {
             return Err(DeserializationError::InvalidValue(
                 "slice memory alignment is not valid for this field element type".to_string(),
             ));
diff --git a/math/src/field/f128/mod.rs b/math/src/field/f128/mod.rs
@@ -119,7 +119,7 @@ impl FieldElement for BaseElement {
     }
 
     unsafe fn bytes_as_elements(bytes: &[u8]) -> Result<&[Self], DeserializationError> {
-        if bytes.len() % Self::ELEMENT_BYTES != 0 {
+        if !bytes.len().is_multiple_of(Self::ELEMENT_BYTES) {
             return Err(DeserializationError::InvalidValue(format!(
                 "number of bytes ({}) does not divide into whole number of field elements",
                 bytes.len(),
@@ -129,7 +129,7 @@ impl FieldElement for BaseElement {
         let p = bytes.as_ptr();
         let len = bytes.len() / Self::ELEMENT_BYTES;
 
-        if (p as usize) % mem::align_of::<u128>() != 0 {
+        if !(p as usize).is_multiple_of(mem::align_of::<u128>()) {
             return Err(DeserializationError::InvalidValue(
                 "slice memory alignment is not valid for this field element type".to_string(),
             ));
diff --git a/math/src/field/f62/mod.rs b/math/src/field/f62/mod.rs
@@ -156,7 +156,7 @@ impl FieldElement for BaseElement {
     }
 
     unsafe fn bytes_as_elements(bytes: &[u8]) -> Result<&[Self], DeserializationError> {
-        if bytes.len() % Self::ELEMENT_BYTES != 0 {
+        if !bytes.len().is_multiple_of(Self::ELEMENT_BYTES) {
             return Err(DeserializationError::InvalidValue(format!(
                 "number of bytes ({}) does not divide into whole number of field elements",
                 bytes.len(),
@@ -166,7 +166,7 @@ impl FieldElement for BaseElement {
         let p = bytes.as_ptr();
         let len = bytes.len() / Self::ELEMENT_BYTES;
 
-        if (p as usize) % mem::align_of::<u64>() != 0 {
+        if !(p as usize).is_multiple_of(mem::align_of::<u64>()) {
             return Err(DeserializationError::InvalidValue(
                 "slice memory alignment is not valid for this field element type".to_string(),
             ));
diff --git a/math/src/field/f64/mod.rs b/math/src/field/f64/mod.rs
@@ -217,7 +217,7 @@ impl FieldElement for BaseElement {
     }
 
     unsafe fn bytes_as_elements(bytes: &[u8]) -> Result<&[Self], DeserializationError> {
-        if bytes.len() % Self::ELEMENT_BYTES != 0 {
+        if !bytes.len().is_multiple_of(Self::ELEMENT_BYTES) {
             return Err(DeserializationError::InvalidValue(format!(
                 "number of bytes ({}) does not divide into whole number of field elements",
                 bytes.len(),
@@ -227,7 +227,7 @@ impl FieldElement for BaseElement {
         let p = bytes.as_ptr();
         let len = bytes.len() / Self::ELEMENT_BYTES;
 
-        if (p as usize) % mem::align_of::<u64>() != 0 {
+        if !(p as usize).is_multiple_of(mem::align_of::<u64>()) {
             return Err(DeserializationError::InvalidValue(
                 "slice memory alignment is not valid for this field element type".to_string(),
             ));
diff --git a/prover/src/matrix/row_matrix.rs b/prover/src/matrix/row_matrix.rs
@@ -281,7 +281,7 @@ pub fn build_segments<E: FieldElement, const N: usize>(
     debug_assert_eq!(polys.num_rows(), twiddles.len() * 2);
     debug_assert_eq!(offsets.len() % polys.num_rows(), 0);
 
-    let num_segments = if polys.num_base_cols() % N == 0 {
+    let num_segments = if polys.num_base_cols().is_multiple_of(N) {
         polys.num_base_cols() / N
     } else {
         polys.num_base_cols() / N + 1

Original file line number	Diff line number	Diff line change
`@@ -191,7 +191,7 @@ impl<E: FieldElement> Assertion<E> {`
`191`	`191`	`return false;`
`192`	`192`	`}`
`193`	`193`	`if other.is_single() \|\| self.stride < other.stride {`
`194`		`- (other.first_step - self.first_step) % self.stride == 0`
	`194`	`+ (other.first_step - self.first_step).is_multiple_of(self.stride)`
`195`	`195`	`} else {`
`196`	`196`	`false`
`197`	`197`	`}`
`@@ -200,7 +200,7 @@ impl<E: FieldElement> Assertion<E> {`
`200`	`200`	`return false;`
`201`	`201`	`}`
`202`	`202`	`if self.is_single() \|\| other.stride < self.stride {`
`203`		`- (self.first_step - other.first_step) % other.stride == 0`
	`203`	`+ (self.first_step - other.first_step).is_multiple_of(other.stride)`
`204`	`204`	`} else {`
`205`	`205`	`false`
`206`	`206`	`}`
Original file line number	Diff line number	Diff line change
`@@ -253,7 +253,7 @@ mod tests {`
`253`	`253`	`let expected = polynom::eval(&poly, g.exp((i as u32).into()));`
`254`	`254`	`let actual = divisor.evaluate_at(g.exp((i as u32).into()));`
`255`	`255`	`assert_eq!(expected, actual);`
`256`		`- if i % (j as usize) == 0 {`
	`256`	`+ if i.is_multiple_of(j as usize) {`
`257`	`257`	`assert_eq!(BaseElement::ZERO, actual);`
`258`	`258`	`}`
`259`	`259`	`}`
Original file line number	Diff line number	Diff line change
`@@ -181,7 +181,7 @@ impl Air for LamportAggregateAir {`
`181`	`181`	`for (i, value) in powers_of_two.iter_mut().enumerate().skip(1) {`
`182`	`182`	`// we switch to a new power of two once every 8 steps this. is so that a`
`183`	`183`	`// new power of two is available for every hash cycle`
`184`		`- if i % HASH_CYCLE_LEN == 0 {`
	`184`	`+ if i.is_multiple_of(HASH_CYCLE_LEN) {`
`185`	`185`	`current_power_of_two *= TWO;`
`186`	`186`	`}`
`187`	`187`	`*value = current_power_of_two;`
Original file line number	Diff line number	Diff line change
`@@ -216,7 +216,7 @@ impl Air for LamportThresholdAir {`
`216`	`216`	`for (i, value) in powers_of_two.iter_mut().enumerate().skip(1) {`
`217`	`217`	`// we switch to a new power of two once every 8 steps this. is so that a`
`218`	`218`	`// new power of two is available for every hash cycle`
`219`		`- if i % HASH_CYCLE_LEN == 0 {`
	`219`	`+ if i.is_multiple_of(HASH_CYCLE_LEN) {`
`220`	`220`	`current_power_of_two *= TWO;`
`221`	`221`	`}`
`222`	`222`	`*value = current_power_of_two;`
Original file line number	Diff line number	Diff line change
`@@ -69,7 +69,7 @@ pub fn print_trace<E: StarkField>(`
`69`	`69`
`70`	`70`	`let mut state = vec![E::ZERO; trace_width];`
`71`	`71`	`for i in 0..trace.length() {`
`72`		`- if (i.wrapping_sub(offset)) % multiples_of != 0 {`
	`72`	`+ if !(i.wrapping_sub(offset)).is_multiple_of(multiples_of) {`
`73`	`73`	`continue;`
`74`	`74`	`}`
`75`	`75`	`trace.read_row_into(i, &mut state);`
Original file line number	Diff line number	Diff line change
`@@ -298,7 +298,7 @@ impl FriProofLayer {`
`298`	`298`	`{`
`299`	`299`	`// make sure the number of value bytes can be parsed into a whole number of queries`
`300`	`300`	`let num_query_bytes = E::ELEMENT_BYTES * folding_factor;`
`301`		`- if self.values.len() % num_query_bytes != 0 {`
	`301`	`+ if !self.values.len().is_multiple_of(num_query_bytes) {`
`302`	`302`	`return Err(DeserializationError::InvalidValue(format!(`
`303`	`303`	`"number of value bytes ({}) does not divide into whole number of queries",`
`304`	`304`	`self.values.len(),`