UintRef { limbs: ... } (#1129)

Changes `UintRef` from a tuple struct to having a `limbs` field like
every other `*Uint` type.

I don't know why I made it a tuple struct in the first place but now the
inconsistency is driving me insane.

Author: tarcieri

src/uint/encoding.rs

@@ -845,7 +845,7 @@ impl RadixDivisionParams {
                 remain_mut
                     .leading_mut(RADIX_ENCODING_LIMBS_LARGE - 1)
                     .copy_from(limbs_rem);
-                remain_mut.0[RADIX_ENCODING_LIMBS_LARGE - 1] = rem_high;
+                remain_mut.limbs[RADIX_ENCODING_LIMBS_LARGE - 1] = rem_high;
                 remain_mut.shr_assign_limb_vartime(self.shift_large);
 
                 (remain_mut, out_idx.saturating_sub(self.digits_large))

src/uint/mul.rs

@@ -261,14 +261,14 @@ pub(crate) const fn wrapping_mul_overflow(
     let mut j = lhs.nlimbs();
     let mut k = rhs.nlimbs().saturating_sub(1);
     while k > j {
-        rhs_tail = rhs_tail.bitor(rhs.0[k]);
+        rhs_tail = rhs_tail.bitor(rhs.limbs[k]);
         k -= 1;
     }
     while i < lhs.nlimbs() {
         j = lhs.nlimbs() - i;
         if j < rhs.nlimbs() {
-            rhs_tail = rhs_tail.bitor(rhs.0[j]);
-            overflow = overflow.or(lhs.0[i].is_nonzero().and(rhs_tail.is_nonzero()));
+            rhs_tail = rhs_tail.bitor(rhs.limbs[j]);
+            overflow = overflow.or(lhs.limbs[i].is_nonzero().and(rhs_tail.is_nonzero()));
         }
         i += 1;
     }

src/uint/mul/karatsuba.rs

@@ -64,8 +64,8 @@ pub const fn widening_mul_fixed<const LHS: usize, const RHS: usize>(
         let (mut l0c, mut l1c) = (Limb::ZERO, Limb::ZERO);
         let mut i = 0;
         while i < HALF {
-            (l0.limbs[i], l0c) = x0.0[i].carrying_add(x1.0[i], l0c);
-            (l1.limbs[i], l1c) = y0.0[i].carrying_add(y1.0[i], l1c);
+            (l0.limbs[i], l0c) = x0.limbs[i].carrying_add(x1.limbs[i], l0c);
+            (l1.limbs[i], l1c) = y0.limbs[i].carrying_add(y1.limbs[i], l1c);
             i += 1;
         }
         let z1 = widening_mul_fixed(l0.as_uint_ref(), l1.as_uint_ref());
@@ -456,7 +456,7 @@ pub(crate) const fn wrapping_square(uint: &UintRef, out: &mut UintRef) -> Limb {
             if tail.is_empty() {
                 Limb::ZERO
             } else {
-                tail.0[0]
+                tail.limbs[0]
             }
         } else {
             let (z01, z2) = hi.split_at_mut(LIMBS);

src/uint/ref_type.rs

@@ -27,7 +27,11 @@ use {crate::BoxedUint, alloc::borrow::ToOwned};
 /// thus provides an abstraction for writing shared implementations.
 #[repr(transparent)]
 #[derive(PartialEq, Eq)]
-pub struct UintRef(pub(crate) [Limb]);
+pub struct UintRef {
+    /// Inner limb array. Stored from least significant to most significant.
+    // TODO(tarcieri): maintain an invariant of at least one limb?
+    pub(crate) limbs: [Limb],
+}
 
 impl UintRef {
     /// Create a [`UintRef`] reference type from a [`Limb`] slice.
@@ -70,55 +74,55 @@ impl UintRef {
     #[inline]
     #[must_use]
     pub const fn as_limbs(&self) -> &[Limb] {
-        &self.0
+        &self.limbs
     }
 
     /// Mutably borrow the inner `&mut [Limb]` slice.
     #[inline]
     pub const fn as_mut_limbs(&mut self) -> &mut [Limb] {
-        &mut self.0
+        &mut self.limbs
     }
 
     /// Borrow the inner limbs as a slice of [`Word`]s.
     #[inline]
     #[must_use]
     pub const fn as_words(&self) -> &[Word] {
-        Limb::slice_as_words(&self.0)
+        Limb::slice_as_words(&self.limbs)
     }
 
     /// Borrow the inner limbs as a mutable slice of [`Word`]s.
     #[inline]
     pub const fn as_mut_words(&mut self) -> &mut [Word] {
-        Limb::slice_as_mut_words(&mut self.0)
+        Limb::slice_as_mut_words(&mut self.limbs)
     }
 
     /// Get an iterator over the inner limbs.
     #[inline]
     #[must_use]
     pub fn iter(&self) -> impl DoubleEndedIterator<Item = &Limb> {
-        self.0.iter()
+        self.limbs.iter()
     }
 
     /// Get a mutable iterator over the inner limbs.
     #[inline]
     #[allow(dead_code)] // TODO(tarcieri): use this
     pub fn iter_mut(&mut self) -> impl DoubleEndedIterator<Item = &mut Limb> {
-        self.0.iter_mut()
+        self.limbs.iter_mut()
     }
 
     /// Access the number of limbs.
     #[inline]
     #[must_use]
     pub const fn nlimbs(&self) -> usize {
-        self.0.len()
+        self.limbs.len()
     }
 
     /// Conditionally assign all of the limbs to zero.
     #[inline(always)]
     pub const fn conditional_set_zero(&mut self, choice: Choice) {
         let mut i = 0;
         while i < self.nlimbs() {
-            self.0[i] = Limb::select(self.0[i], Limb::ZERO, choice);
+            self.limbs[i] = Limb::select(self.limbs[i], Limb::ZERO, choice);
             i += 1;
         }
     }
@@ -128,7 +132,7 @@ impl UintRef {
     pub const fn conditional_set_max(&mut self, choice: Choice) {
         let mut i = 0;
         while i < self.nlimbs() {
-            self.0[i] = Limb::select(self.0[i], Limb::MAX, choice);
+            self.limbs[i] = Limb::select(self.limbs[i], Limb::MAX, choice);
             i += 1;
         }
     }
@@ -144,7 +148,7 @@ impl UintRef {
         };
         let mut i = 0;
         while i < len {
-            out.limbs[i] = self.0[i];
+            out.limbs[i] = self.limbs[i];
             i += 1;
         }
         out
@@ -164,11 +168,11 @@ impl UintRef {
     #[inline]
     #[must_use]
     pub const fn to_mut_nz_ref(&mut self) -> CtOption<&mut NonZero<Self>> {
-        assert!(!self.0.is_empty(), "cannot be used with empty slices");
+        assert!(!self.limbs.is_empty(), "cannot be used with empty slices");
         let is_nz = self.is_nonzero();
 
         // If `self` is zero, set the first limb to `1` to make it non-zero.
-        self.0[0] = Limb::select(Limb::ONE, self.0[0], is_nz);
+        self.limbs[0] = Limb::select(Limb::ONE, self.limbs[0], is_nz);
 
         CtOption::new(self.as_mut_nz_unchecked(), is_nz)
     }
@@ -234,11 +238,11 @@ impl UintRef {
     #[inline]
     #[must_use]
     pub const fn to_mut_odd_ref(&mut self) -> CtOption<&mut Odd<Self>> {
-        assert!(!self.0.is_empty(), "cannot be used with empty slices");
+        assert!(!self.limbs.is_empty(), "cannot be used with empty slices");
         let is_odd = self.is_odd();
 
         // If `self` is even, set the first limb to `1` to make it odd.
-        self.0[0] = Limb::select(Limb::ONE, self.0[0], is_odd);
+        self.limbs[0] = Limb::select(Limb::ONE, self.limbs[0], is_odd);
 
         CtOption::new(self.as_mut_odd_unchecked(), is_odd)
     }
@@ -296,18 +300,18 @@ impl UintRef {
         #[cfg(target_pointer_width = "32")]
         {
             debug_assert!(self.nlimbs() >= 1);
-            let mut ret = self.0[0].0 as u64;
+            let mut ret = self.limbs[0].0 as u64;
 
             if self.nlimbs() >= 2 {
-                ret |= (self.0[1].0 as u64) << 32;
+                ret |= (self.limbs[1].0 as u64) << 32;
             }
 
             ret
         }
 
         #[cfg(target_pointer_width = "64")]
         {
-            self.0[0].0
+            self.limbs[0].0
         }
     }
 }
@@ -331,14 +335,14 @@ impl Index<usize> for UintRef {
 
     #[inline]
     fn index(&self, index: usize) -> &Limb {
-        self.0.index(index)
+        self.limbs.index(index)
     }
 }
 
 impl IndexMut<usize> for UintRef {
     #[inline]
     fn index_mut(&mut self, index: usize) -> &mut Limb {
-        self.0.index_mut(index)
+        self.limbs.index_mut(index)
     }
 }
 

src/uint/ref_type/add.rs

@@ -7,8 +7,8 @@ impl UintRef {
     #[track_caller]
     pub const fn add_assign_limb(&mut self, mut rhs: Limb) -> Limb {
         let mut i = 0;
-        while i < self.0.len() {
-            (self.0[i], rhs) = self.0[i].overflowing_add(rhs);
+        while i < self.limbs.len() {
+            (self.limbs[i], rhs) = self.limbs[i].overflowing_add(rhs);
             i += 1;
         }
         rhs
@@ -18,7 +18,7 @@ impl UintRef {
     #[inline]
     #[track_caller]
     pub const fn carrying_add_assign(&mut self, rhs: &Self, carry: Limb) -> Limb {
-        self.carrying_add_assign_slice(&rhs.0, carry)
+        self.carrying_add_assign_slice(&rhs.limbs, carry)
     }
 
     /// Perform an in-place carrying add of another limb slice, returning the carried limb value.
@@ -29,12 +29,12 @@ impl UintRef {
     #[track_caller]
     pub const fn carrying_add_assign_slice(&mut self, rhs: &[Limb], mut carry: Limb) -> Limb {
         assert!(
-            self.0.len() == rhs.len(),
+            self.limbs.len() == rhs.len(),
             "length mismatch in carrying_add_assign_slice"
         );
         let mut i = 0;
-        while i < self.0.len() {
-            (self.0[i], carry) = self.0[i].carrying_add(rhs[i], carry);
+        while i < self.limbs.len() {
+            (self.limbs[i], carry) = self.limbs[i].carrying_add(rhs[i], carry);
             i += 1;
         }
         carry
@@ -65,13 +65,13 @@ impl UintRef {
         choice: Choice,
     ) -> Limb {
         assert!(
-            self.0.len() == rhs.len(),
+            self.limbs.len() == rhs.len(),
             "length mismatch in conditional_add_assign_slice"
         );
         let mut i = 0;
-        while i < self.0.len() {
-            (self.0[i], carry) =
-                self.0[i].carrying_add(Limb::select(Limb::ZERO, rhs[i], choice), carry);
+        while i < self.limbs.len() {
+            (self.limbs[i], carry) =
+                self.limbs[i].carrying_add(Limb::select(Limb::ZERO, rhs[i], choice), carry);
             i += 1;
         }
         carry