Added #[rustfmt::skip] where necessary

src/backend/serial/u32/field.rs

@@ -120,6 +120,8 @@ impl<'b> MulAssign<&'b FieldElement2625> for FieldElement2625 {
 
 impl<'a, 'b> Mul<&'b FieldElement2625> for &'a FieldElement2625 {
     type Output = FieldElement2625;
+
+    #[rustfmt::skip] // keep alignment of z* calculations
     fn mul(self, _rhs: &'b FieldElement2625) -> FieldElement2625 {
         /// Helper function to multiply two 32-bit integers with 64 bits
         /// of output.
@@ -328,6 +330,7 @@ impl FieldElement2625 {
     ///
     /// In other words, each coefficient of the result is bounded by
     /// either `2^(25 + 0.007)` or `2^(26 + 0.007)`, as appropriate.
+    #[rustfmt::skip] // keep alignment of carry chain
     fn reduce(mut z: [u64; 10]) -> FieldElement2625 {
 
         const LOW_25_BITS: u64 = (1 << 25) - 1;
@@ -521,6 +524,7 @@ impl FieldElement2625 {
         s
     }
 
+    #[rustfmt::skip] // keep alignment of z* calculations
     fn square_inner(&self) -> [u64; 10] {
         // Optimized version of multiplication for the case of squaring.
         // Pre- and post- conditions identical to multiplication function.

src/backend/serial/u32/scalar.rs

@@ -59,6 +59,7 @@ impl Scalar29 {
     }
 
     /// Unpack a 32 byte / 256 bit scalar into 9 29-bit limbs.
+    #[rustfmt::skip] // keep alignment of s[*] calculations
     pub fn from_bytes(bytes: &[u8; 32]) -> Scalar29 {
         let mut words = [0u32; 8];
         for i in 0..8 {
@@ -85,6 +86,7 @@ impl Scalar29 {
     }
 
     /// Reduce a 64 byte / 512 bit scalar mod l.
+    #[rustfmt::skip] // keep alignment of lo[*] calculations
     pub fn from_bytes_wide(bytes: &[u8; 64]) -> Scalar29 {
         let mut words = [0u32; 16];
         for i in 0..16 {
@@ -123,6 +125,7 @@ impl Scalar29 {
     }
 
     /// Pack the limbs of this `Scalar29` into 32 bytes.
+    #[rustfmt::skip] // keep alignment of s[*] calculations
     pub fn to_bytes(&self) -> [u8; 32] {
         let mut s = [0u8; 32];
 
@@ -205,6 +208,7 @@ impl Scalar29 {
     ///
     /// This is implemented with a one-level refined Karatsuba decomposition
     #[inline(always)]
+    #[rustfmt::skip] // keep alignment of z[*] calculations
     pub (crate) fn mul_internal(a: &Scalar29, b: &Scalar29) -> [u64; 17] {
         let mut z = [0u64; 17];
 
@@ -262,6 +266,7 @@ impl Scalar29 {
 
     /// Compute `a^2`.
     #[inline(always)]
+    #[rustfmt::skip] // keep alignment of calculations
     fn square_internal(a: &Scalar29) -> [u64; 17] {
         let aa = [
             a[0]*2,

src/backend/serial/u64/field.rs

@@ -108,6 +108,8 @@ impl<'b> MulAssign<&'b FieldElement51> for FieldElement51 {
 
 impl<'a, 'b> Mul<&'b FieldElement51> for &'a FieldElement51 {
     type Output = FieldElement51;
+
+    #[rustfmt::skip] // keep alignment of c* calculations
     fn mul(self, _rhs: &'b FieldElement51) -> FieldElement51 {
         /// Helper function to multiply two 64-bit integers with 128
         /// bits of output.
@@ -328,6 +330,7 @@ impl FieldElement51 {
     /// the canonical encoding, and check that the input was
     /// canonical.
     ///
+    #[rustfmt::skip] // keep alignment of bit shifts
     pub fn from_bytes(bytes: &[u8; 32]) -> FieldElement51 {
         let load8 = |input: &[u8]| -> u64 {
                (input[0] as u64)
@@ -357,6 +360,7 @@ impl FieldElement51 {
 
     /// Serialize this `FieldElement51` to a 32-byte array.  The
     /// encoding is canonical.
+    #[rustfmt::skip] // keep alignment of s[*] calculations
     pub fn to_bytes(&self) -> [u8; 32] {
         // Let h = limbs[0] + limbs[1]*2^51 + ... + limbs[4]*2^204.
         //
@@ -442,6 +446,7 @@ impl FieldElement51 {
     }
 
     /// Given `k > 0`, return `self^(2^k)`.
+    #[rustfmt::skip] // keep alignment of c* calculations
     pub fn pow2k(&self, mut k: u32) -> FieldElement51 {
 
         debug_assert!( k > 0 );

src/backend/serial/u64/scalar.rs

@@ -61,6 +61,7 @@ impl Scalar52 {
     }
 
     /// Unpack a 32 byte / 256 bit scalar into 5 52-bit limbs.
+    #[rustfmt::skip] // keep alignment of s[*] calculations
     pub fn from_bytes(bytes: &[u8; 32]) -> Scalar52 {
         let mut words = [0u64; 4];
         for i in 0..4 {
@@ -83,6 +84,7 @@ impl Scalar52 {
     }
 
     /// Reduce a 64 byte / 512 bit scalar mod l
+    #[rustfmt::skip] // keep alignment of lo[*] and hi[*] calculations
     pub fn from_bytes_wide(bytes: &[u8; 64]) -> Scalar52 {
         let mut words = [0u64; 8];
         for i in 0..8 {
@@ -113,6 +115,7 @@ impl Scalar52 {
     }
 
     /// Pack the limbs of this `Scalar52` into 32 bytes
+    #[rustfmt::skip] // keep alignment of s[*] calculations
     pub fn to_bytes(&self) -> [u8; 32] {
         let mut s = [0u8; 32];
 
@@ -193,6 +196,7 @@ impl Scalar52 {
 
     /// Compute `a * b`
     #[inline(always)]
+    #[rustfmt::skip] // keep alignment of z[*] calculations
     pub (crate) fn mul_internal(a: &Scalar52, b: &Scalar52) -> [u128; 9] {
         let mut z = [0u128; 9];
 
@@ -211,6 +215,7 @@ impl Scalar52 {
 
     /// Compute `a^2`
     #[inline(always)]
+    #[rustfmt::skip] // keep alignment of return calculations
     fn square_internal(a: &Scalar52) -> [u128; 9] {
         let aa = [
             a[0]*2,
@@ -234,6 +239,7 @@ impl Scalar52 {
 
     /// Compute `limbs/R` (mod l), where R is the Montgomery modulus 2^260
     #[inline(always)]
+    #[rustfmt::skip] // keep alignment of n* and r* calculations
     pub (crate) fn montgomery_reduce(limbs: &[u128; 9]) -> Scalar52 {
 
         #[inline(always)]

src/backend/vector/avx2/edwards.rs

@@ -329,6 +329,7 @@ impl<'a> From<&'a edwards::EdwardsPoint> for NafLookupTable8<CachedPoint> {
 mod test {
     use super::*;
 
+    #[rustfmt::skip] // keep alignment of some S* calculations
     fn serial_add(P: edwards::EdwardsPoint, Q: edwards::EdwardsPoint) -> edwards::EdwardsPoint {
         use crate::backend::serial::u64::field::FieldElement51;
 

src/backend/vector/avx2/field.rs

@@ -184,6 +184,7 @@ impl ConditionallySelectable for FieldElement2625x4 {
 impl FieldElement2625x4 {
     /// Split this vector into an array of four (serial) field
     /// elements.
+    #[rustfmt::skip] // keep alignment of extracted lanes
     pub fn split(&self) -> [FieldElement51; 4] {
         let mut out = [FieldElement51::zero(); 4];
         for i in 0..5 {
@@ -337,6 +338,7 @@ impl FieldElement2625x4 {
     /// # Postconditions
     ///
     /// The resulting `FieldElement2625x4` is bounded with \\( b < 0.0002 \\).
+    #[rustfmt::skip] // keep alignment of computed lanes
     pub fn new(
         x0: &FieldElement51,
         x1: &FieldElement51,
@@ -521,6 +523,7 @@ impl FieldElement2625x4 {
     ///
     /// The coefficients of the result are bounded with \\( b < 0.007 \\).
     #[inline]
+    #[rustfmt::skip] // keep alignment of carry chain
     fn reduce64(mut z: [u64x4; 10]) -> FieldElement2625x4 {
         // These aren't const because splat isn't a const fn
         let LOW_25_BITS: u64x4 = u64x4::splat((1 << 25) - 1);
@@ -599,6 +602,7 @@ impl FieldElement2625x4 {
     /// # Postconditions
     ///
     /// The coefficients of the result are bounded with \\( b < 0.007 \\).
+    #[rustfmt::skip] // keep alignment of z* calculations
     pub fn square_and_negate_D(&self) -> FieldElement2625x4 {
         #[inline(always)]
         fn m(x: u32x8, y: u32x8) -> u64x4 {
@@ -780,6 +784,7 @@ impl<'a, 'b> Mul<&'b FieldElement2625x4> for &'a FieldElement2625x4 {
     ///
     /// The coefficients of the result are bounded with \\( b < 0.007 \\).
     ///
+    #[rustfmt::skip] // keep alignment of z* calculations
     fn mul(self, rhs: &'b FieldElement2625x4) -> FieldElement2625x4 {
         #[inline(always)]
         fn m(x: u32x8, y: u32x8) -> u64x4 {

src/field.rs

@@ -112,6 +112,7 @@ impl FieldElement {
 
     /// Compute (self^(2^250-1), self^11), used as a helper function
     /// within invert() and pow22523().
+    #[rustfmt::skip] // keep alignment of explanatory comments
     fn pow22501(&self) -> (FieldElement, FieldElement) {
         // Instead of managing which temporary variables are used
         // for what, we define as many as we need and leave stack
@@ -170,7 +171,7 @@ impl FieldElement {
             acc = &acc * input;
         }
 
-	// acc is nonzero iff all inputs are nonzero
+        // acc is nonzero iff all inputs are nonzero
         assert_eq!(acc.is_zero().unwrap_u8(), 0);
 
         // Compute the inverse of all products
@@ -191,6 +192,7 @@ impl FieldElement {
     /// x^(p-2)x = x^(p-1) = 1 (mod p).
     ///
     /// This function returns zero on input zero.
+    #[rustfmt::skip] // keep alignment of explanatory comments
     pub fn invert(&self) -> FieldElement {
         // The bits of p-2 = 2^255 -19 -2 are 11010111111...11.
         //
@@ -203,6 +205,7 @@ impl FieldElement {
     }
 
     /// Raise this field element to the power (p-5)/8 = 2^252 -3.
+    #[rustfmt::skip] // keep alignment of explanatory comments
     fn pow_p58(&self) -> FieldElement {
         // The bits of (p-5)/8 are 101111.....11.
         //

src/montgomery.rs

@@ -257,6 +257,7 @@ impl ProjectivePoint {
 /// $$
 ///     (U\_Q : W\_Q) \gets u(P + Q).
 /// $$
+#[rustfmt::skip] // keep alignment of explanatory comments
 fn differential_add_and_double(
     P: &mut ProjectivePoint,
     Q: &mut ProjectivePoint,