[chore] Bump version to 0.5.0 and fix clippy (#19)

jonathanpwang · web-flow · commit aa4d981060a1 · 2023-12-18T13:55:08.000-05:00
Sync with upstream for v0.5.0
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "halo2curves-axiom"
-version = "0.4.4"
+version = "0.5.0"
 authors = ["Privacy Scaling Explorations team", "Taiko Labs", "Intrinsic Technologies"]
 license = "MIT/Apache-2.0"
 edition = "2021"
diff --git a/src/derive/curve.rs b/src/derive/curve.rs
@@ -305,12 +305,11 @@ macro_rules! new_curve_impl {
                 }
 
                 paste::paste! {
-                    #[allow(unused_imports)]
-                    use ::serde::de::Error as _;
                     impl<'de> ::serde::Deserialize<'de> for $name {
                         fn deserialize<D: ::serde::Deserializer<'de>>(
                             deserializer: D,
                         ) -> Result<Self, D::Error> {
+                            use ::serde::de::Error as _;
                             let bytes = if deserializer.is_human_readable() {
                                 ::hex::serde::deserialize(deserializer)?
                             } else {
@@ -335,12 +334,11 @@ macro_rules! new_curve_impl {
                 }
 
                 paste::paste! {
-                    #[allow(unused_imports)]
-                    use ::serde::de::Error as _;
                     impl<'de> ::serde::Deserialize<'de> for $name_affine {
                         fn deserialize<D: ::serde::Deserializer<'de>>(
                             deserializer: D,
                         ) -> Result<Self, D::Error> {
+                            use ::serde::de::Error as _;
                             let bytes = if deserializer.is_human_readable() {
                                 ::hex::serde::deserialize(deserializer)?
                             } else {
@@ -532,6 +530,7 @@ macro_rules! new_curve_impl {
             }
 
 
+            #[allow(clippy::redundant_closure_call)]
             fn hash_to_curve<'a>(domain_prefix: &'a str) -> Box<dyn Fn(&[u8]) -> Self + 'a> {
                 $hash_to_curve($curve_id, domain_prefix)
             }
diff --git a/src/derive/field.rs b/src/derive/field.rs
@@ -63,7 +63,7 @@ macro_rules! field_common {
                 $crate::ff_ext::jacobi::jacobi::<5>(&self.0, &$modulus.0)
             }
 
-            #[allow(dead_code)]
+            #[cfg(feature = "asm")]
             const fn montgomery_form(val: [u64; 4], r: $field) -> $field {
                 // Converts a 4 64-bit limb value into its congruent field representation.
                 // If `val` representes a 256 bit value then `r` should be R^2,
diff --git a/src/ff_ext/inverse.rs b/src/ff_ext/inverse.rs
@@ -57,12 +57,12 @@ impl<const B: usize, const L: usize> Add for &CInt<B, L> {
     type Output = CInt<B, L>;
     fn add(self, other: Self) -> Self::Output {
         let (mut data, mut carry) = ([0; L], 0);
-        for i in 0..L {
+        for (i, d) in data.iter_mut().enumerate().take(L) {
             let sum = self.0[i] + other.0[i] + carry;
-            data[i] = sum & CInt::<B, L>::MASK;
+            *d = sum & CInt::<B, L>::MASK;
             carry = sum >> B;
         }
-        Self::Output { 0: data }
+        CInt::<B, L>(data)
     }
 }
 
@@ -91,12 +91,12 @@ impl<const B: usize, const L: usize> Sub for &CInt<B, L> {
         // addition algorithm, where the carry flag is initialized with 1 and
         // the chunks of the second argument are bitwise inverted
         let (mut data, mut carry) = ([0; L], 1);
-        for i in 0..L {
+        for (i, d) in data.iter_mut().enumerate().take(L) {
             let sum = self.0[i] + (other.0[i] ^ CInt::<B, L>::MASK) + carry;
-            data[i] = sum & CInt::<B, L>::MASK;
+            *d = sum & CInt::<B, L>::MASK;
             carry = sum >> B;
         }
-        Self::Output { 0: data }
+        CInt::<B, L>(data)
     }
 }
 
@@ -120,12 +120,12 @@ impl<const B: usize, const L: usize> Neg for &CInt<B, L> {
         // For the two's complement code the additive negation is the result
         // of adding 1 to the bitwise inverted argument's representation
         let (mut data, mut carry) = ([0; L], 1);
-        for i in 0..L {
+        for (i, d) in data.iter_mut().enumerate().take(L) {
             let sum = (self.0[i] ^ CInt::<B, L>::MASK) + carry;
-            data[i] = sum & CInt::<B, L>::MASK;
+            *d = sum & CInt::<B, L>::MASK;
             carry = sum >> B;
         }
-        Self::Output { 0: data }
+        CInt::<B, L>(data)
     }
 }
 
@@ -150,7 +150,7 @@ impl<const B: usize, const L: usize> Mul for &CInt<B, L> {
                 carry = (sum >> B) as u64;
             }
         }
-        Self::Output { 0: data }
+        CInt::<B, L>(data)
     }
 }
 
@@ -189,12 +189,12 @@ impl<const B: usize, const L: usize> Mul<i64> for &CInt<B, L> {
         } else {
             (other, 0, 0)
         };
-        for i in 0..L {
+        for (i, d) in data.iter_mut().enumerate().take(L) {
             let sum = (carry as u128) + ((self.0[i] ^ mask) as u128) * (other as u128);
-            data[i] = sum as u64 & CInt::<B, L>::MASK;
+            *d = sum as u64 & CInt::<B, L>::MASK;
             carry = (sum >> B) as u64;
         }
-        Self::Output { 0: data }
+        CInt::<B, L>(data)
     }
 }
 
diff --git a/src/ff_ext/jacobi.rs b/src/ff_ext/jacobi.rs
@@ -74,14 +74,15 @@ impl<const L: usize> Shr<u32> for &LInt<L> {
             "Cannot shift by 0 or more than 63 bits!"
         );
         let (mut data, right) = ([0; L], u64::BITS - bits);
-        for i in 0..(L - 1) {
-            data[i] = (self.0[i] >> bits) | (self.0[i + 1] << right);
+
+        for (i, d) in data.iter_mut().enumerate().take(L - 1) {
+            *d = (self.0[i] >> bits) | (self.0[i + 1] << right);
         }
         data[L - 1] = self.0[L - 1] >> bits;
         if self.is_negative() {
             data[L - 1] |= u64::MAX << right;
         }
-        Self::Output { 0: data }
+        LInt::<L>(data)
     }
 }
 
@@ -96,10 +97,10 @@ impl<const L: usize> Add for &LInt<L> {
     type Output = LInt<L>;
     fn add(self, other: Self) -> Self::Output {
         let (mut data, mut carry) = ([0; L], false);
-        for i in 0..L {
-            (data[i], carry) = Self::Output::sum(self.0[i], other.0[i], carry);
+        for (i, d) in data.iter_mut().enumerate().take(L) {
+            (*d, carry) = Self::Output::sum(self.0[i], other.0[i], carry);
         }
-        Self::Output { 0: data }
+        LInt::<L>(data)
     }
 }
 
@@ -128,10 +129,10 @@ impl<const L: usize> Sub for &LInt<L> {
         // addition algorithm, where the carry flag is initialized with "true"
         // and the chunks of the second argument are bitwise inverted
         let (mut data, mut carry) = ([0; L], true);
-        for i in 0..L {
-            (data[i], carry) = Self::Output::sum(self.0[i], !other.0[i], carry);
+        for (i, d) in data.iter_mut().enumerate().take(L) {
+            (*d, carry) = Self::Output::sum(self.0[i], !other.0[i], carry);
         }
-        Self::Output { 0: data }
+        LInt::<L>(data)
     }
 }
 
@@ -155,10 +156,10 @@ impl<const L: usize> Neg for &LInt<L> {
         // For the two's complement code the additive negation is the result
         // of adding 1 to the bitwise inverted argument's representation
         let (mut data, mut carry) = ([0; L], true);
-        for i in 0..L {
-            (data[i], carry) = (!self.0[i]).overflowing_add(carry as u64);
+        for (i, d) in data.iter_mut().enumerate().take(L) {
+            (*d, carry) = (!self.0[i]).overflowing_add(carry as u64);
         }
-        Self::Output { 0: data }
+        LInt::<L>(data)
     }
 }
 
@@ -180,7 +181,7 @@ impl<const L: usize> Mul for &LInt<L> {
                     Self::Output::prodsum(self.0[i], other.0[k], data[i + k], carry);
             }
         }
-        Self::Output { 0: data }
+        LInt::<L>(data)
     }
 }
 
@@ -219,11 +220,10 @@ impl<const L: usize> Mul<i64> for &LInt<L> {
         } else {
             (other as u64, 0, 0)
         };
-        #[allow(clippy::needless_range_loop)]
-        for i in 0..L {
-            (data[i], carry) = Self::Output::prodsum(self.0[i] ^ mask, other, 0, carry);
+        for (i, d) in data.iter_mut().enumerate().take(L) {
+            (*d, carry) = Self::Output::prodsum(self.0[i] ^ mask, other, 0, carry);
         }
-        Self::Output { 0: data }
+        LInt::<L>(data)
     }
 }
 
diff --git a/src/msm.rs b/src/msm.rs
@@ -102,7 +102,7 @@ pub fn multiexp_serial<C: CurveAffine>(coeffs: &[C::Scalar], bases: &[C], acc: &
         let mut buckets: Vec<Bucket<C>> = vec![Bucket::None; 1 << (c - 1)];
 
         for (coeff, base) in coeffs.iter().zip(bases.iter()) {
-            let coeff = get_booth_index(current_window as usize, c, coeff.as_ref());
+            let coeff = get_booth_index(current_window, c, coeff.as_ref());
             if coeff.is_positive() {
                 buckets[coeff as usize - 1].add_assign(base);
             }
@@ -333,7 +333,7 @@ mod test {
                     acc = acc.double();
                 }
 
-                let idx = super::get_booth_index(i as usize, window, u.as_ref());
+                let idx = super::get_booth_index(i, window, u.as_ref());
 
                 if idx.is_negative() {
                     acc += table[idx.unsigned_abs() as usize].neg();
diff --git a/src/pluto_eris/fields/fp12.rs b/src/pluto_eris/fields/fp12.rs
@@ -643,7 +643,7 @@ fn test_frobenius() {
             let mut b = a;
 
             for _ in 0..i {
-                a = a.pow_vartime(&[
+                a = a.pow_vartime([
                     0x9ffffcd300000001,
                     0xa2a7e8c30006b945,
                     0xe4a7a5fe8fadffd6,
diff --git a/src/pluto_eris/fields/fp2.rs b/src/pluto_eris/fields/fp2.rs
@@ -381,7 +381,7 @@ impl Field for Fp2 {
         };
 
         // Algorithm (not constant time)
-        let b = self.pow_vartime(&[
+        let b = self.pow_vartime([
             // (p-1)/4 =
             // 0x900000000000900004c3800035fdc392a00f29dbd0e499bd10fe69736a29b1ef929e97fa3eb7ff5a8a9fa30c001ae5167ffff34c0000000
             0x67ffff34c0000000,
@@ -747,7 +747,7 @@ fn test_frobenius() {
             let mut b = a;
 
             for _ in 0..i {
-                a = a.pow_vartime(&[
+                a = a.pow_vartime([
                     0x9ffffcd300000001,
                     0xa2a7e8c30006b945,
                     0xe4a7a5fe8fadffd6,
diff --git a/src/pluto_eris/fields/fp6.rs b/src/pluto_eris/fields/fp6.rs
@@ -762,7 +762,7 @@ fn test_frobenius() {
             let mut b = a;
 
             for _ in 0..i {
-                a = a.pow_vartime(&[
+                a = a.pow_vartime([
                     // p
                     0x9ffffcd300000001,
                     0xa2a7e8c30006b945,
diff --git a/src/pluto_eris/mod.rs b/src/pluto_eris/mod.rs
@@ -5,9 +5,6 @@
 //! Supporting evidence: https://github.com/daira/pluto-eris
 //! Field constant derivation: https://github.com/davidnevadoc/ec-constants/tree/main/pluto_eris
 //! Pairing constants derivation: https://github.com/John-Gong-Math/pluto_eris/blob/main/pluto_pairing.ipynb
-
-// temporarily allow clippy::all to avoid warnings in this module:
-#[allow(clippy::all)]
 mod curve;
 mod engine;
 mod fields;

Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,7 @@ macro_rules! field_common {`
`63`	`63`	`$crate::ff_ext::jacobi::jacobi::<5>(&self.0, &$modulus.0)`
`64`	`64`	`}`
`65`	`65`
`66`		`- #[allow(dead_code)]`
	`66`	`+ #[cfg(feature = "asm")]`
`67`	`67`	`const fn montgomery_form(val: [u64; 4], r: $field) -> $field {`
`68`	`68`	`// Converts a 4 64-bit limb value into its congruent field representation.`
`69`	`69`	// If `val` representes a 256 bit value then `r` should be R^2,
Original file line number	Diff line number	Diff line change
`@@ -57,12 +57,12 @@ impl<const B: usize, const L: usize> Add for &CInt<B, L> {`
`57`	`57`	`type Output = CInt<B, L>;`
`58`	`58`	`fn add(self, other: Self) -> Self::Output {`
`59`	`59`	`let (mut data, mut carry) = ([0; L], 0);`
`60`		`- for i in 0..L {`
	`60`	`+ for (i, d) in data.iter_mut().enumerate().take(L) {`
`61`	`61`	`let sum = self.0[i] + other.0[i] + carry;`
`62`		`- data[i] = sum & CInt::<B, L>::MASK;`
	`62`	`+ *d = sum & CInt::<B, L>::MASK;`
`63`	`63`	`carry = sum >> B;`
`64`	`64`	`}`
`65`		`- Self::Output { 0: data }`
	`65`	`+ CInt::<B, L>(data)`
`66`	`66`	`}`
`67`	`67`	`}`
`68`	`68`
`@@ -91,12 +91,12 @@ impl<const B: usize, const L: usize> Sub for &CInt<B, L> {`
`91`	`91`	`// addition algorithm, where the carry flag is initialized with 1 and`
`92`	`92`	`// the chunks of the second argument are bitwise inverted`
`93`	`93`	`let (mut data, mut carry) = ([0; L], 1);`
`94`		`- for i in 0..L {`
	`94`	`+ for (i, d) in data.iter_mut().enumerate().take(L) {`
`95`	`95`	`let sum = self.0[i] + (other.0[i] ^ CInt::<B, L>::MASK) + carry;`
`96`		`- data[i] = sum & CInt::<B, L>::MASK;`
	`96`	`+ *d = sum & CInt::<B, L>::MASK;`
`97`	`97`	`carry = sum >> B;`
`98`	`98`	`}`
`99`		`- Self::Output { 0: data }`
	`99`	`+ CInt::<B, L>(data)`
`100`	`100`	`}`
`101`	`101`	`}`
`102`	`102`
`@@ -120,12 +120,12 @@ impl<const B: usize, const L: usize> Neg for &CInt<B, L> {`
`120`	`120`	`// For the two's complement code the additive negation is the result`
`121`	`121`	`// of adding 1 to the bitwise inverted argument's representation`
`122`	`122`	`let (mut data, mut carry) = ([0; L], 1);`
`123`		`- for i in 0..L {`
	`123`	`+ for (i, d) in data.iter_mut().enumerate().take(L) {`
`124`	`124`	`let sum = (self.0[i] ^ CInt::<B, L>::MASK) + carry;`
`125`		`- data[i] = sum & CInt::<B, L>::MASK;`
	`125`	`+ *d = sum & CInt::<B, L>::MASK;`
`126`	`126`	`carry = sum >> B;`
`127`	`127`	`}`
`128`		`- Self::Output { 0: data }`
	`128`	`+ CInt::<B, L>(data)`
`129`	`129`	`}`
`130`	`130`	`}`
`131`	`131`
`@@ -150,7 +150,7 @@ impl<const B: usize, const L: usize> Mul for &CInt<B, L> {`
`150`	`150`	`carry = (sum >> B) as u64;`
`151`	`151`	`}`
`152`	`152`	`}`
`153`		`- Self::Output { 0: data }`
	`153`	`+ CInt::<B, L>(data)`
`154`	`154`	`}`
`155`	`155`	`}`
`156`	`156`
`@@ -189,12 +189,12 @@ impl<const B: usize, const L: usize> Mul<i64> for &CInt<B, L> {`
`189`	`189`	`} else {`
`190`	`190`	`(other, 0, 0)`
`191`	`191`	`};`
`192`		`- for i in 0..L {`
	`192`	`+ for (i, d) in data.iter_mut().enumerate().take(L) {`
`193`	`193`	`let sum = (carry as u128) + ((self.0[i] ^ mask) as u128) * (other as u128);`
`194`		`- data[i] = sum as u64 & CInt::<B, L>::MASK;`
	`194`	`+ *d = sum as u64 & CInt::<B, L>::MASK;`
`195`	`195`	`carry = (sum >> B) as u64;`
`196`	`196`	`}`
`197`		`- Self::Output { 0: data }`
	`197`	`+ CInt::<B, L>(data)`
`198`	`198`	`}`
`199`	`199`	`}`
`200`	`200`
Original file line number	Diff line number	Diff line change
`@@ -74,14 +74,15 @@ impl<const L: usize> Shr<u32> for &LInt<L> {`
`74`	`74`	`"Cannot shift by 0 or more than 63 bits!"`
`75`	`75`	`);`
`76`	`76`	`let (mut data, right) = ([0; L], u64::BITS - bits);`
`77`		`- for i in 0..(L - 1) {`
`78`		`- data[i] = (self.0[i] >> bits) \| (self.0[i + 1] << right);`
	`77`	`+`
	`78`	`+ for (i, d) in data.iter_mut().enumerate().take(L - 1) {`
	`79`	`+ *d = (self.0[i] >> bits) \| (self.0[i + 1] << right);`
`79`	`80`	`}`
`80`	`81`	`data[L - 1] = self.0[L - 1] >> bits;`
`81`	`82`	`if self.is_negative() {`
`82`	`83`	`data[L - 1] \|= u64::MAX << right;`
`83`	`84`	`}`
`84`		`- Self::Output { 0: data }`
	`85`	`+ LInt::<L>(data)`
`85`	`86`	`}`
`86`	`87`	`}`
`87`	`88`
`@@ -96,10 +97,10 @@ impl<const L: usize> Add for &LInt<L> {`
`96`	`97`	`type Output = LInt<L>;`
`97`	`98`	`fn add(self, other: Self) -> Self::Output {`
`98`	`99`	`let (mut data, mut carry) = ([0; L], false);`
`99`		`- for i in 0..L {`
`100`		`- (data[i], carry) = Self::Output::sum(self.0[i], other.0[i], carry);`
	`100`	`+ for (i, d) in data.iter_mut().enumerate().take(L) {`
	`101`	`+ (*d, carry) = Self::Output::sum(self.0[i], other.0[i], carry);`
`101`	`102`	`}`
`102`		`- Self::Output { 0: data }`
	`103`	`+ LInt::<L>(data)`
`103`	`104`	`}`
`104`	`105`	`}`
`105`	`106`
`@@ -128,10 +129,10 @@ impl<const L: usize> Sub for &LInt<L> {`
`128`	`129`	`// addition algorithm, where the carry flag is initialized with "true"`
`129`	`130`	`// and the chunks of the second argument are bitwise inverted`
`130`	`131`	`let (mut data, mut carry) = ([0; L], true);`
`131`		`- for i in 0..L {`
`132`		`- (data[i], carry) = Self::Output::sum(self.0[i], !other.0[i], carry);`
	`132`	`+ for (i, d) in data.iter_mut().enumerate().take(L) {`
	`133`	`+ (*d, carry) = Self::Output::sum(self.0[i], !other.0[i], carry);`
`133`	`134`	`}`
`134`		`- Self::Output { 0: data }`
	`135`	`+ LInt::<L>(data)`
`135`	`136`	`}`
`136`	`137`	`}`
`137`	`138`
`@@ -155,10 +156,10 @@ impl<const L: usize> Neg for &LInt<L> {`
`155`	`156`	`// For the two's complement code the additive negation is the result`
`156`	`157`	`// of adding 1 to the bitwise inverted argument's representation`
`157`	`158`	`let (mut data, mut carry) = ([0; L], true);`
`158`		`- for i in 0..L {`
`159`		`- (data[i], carry) = (!self.0[i]).overflowing_add(carry as u64);`
	`159`	`+ for (i, d) in data.iter_mut().enumerate().take(L) {`
	`160`	`+ (*d, carry) = (!self.0[i]).overflowing_add(carry as u64);`
`160`	`161`	`}`
`161`		`- Self::Output { 0: data }`
	`162`	`+ LInt::<L>(data)`
`162`	`163`	`}`
`163`	`164`	`}`
`164`	`165`
`@@ -180,7 +181,7 @@ impl<const L: usize> Mul for &LInt<L> {`
`180`	`181`	`Self::Output::prodsum(self.0[i], other.0[k], data[i + k], carry);`
`181`	`182`	`}`
`182`	`183`	`}`
`183`		`- Self::Output { 0: data }`
	`184`	`+ LInt::<L>(data)`
`184`	`185`	`}`
`185`	`186`	`}`
`186`	`187`
`@@ -219,11 +220,10 @@ impl<const L: usize> Mul<i64> for &LInt<L> {`
`219`	`220`	`} else {`
`220`	`221`	`(other as u64, 0, 0)`
`221`	`222`	`};`
`222`		`- #[allow(clippy::needless_range_loop)]`
`223`		`- for i in 0..L {`
`224`		`- (data[i], carry) = Self::Output::prodsum(self.0[i] ^ mask, other, 0, carry);`
	`223`	`+ for (i, d) in data.iter_mut().enumerate().take(L) {`
	`224`	`+ (*d, carry) = Self::Output::prodsum(self.0[i] ^ mask, other, 0, carry);`
`225`	`225`	`}`
`226`		`- Self::Output { 0: data }`
	`226`	`+ LInt::<L>(data)`
`227`	`227`	`}`
`228`	`228`	`}`
`229`	`229`
Original file line number	Diff line number	Diff line change
`@@ -102,7 +102,7 @@ pub fn multiexp_serial<C: CurveAffine>(coeffs: &[C::Scalar], bases: &[C], acc: &`
`102`	`102`	`let mut buckets: Vec<Bucket<C>> = vec![Bucket::None; 1 << (c - 1)];`
`103`	`103`
`104`	`104`	`for (coeff, base) in coeffs.iter().zip(bases.iter()) {`
`105`		`- let coeff = get_booth_index(current_window as usize, c, coeff.as_ref());`
	`105`	`+ let coeff = get_booth_index(current_window, c, coeff.as_ref());`
`106`	`106`	`if coeff.is_positive() {`
`107`	`107`	`buckets[coeff as usize - 1].add_assign(base);`
`108`	`108`	`}`
`@@ -333,7 +333,7 @@ mod test {`
`333`	`333`	`acc = acc.double();`
`334`	`334`	`}`
`335`	`335`
`336`		`- let idx = super::get_booth_index(i as usize, window, u.as_ref());`
	`336`	`+ let idx = super::get_booth_index(i, window, u.as_ref());`
`337`	`337`
`338`	`338`	`if idx.is_negative() {`
`339`	`339`	`acc += table[idx.unsigned_abs() as usize].neg();`