test UintRef as operator

andrewwhitehead · andrewwhitehead · commit 12765177fa89 · 2026-02-03T13:18:35.000-07:00
Signed-off-by: Andrew Whitehead &lt;cywolf@gmail.com&gt;
diff --git a/src/uint/boxed/add.rs b/src/uint/boxed/add.rs
@@ -222,7 +222,7 @@ impl AddAssign<u128> for BoxedUint {
 #[cfg(test)]
 #[allow(clippy::unwrap_used)]
 mod tests {
-    use super::{BoxedUint, CheckedAdd, Limb, Wrapping};
+    use super::{BoxedUint, CheckedAdd, Limb, UintRef, Wrapping};
     use crate::Resize;
 
     #[test]
@@ -292,4 +292,14 @@ mod tests {
         ret += Wrapping(Limb::ONE);
         assert!(ret.0.is_zero_vartime());
     }
+
+    #[test]
+    fn add_uintref() {
+        let a = BoxedUint::from(1234567890u64);
+        let b = UintRef::new(&[Limb(456), Limb(0)]);
+        assert_eq!(
+            a.carrying_add(b, Limb::ZERO).0,
+            BoxedUint::from(1234568346u64)
+        );
+    }
 }
diff --git a/src/uint/boxed/mul.rs b/src/uint/boxed/mul.rs
@@ -116,45 +116,45 @@ impl BoxedUint {
     }
 }
 
-impl<RHS: AsRef<UintRef>> CheckedMul<RHS> for BoxedUint {
-    fn checked_mul(&self, rhs: &RHS) -> CtOption<Self> {
+impl<Rhs: AsRef<UintRef>> CheckedMul<Rhs> for BoxedUint {
+    fn checked_mul(&self, rhs: &Rhs) -> CtOption<Self> {
         self.checked_mul(rhs)
     }
 }
 
-impl<RHS: AsRef<UintRef>> Mul<RHS> for BoxedUint {
+impl<Rhs: AsRef<UintRef>> Mul<Rhs> for BoxedUint {
     type Output = BoxedUint;
 
-    fn mul(self, rhs: RHS) -> Self {
+    fn mul(self, rhs: Rhs) -> Self {
         BoxedUint::mul(&self, &rhs)
     }
 }
 
-impl<RHS: AsRef<UintRef>> Mul<RHS> for &BoxedUint {
+impl<Rhs: AsRef<UintRef>> Mul<Rhs> for &BoxedUint {
     type Output = BoxedUint;
 
-    fn mul(self, rhs: RHS) -> Self::Output {
+    fn mul(self, rhs: Rhs) -> Self::Output {
         BoxedUint::mul(self, rhs)
     }
 }
 
-impl<RHS: AsRef<UintRef>> MulAssign<RHS> for BoxedUint {
-    fn mul_assign(&mut self, rhs: RHS) {
+impl<Rhs: AsRef<UintRef>> MulAssign<Rhs> for BoxedUint {
+    fn mul_assign(&mut self, rhs: Rhs) {
         *self = BoxedUint::mul(self, rhs);
     }
 }
 
-impl<RHS: AsRef<UintRef>> MulAssign<RHS> for Wrapping<BoxedUint> {
-    fn mul_assign(&mut self, other: RHS) {
+impl<Rhs: AsRef<UintRef>> MulAssign<Rhs> for Wrapping<BoxedUint> {
+    fn mul_assign(&mut self, other: Rhs) {
         self.0 = self.0.wrapping_mul(other);
     }
 }
 
-impl<RHS: AsRef<UintRef>> ConcatenatingMul<RHS> for BoxedUint {
+impl<Rhs: AsRef<UintRef>> ConcatenatingMul<Rhs> for BoxedUint {
     type Output = Self;
 
     #[inline]
-    fn concatenating_mul(&self, rhs: RHS) -> Self {
+    fn concatenating_mul(&self, rhs: Rhs) -> Self {
         self.mul(&rhs)
     }
 }
@@ -167,7 +167,7 @@ impl WrappingMul for BoxedUint {
 
 #[cfg(test)]
 mod tests {
-    use crate::{BoxedUint, CheckedMul, ConcatenatingMul, Resize, WrappingMul};
+    use crate::{BoxedUint, CheckedMul, ConcatenatingMul, Limb, Resize, UintRef, WrappingMul};
 
     #[test]
     fn mul_zero_and_one() {
@@ -261,4 +261,11 @@ mod tests {
         assert!(m.checked_square().is_none().to_bool());
         assert!(CheckedMul::checked_mul(&m, &m).is_none().to_bool());
     }
+
+    #[test]
+    fn mul_uintref() {
+        let a = BoxedUint::from(1234567890u64);
+        let b = UintRef::new(&[Limb(456), Limb(0)]);
+        assert_eq!(a * b, BoxedUint::from(562962957840u64));
+    }
 }
diff --git a/src/uint/boxed/pow.rs b/src/uint/boxed/pow.rs
@@ -209,8 +209,8 @@ impl BoxedUint {
     }
 }
 
-impl<RHS: AsRef<UintRef>> PowBoundedExp<RHS> for Checked<BoxedUint> {
-    fn pow_bounded_exp(&self, exponent: &RHS, exponent_bits: u32) -> Self {
+impl<Rhs: AsRef<UintRef>> PowBoundedExp<Rhs> for Checked<BoxedUint> {
+    fn pow_bounded_exp(&self, exponent: &Rhs, exponent_bits: u32) -> Self {
         let is_some = self.0.is_some();
         let pow = self
             .0
@@ -220,15 +220,15 @@ impl<RHS: AsRef<UintRef>> PowBoundedExp<RHS> for Checked<BoxedUint> {
     }
 }
 
-impl<RHS: AsRef<UintRef>> PowBoundedExp<RHS> for Wrapping<BoxedUint> {
-    fn pow_bounded_exp(&self, exponent: &RHS, exponent_bits: u32) -> Self {
+impl<Rhs: AsRef<UintRef>> PowBoundedExp<Rhs> for Wrapping<BoxedUint> {
+    fn pow_bounded_exp(&self, exponent: &Rhs, exponent_bits: u32) -> Self {
         Wrapping(self.0.wrapping_pow_bounded_exp(exponent, exponent_bits))
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::{BoxedUint, Checked, CtOption, Pow, U128, Wrapping};
+    use crate::{BoxedUint, Checked, CtOption, Limb, Pow, Resize, U128, UintRef, Wrapping};
 
     #[test]
     fn checked_pow_expected() {
@@ -329,4 +329,14 @@ mod tests {
             BoxedUint::from_be_hex("002b3854b3dc5d6e0000000000000001", 128).unwrap()
         );
     }
+
+    #[test]
+    fn pow_uintref() {
+        let a = BoxedUint::from(1234567890u64).resize_unchecked(128);
+        let b = UintRef::new(&[Limb(4), Limb(0)]);
+        assert_eq!(
+            a.wrapping_pow(b),
+            BoxedUint::from(2323057227982592441500937982514410000u128)
+        );
+    }
 }
diff --git a/src/uint/boxed/sub.rs b/src/uint/boxed/sub.rs
@@ -95,25 +95,25 @@ impl BoxedUint {
     }
 }
 
-impl<RHS: AsRef<UintRef>> CheckedSub<RHS> for BoxedUint {
-    fn checked_sub(&self, rhs: &RHS) -> CtOption<Self> {
+impl<Rhs: AsRef<UintRef>> CheckedSub<Rhs> for BoxedUint {
+    fn checked_sub(&self, rhs: &Rhs) -> CtOption<Self> {
         let (result, underflow) = self.underflowing_sub(rhs);
         CtOption::new(result, underflow.not())
     }
 }
 
-impl<RHS: AsRef<UintRef>> Sub<RHS> for BoxedUint {
+impl<Rhs: AsRef<UintRef>> Sub<Rhs> for BoxedUint {
     type Output = Self;
 
-    fn sub(self, rhs: RHS) -> Self {
+    fn sub(self, rhs: Rhs) -> Self {
         Sub::sub(&self, rhs)
     }
 }
 
-impl<RHS: AsRef<UintRef>> Sub<RHS> for &BoxedUint {
+impl<Rhs: AsRef<UintRef>> Sub<Rhs> for &BoxedUint {
     type Output = BoxedUint;
 
-    fn sub(self, rhs: RHS) -> BoxedUint {
+    fn sub(self, rhs: Rhs) -> BoxedUint {
         let (res, underflow) = self.underflowing_sub(rhs);
         assert!(
             underflow.not().to_bool(),
@@ -123,8 +123,8 @@ impl<RHS: AsRef<UintRef>> Sub<RHS> for &BoxedUint {
     }
 }
 
-impl<RHS: AsRef<UintRef>> SubAssign<RHS> for BoxedUint {
-    fn sub_assign(&mut self, rhs: RHS) {
+impl<Rhs: AsRef<UintRef>> SubAssign<Rhs> for BoxedUint {
+    fn sub_assign(&mut self, rhs: Rhs) {
         let underflow = self.underflowing_sub_assign(rhs);
         assert!(
             underflow.not().to_bool(),
@@ -133,8 +133,8 @@ impl<RHS: AsRef<UintRef>> SubAssign<RHS> for BoxedUint {
     }
 }
 
-impl<RHS: AsRef<UintRef>> SubAssign<RHS> for Wrapping<BoxedUint> {
-    fn sub_assign(&mut self, other: RHS) {
+impl<Rhs: AsRef<UintRef>> SubAssign<Rhs> for Wrapping<BoxedUint> {
+    fn sub_assign(&mut self, other: Rhs) {
         self.0.wrapping_sub_assign(other);
     }
 }
@@ -204,7 +204,7 @@ impl SubAssign<u128> for BoxedUint {
 #[cfg(test)]
 #[allow(clippy::unwrap_used)]
 mod tests {
-    use super::{BoxedUint, CheckedSub, Limb, Wrapping};
+    use super::{BoxedUint, CheckedSub, Limb, UintRef, Wrapping};
     use crate::Resize;
 
     #[test]
@@ -259,4 +259,14 @@ mod tests {
         ret -= Wrapping(Limb::ONE);
         assert_eq!(ret.0, BoxedUint::max(2 * Limb::BITS));
     }
+
+    #[test]
+    fn sub_uintref() {
+        let a = BoxedUint::from(1234567890u64);
+        let b = UintRef::new(&[Limb(456), Limb(0)]);
+        assert_eq!(
+            a.borrowing_sub(b, Limb::ZERO).0,
+            BoxedUint::from(1234567434u64)
+        );
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -116,45 +116,45 @@ impl BoxedUint {`
`116`	`116`	`}`
`117`	`117`	`}`
`118`	`118`
`119`		`-impl<RHS: AsRef<UintRef>> CheckedMul<RHS> for BoxedUint {`
`120`		`- fn checked_mul(&self, rhs: &RHS) -> CtOption<Self> {`
	`119`	`+impl<Rhs: AsRef<UintRef>> CheckedMul<Rhs> for BoxedUint {`
	`120`	`+ fn checked_mul(&self, rhs: &Rhs) -> CtOption<Self> {`
`121`	`121`	`self.checked_mul(rhs)`
`122`	`122`	`}`
`123`	`123`	`}`
`124`	`124`
`125`		`-impl<RHS: AsRef<UintRef>> Mul<RHS> for BoxedUint {`
	`125`	`+impl<Rhs: AsRef<UintRef>> Mul<Rhs> for BoxedUint {`
`126`	`126`	`type Output = BoxedUint;`
`127`	`127`
`128`		`- fn mul(self, rhs: RHS) -> Self {`
	`128`	`+ fn mul(self, rhs: Rhs) -> Self {`
`129`	`129`	`BoxedUint::mul(&self, &rhs)`
`130`	`130`	`}`
`131`	`131`	`}`
`132`	`132`
`133`		`-impl<RHS: AsRef<UintRef>> Mul<RHS> for &BoxedUint {`
	`133`	`+impl<Rhs: AsRef<UintRef>> Mul<Rhs> for &BoxedUint {`
`134`	`134`	`type Output = BoxedUint;`
`135`	`135`
`136`		`- fn mul(self, rhs: RHS) -> Self::Output {`
	`136`	`+ fn mul(self, rhs: Rhs) -> Self::Output {`
`137`	`137`	`BoxedUint::mul(self, rhs)`
`138`	`138`	`}`
`139`	`139`	`}`
`140`	`140`
`141`		`-impl<RHS: AsRef<UintRef>> MulAssign<RHS> for BoxedUint {`
`142`		`- fn mul_assign(&mut self, rhs: RHS) {`
	`141`	`+impl<Rhs: AsRef<UintRef>> MulAssign<Rhs> for BoxedUint {`
	`142`	`+ fn mul_assign(&mut self, rhs: Rhs) {`
`143`	`143`	`*self = BoxedUint::mul(self, rhs);`
`144`	`144`	`}`
`145`	`145`	`}`
`146`	`146`
`147`		`-impl<RHS: AsRef<UintRef>> MulAssign<RHS> for Wrapping<BoxedUint> {`
`148`		`- fn mul_assign(&mut self, other: RHS) {`
	`147`	`+impl<Rhs: AsRef<UintRef>> MulAssign<Rhs> for Wrapping<BoxedUint> {`
	`148`	`+ fn mul_assign(&mut self, other: Rhs) {`
`149`	`149`	`self.0 = self.0.wrapping_mul(other);`
`150`	`150`	`}`
`151`	`151`	`}`
`152`	`152`
`153`		`-impl<RHS: AsRef<UintRef>> ConcatenatingMul<RHS> for BoxedUint {`
	`153`	`+impl<Rhs: AsRef<UintRef>> ConcatenatingMul<Rhs> for BoxedUint {`
`154`	`154`	`type Output = Self;`
`155`	`155`
`156`	`156`	`#[inline]`
`157`		`- fn concatenating_mul(&self, rhs: RHS) -> Self {`
	`157`	`+ fn concatenating_mul(&self, rhs: Rhs) -> Self {`
`158`	`158`	`self.mul(&rhs)`
`159`	`159`	`}`
`160`	`160`	`}`
`@@ -167,7 +167,7 @@ impl WrappingMul for BoxedUint {`
`167`	`167`
`168`	`168`	`#[cfg(test)]`
`169`	`169`	`mod tests {`
`170`		`- use crate::{BoxedUint, CheckedMul, ConcatenatingMul, Resize, WrappingMul};`
	`170`	`+ use crate::{BoxedUint, CheckedMul, ConcatenatingMul, Limb, Resize, UintRef, WrappingMul};`
`171`	`171`
`172`	`172`	`#[test]`
`173`	`173`	`fn mul_zero_and_one() {`
`@@ -261,4 +261,11 @@ mod tests {`
`261`	`261`	`assert!(m.checked_square().is_none().to_bool());`
`262`	`262`	`assert!(CheckedMul::checked_mul(&m, &m).is_none().to_bool());`
`263`	`263`	`}`
	`264`	`+`
	`265`	`+ #[test]`
	`266`	`+ fn mul_uintref() {`
	`267`	`+ let a = BoxedUint::from(1234567890u64);`
	`268`	`+ let b = UintRef::new(&[Limb(456), Limb(0)]);`
	`269`	`+ assert_eq!(a * b, BoxedUint::from(562962957840u64));`
	`270`	`+ }`
`264`	`271`	`}`
Original file line number	Diff line number	Diff line change
`@@ -209,8 +209,8 @@ impl BoxedUint {`
`209`	`209`	`}`
`210`	`210`	`}`
`211`	`211`
`212`		`-impl<RHS: AsRef<UintRef>> PowBoundedExp<RHS> for Checked<BoxedUint> {`
`213`		`- fn pow_bounded_exp(&self, exponent: &RHS, exponent_bits: u32) -> Self {`
	`212`	`+impl<Rhs: AsRef<UintRef>> PowBoundedExp<Rhs> for Checked<BoxedUint> {`
	`213`	`+ fn pow_bounded_exp(&self, exponent: &Rhs, exponent_bits: u32) -> Self {`
`214`	`214`	`let is_some = self.0.is_some();`
`215`	`215`	`let pow = self`
`216`	`216`	`.0`
`@@ -220,15 +220,15 @@ impl<RHS: AsRef<UintRef>> PowBoundedExp<RHS> for Checked<BoxedUint> {`
`220`	`220`	`}`
`221`	`221`	`}`
`222`	`222`
`223`		`-impl<RHS: AsRef<UintRef>> PowBoundedExp<RHS> for Wrapping<BoxedUint> {`
`224`		`- fn pow_bounded_exp(&self, exponent: &RHS, exponent_bits: u32) -> Self {`
	`223`	`+impl<Rhs: AsRef<UintRef>> PowBoundedExp<Rhs> for Wrapping<BoxedUint> {`
	`224`	`+ fn pow_bounded_exp(&self, exponent: &Rhs, exponent_bits: u32) -> Self {`
`225`	`225`	`Wrapping(self.0.wrapping_pow_bounded_exp(exponent, exponent_bits))`
`226`	`226`	`}`
`227`	`227`	`}`
`228`	`228`
`229`	`229`	`#[cfg(test)]`
`230`	`230`	`mod tests {`
`231`		`- use crate::{BoxedUint, Checked, CtOption, Pow, U128, Wrapping};`
	`231`	`+ use crate::{BoxedUint, Checked, CtOption, Limb, Pow, Resize, U128, UintRef, Wrapping};`
`232`	`232`
`233`	`233`	`#[test]`
`234`	`234`	`fn checked_pow_expected() {`
`@@ -329,4 +329,14 @@ mod tests {`
`329`	`329`	`BoxedUint::from_be_hex("002b3854b3dc5d6e0000000000000001", 128).unwrap()`
`330`	`330`	`);`
`331`	`331`	`}`
	`332`	`+`
	`333`	`+ #[test]`
	`334`	`+ fn pow_uintref() {`
	`335`	`+ let a = BoxedUint::from(1234567890u64).resize_unchecked(128);`
	`336`	`+ let b = UintRef::new(&[Limb(4), Limb(0)]);`
	`337`	`+ assert_eq!(`
	`338`	`+ a.wrapping_pow(b),`
	`339`	`+ BoxedUint::from(2323057227982592441500937982514410000u128)`
	`340`	`+ );`
	`341`	`+ }`
`332`	`342`	`}`
Original file line number	Diff line number	Diff line change
`@@ -95,25 +95,25 @@ impl BoxedUint {`
`95`	`95`	`}`
`96`	`96`	`}`
`97`	`97`
`98`		`-impl<RHS: AsRef<UintRef>> CheckedSub<RHS> for BoxedUint {`
`99`		`- fn checked_sub(&self, rhs: &RHS) -> CtOption<Self> {`
	`98`	`+impl<Rhs: AsRef<UintRef>> CheckedSub<Rhs> for BoxedUint {`
	`99`	`+ fn checked_sub(&self, rhs: &Rhs) -> CtOption<Self> {`
`100`	`100`	`let (result, underflow) = self.underflowing_sub(rhs);`
`101`	`101`	`CtOption::new(result, underflow.not())`
`102`	`102`	`}`
`103`	`103`	`}`
`104`	`104`
`105`		`-impl<RHS: AsRef<UintRef>> Sub<RHS> for BoxedUint {`
	`105`	`+impl<Rhs: AsRef<UintRef>> Sub<Rhs> for BoxedUint {`
`106`	`106`	`type Output = Self;`
`107`	`107`
`108`		`- fn sub(self, rhs: RHS) -> Self {`
	`108`	`+ fn sub(self, rhs: Rhs) -> Self {`
`109`	`109`	`Sub::sub(&self, rhs)`
`110`	`110`	`}`
`111`	`111`	`}`
`112`	`112`
`113`		`-impl<RHS: AsRef<UintRef>> Sub<RHS> for &BoxedUint {`
	`113`	`+impl<Rhs: AsRef<UintRef>> Sub<Rhs> for &BoxedUint {`
`114`	`114`	`type Output = BoxedUint;`
`115`	`115`
`116`		`- fn sub(self, rhs: RHS) -> BoxedUint {`
	`116`	`+ fn sub(self, rhs: Rhs) -> BoxedUint {`
`117`	`117`	`let (res, underflow) = self.underflowing_sub(rhs);`
`118`	`118`	`assert!(`
`119`	`119`	`underflow.not().to_bool(),`
`@@ -123,8 +123,8 @@ impl<RHS: AsRef<UintRef>> Sub<RHS> for &BoxedUint {`
`123`	`123`	`}`
`124`	`124`	`}`
`125`	`125`
`126`		`-impl<RHS: AsRef<UintRef>> SubAssign<RHS> for BoxedUint {`
`127`		`- fn sub_assign(&mut self, rhs: RHS) {`
	`126`	`+impl<Rhs: AsRef<UintRef>> SubAssign<Rhs> for BoxedUint {`
	`127`	`+ fn sub_assign(&mut self, rhs: Rhs) {`
`128`	`128`	`let underflow = self.underflowing_sub_assign(rhs);`
`129`	`129`	`assert!(`
`130`	`130`	`underflow.not().to_bool(),`
`@@ -133,8 +133,8 @@ impl<RHS: AsRef<UintRef>> SubAssign<RHS> for BoxedUint {`
`133`	`133`	`}`
`134`	`134`	`}`
`135`	`135`
`136`		`-impl<RHS: AsRef<UintRef>> SubAssign<RHS> for Wrapping<BoxedUint> {`
`137`		`- fn sub_assign(&mut self, other: RHS) {`
	`136`	`+impl<Rhs: AsRef<UintRef>> SubAssign<Rhs> for Wrapping<BoxedUint> {`
	`137`	`+ fn sub_assign(&mut self, other: Rhs) {`
`138`	`138`	`self.0.wrapping_sub_assign(other);`
`139`	`139`	`}`
`140`	`140`	`}`
`@@ -204,7 +204,7 @@ impl SubAssign<u128> for BoxedUint {`
`204`	`204`	`#[cfg(test)]`
`205`	`205`	`#[allow(clippy::unwrap_used)]`
`206`	`206`	`mod tests {`
`207`		`- use super::{BoxedUint, CheckedSub, Limb, Wrapping};`
	`207`	`+ use super::{BoxedUint, CheckedSub, Limb, UintRef, Wrapping};`
`208`	`208`	`use crate::Resize;`
`209`	`209`
`210`	`210`	`#[test]`
`@@ -259,4 +259,14 @@ mod tests {`
`259`	`259`	`ret -= Wrapping(Limb::ONE);`
`260`	`260`	`assert_eq!(ret.0, BoxedUint::max(2 * Limb::BITS));`
`261`	`261`	`}`
	`262`	`+`
	`263`	`+ #[test]`
	`264`	`+ fn sub_uintref() {`
	`265`	`+ let a = BoxedUint::from(1234567890u64);`
	`266`	`+ let b = UintRef::new(&[Limb(456), Limb(0)]);`
	`267`	`+ assert_eq!(`
	`268`	`+ a.borrowing_sub(b, Limb::ZERO).0,`
	`269`	`+ BoxedUint::from(1234567434u64)`
	`270`	`+ );`
	`271`	`+ }`
`262`	`272`	`}`