Remove ConstChoice::is_true_vartime

tarcieri · tarcieri · commit 152179eaa41e · 2025-12-19T21:41:22.000-07:00
The `to_bool_vartime` and `is_true_vartime` methods duplicate each
other, performing the same function.

I picked `to_bool_vartime` to consolidate on.
diff --git a/src/const_choice.rs b/src/const_choice.rs
@@ -241,21 +241,16 @@ impl ConstChoice {
         x & self.as_u32_mask()
     }
 
+    /// WARNING: this method should only be used in contexts that aren't constant-time critical!
     #[inline]
-    pub(crate) const fn is_true_vartime(&self) -> bool {
-        self.0 == ConstChoice::TRUE.0
+    pub(crate) const fn to_bool_vartime(&self) -> bool {
+        self.0 != 0
     }
 
     #[inline]
     pub(crate) const fn to_u8(self) -> u8 {
         (self.0 as u8) & 1
     }
-
-    /// WARNING: this method should only be used in contexts that aren't constant-time critical!
-    #[inline]
-    pub(crate) const fn to_bool_vartime(self) -> bool {
-        self.to_u8() != 0
-    }
 }
 
 /// `const` equivalent of `u32::max(a, b)`.
@@ -284,7 +279,7 @@ impl From<Choice> for ConstChoice {
 
 impl From<ConstChoice> for bool {
     fn from(choice: ConstChoice) -> Self {
-        choice.is_true_vartime()
+        choice.to_bool_vartime()
     }
 }
 
@@ -351,7 +346,7 @@ impl<T> ConstCtOption<T> {
     #[track_caller]
     pub fn unwrap(self) -> T {
         assert!(
-            self.is_some.is_true_vartime(),
+            self.is_some.to_bool_vartime(),
             "called `ConstCtOption::unwrap()` on a `None` value"
         );
         self.value
@@ -403,7 +398,7 @@ impl<const LIMBS: usize> ConstCtOption<Uint<LIMBS>> {
     #[inline]
     #[track_caller]
     pub const fn expect(self, msg: &str) -> Uint<LIMBS> {
-        assert!(self.is_some.is_true_vartime(), "{}", msg);
+        assert!(self.is_some.to_bool_vartime(), "{}", msg);
         self.value
     }
 
@@ -424,7 +419,7 @@ impl<const LIMBS: usize> ConstCtOption<(Uint<LIMBS>, Uint<LIMBS>)> {
     #[inline]
     #[track_caller]
     pub const fn expect(self, msg: &str) -> (Uint<LIMBS>, Uint<LIMBS>) {
-        assert!(self.is_some.is_true_vartime(), "{}", msg);
+        assert!(self.is_some.to_bool_vartime(), "{}", msg);
         self.value
     }
 }
@@ -439,7 +434,7 @@ impl<const LIMBS: usize> ConstCtOption<NonZero<Uint<LIMBS>>> {
     #[inline]
     #[track_caller]
     pub const fn expect(self, msg: &str) -> NonZero<Uint<LIMBS>> {
-        assert!(self.is_some.is_true_vartime(), "{}", msg);
+        assert!(self.is_some.to_bool_vartime(), "{}", msg);
         self.value
     }
 }
@@ -454,7 +449,7 @@ impl<const LIMBS: usize> ConstCtOption<Odd<Uint<LIMBS>>> {
     #[inline]
     #[track_caller]
     pub const fn expect(self, msg: &str) -> Odd<Uint<LIMBS>> {
-        assert!(self.is_some.is_true_vartime(), "{}", msg);
+        assert!(self.is_some.to_bool_vartime(), "{}", msg);
         self.value
     }
 }
@@ -475,7 +470,7 @@ impl<const LIMBS: usize> ConstCtOption<Int<LIMBS>> {
     #[inline]
     #[track_caller]
     pub const fn expect(self, msg: &str) -> Int<LIMBS> {
-        assert!(self.is_some.is_true_vartime(), "{}", msg);
+        assert!(self.is_some.to_bool_vartime(), "{}", msg);
         self.value
     }
 }
@@ -490,7 +485,7 @@ impl<const LIMBS: usize> ConstCtOption<NonZeroInt<LIMBS>> {
     #[inline]
     #[track_caller]
     pub const fn expect(self, msg: &str) -> NonZeroInt<LIMBS> {
-        assert!(self.is_some.is_true_vartime(), "{}", msg);
+        assert!(self.is_some.to_bool_vartime(), "{}", msg);
         self.value
     }
 }
@@ -505,7 +500,7 @@ impl<const LIMBS: usize> ConstCtOption<OddInt<LIMBS>> {
     #[inline]
     #[track_caller]
     pub const fn expect(self, msg: &str) -> OddInt<LIMBS> {
-        assert!(self.is_some.is_true_vartime(), "{}", msg);
+        assert!(self.is_some.to_bool_vartime(), "{}", msg);
         self.value
     }
 }
@@ -520,7 +515,7 @@ impl ConstCtOption<NonZero<Limb>> {
     #[inline]
     #[track_caller]
     pub const fn expect(self, msg: &str) -> NonZero<Limb> {
-        assert!(self.is_some.is_true_vartime(), "{}", msg);
+        assert!(self.is_some.to_bool_vartime(), "{}", msg);
         self.value
     }
 }
@@ -535,7 +530,7 @@ impl<const LIMBS: usize> ConstCtOption<SafeGcdInverter<LIMBS>> {
     #[inline]
     #[track_caller]
     pub const fn expect(self, msg: &str) -> SafeGcdInverter<LIMBS> {
-        assert!(self.is_some.is_true_vartime(), "{}", msg);
+        assert!(self.is_some.to_bool_vartime(), "{}", msg);
         self.value
     }
 }
@@ -555,7 +550,7 @@ impl<MOD: ConstMontyParams<LIMBS>, const LIMBS: usize> ConstCtOption<ConstMontyF
     #[inline]
     #[track_caller]
     pub const fn expect(self, msg: &str) -> ConstMontyForm<MOD, LIMBS> {
-        assert!(self.is_some.is_true_vartime(), "{}", msg);
+        assert!(self.is_some.to_bool_vartime(), "{}", msg);
         self.value
     }
 }
diff --git a/src/int/mod_symbol.rs b/src/int/mod_symbol.rs
@@ -25,7 +25,7 @@ impl<const LIMBS: usize> Int<LIMBS> {
         let (abs, sign) = self.abs_sign();
         let jacobi = abs.jacobi_symbol_vartime(rhs);
         JacobiSymbol::from_i8(
-            if sign.is_true_vartime() && rhs.as_ref().limbs[0].0 & 3 == 3 {
+            if sign.to_bool_vartime() && rhs.as_ref().limbs[0].0 & 3 == 3 {
                 -(jacobi as i8)
             } else {
                 jacobi as i8
diff --git a/src/int/shl.rs b/src/int/shl.rs
@@ -153,8 +153,8 @@ mod tests {
 
     #[test]
     fn shl256_const() {
-        assert!(N.overflowing_shl(256).is_none().is_true_vartime());
-        assert!(N.overflowing_shl_vartime(256).is_none().is_true_vartime());
+        assert!(N.overflowing_shl(256).is_none().to_bool_vartime());
+        assert!(N.overflowing_shl_vartime(256).is_none().to_bool_vartime());
     }
 
     #[test]
diff --git a/src/int/shr.rs b/src/int/shr.rs
@@ -227,8 +227,8 @@ mod tests {
 
     #[test]
     fn shr256_const() {
-        assert!(N.overflowing_shr(256).is_none().is_true_vartime());
-        assert!(N.overflowing_shr_vartime(256).is_none().is_true_vartime());
+        assert!(N.overflowing_shr(256).is_none().to_bool_vartime());
+        assert!(N.overflowing_shr_vartime(256).is_none().to_bool_vartime());
     }
 
     #[test]
diff --git a/src/modular/reduction.rs b/src/modular/reduction.rs
@@ -104,7 +104,7 @@ pub const fn montgomery_retrieve<const LIMBS: usize>(
     modulus: &Odd<Uint<LIMBS>>,
     mod_neg_inv: Limb,
 ) -> Uint<LIMBS> {
-    debug_assert!(Uint::lt(montgomery_form, modulus.as_ref()).is_true_vartime());
+    debug_assert!(Uint::lt(montgomery_form, modulus.as_ref()).to_bool_vartime());
     let mut res = Uint::ZERO;
     montgomery_retrieve_inner(
         montgomery_form.as_limbs(),
diff --git a/src/modular/safegcd.rs b/src/modular/safegcd.rs
@@ -508,7 +508,7 @@ impl<const LIMBS: usize> fmt::Debug for SignedInt<LIMBS> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_fmt(format_args!(
             "{}0x{}",
-            if self.sign.is_true_vartime() {
+            if self.sign.to_bool_vartime() {
                 "-"
             } else {
                 "+"
@@ -534,7 +534,7 @@ impl<const LIMBS: usize> ConstCtOption<Odd<SignedInt<LIMBS>>> {
     #[inline]
     #[track_caller]
     pub const fn expect(self, msg: &str) -> Odd<SignedInt<LIMBS>> {
-        assert!(self.is_some().is_true_vartime(), "{}", msg);
+        assert!(self.is_some().to_bool_vartime(), "{}", msg);
         *self.components_ref().0
     }
 }
diff --git a/src/modular/safegcd/boxed.rs b/src/modular/safegcd/boxed.rs
@@ -417,7 +417,7 @@ impl fmt::Debug for SignedBoxedInt {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_fmt(format_args!(
             "{}0x{}",
-            if self.sign.is_true_vartime() {
+            if self.sign.to_bool_vartime() {
                 "-"
             } else {
                 "+"
@@ -443,7 +443,7 @@ impl ConstCtOption<Odd<SignedBoxedInt>> {
     #[inline]
     #[track_caller]
     pub fn expect(self, msg: &str) -> Odd<SignedBoxedInt> {
-        assert!(self.is_some().is_true_vartime(), "{}", msg);
+        assert!(self.is_some().to_bool_vartime(), "{}", msg);
         self.components_ref().0.clone()
     }
 }
diff --git a/src/non_zero.rs b/src/non_zero.rs
@@ -152,7 +152,7 @@ impl NonZero<Limb> {
     /// `NonZero::new(…).unwrap()`
     // TODO: Remove when `Self::new` and `CtOption::unwrap` support `const fn`
     pub const fn new_unwrap(n: Limb) -> Self {
-        if n.is_nonzero().is_true_vartime() {
+        if n.is_nonzero().to_bool_vartime() {
             Self(n)
         } else {
             panic!("Invalid value: zero")
@@ -195,7 +195,7 @@ impl<const LIMBS: usize> NonZeroUint<LIMBS> {
     /// - if the value is zero.
     // TODO: Remove when `Self::new` and `CtOption::unwrap` support `const fn`
     pub const fn new_unwrap(n: Uint<LIMBS>) -> Self {
-        if n.is_nonzero().is_true_vartime() {
+        if n.is_nonzero().to_bool_vartime() {
             Self(n)
         } else {
             panic!("Invalid value: zero")
diff --git a/src/odd.rs b/src/odd.rs
@@ -91,7 +91,7 @@ impl<const LIMBS: usize> Odd<Uint<LIMBS>> {
     /// Panics if the hex is malformed or not zero-padded accordingly for the size, or if the value is even.
     pub const fn from_be_hex(hex: &str) -> Self {
         let uint = Uint::<LIMBS>::from_be_hex(hex);
-        assert!(uint.is_odd().is_true_vartime(), "number must be odd");
+        assert!(uint.is_odd().to_bool_vartime(), "number must be odd");
         Odd(uint)
     }
 
@@ -100,7 +100,7 @@ impl<const LIMBS: usize> Odd<Uint<LIMBS>> {
     /// Panics if the hex is malformed or not zero-padded accordingly for the size, or if the value is even.
     pub const fn from_le_hex(hex: &str) -> Self {
         let uint = Uint::<LIMBS>::from_be_hex(hex);
-        assert!(uint.is_odd().is_true_vartime(), "number must be odd");
+        assert!(uint.is_odd().to_bool_vartime(), "number must be odd");
         Odd(uint)
     }
 
diff --git a/src/uint/bits.rs b/src/uint/bits.rs
@@ -162,13 +162,13 @@ mod tests {
     #[test]
     fn bit() {
         let u = uint_with_bits_at(&[16, 48, 112, 127, 255]);
-        assert!(!u.bit(0).is_true_vartime());
-        assert!(!u.bit(1).is_true_vartime());
-        assert!(u.bit(16).is_true_vartime());
-        assert!(u.bit(127).is_true_vartime());
-        assert!(u.bit(255).is_true_vartime());
-        assert!(!u.bit(256).is_true_vartime());
-        assert!(!u.bit(260).is_true_vartime());
+        assert!(!u.bit(0).to_bool_vartime());
+        assert!(!u.bit(1).to_bool_vartime());
+        assert!(u.bit(16).to_bool_vartime());
+        assert!(u.bit(127).to_bool_vartime());
+        assert!(u.bit(255).to_bool_vartime());
+        assert!(!u.bit(256).to_bool_vartime());
+        assert!(!u.bit(260).to_bool_vartime());
     }
 
     #[test]
diff --git a/src/uint/invert_mod.rs b/src/uint/invert_mod.rs
@@ -291,10 +291,10 @@ mod tests {
         // An inverse of an even number does not exist.
 
         let a = U256::from(10u64).invert_mod2k(4);
-        assert!(a.is_none().is_true_vartime());
+        assert!(a.is_none().to_bool_vartime());
 
         let a = U256::from(10u64).invert_mod2k_vartime(4);
-        assert!(a.is_none().is_true_vartime());
+        assert!(a.is_none().to_bool_vartime());
 
         // A degenerate case. An inverse mod 2^0 == 1 always exists even for even numbers.
 
@@ -346,7 +346,7 @@ mod tests {
 
         // `m` is a multiple of `p1`, so no inverse exists
         let res = p1.invert_odd_mod(&m);
-        assert!(res.is_none().is_true_vartime());
+        assert!(res.is_none().to_bool_vartime());
     }
 
     #[test]
@@ -391,7 +391,7 @@ mod tests {
         let m = U64::from(49u64).to_odd().unwrap();
 
         let res = a.invert_odd_mod(&m);
-        assert!(res.is_none().is_true_vartime());
+        assert!(res.is_none().to_bool_vartime());
     }
 
     #[test]
diff --git a/src/uint/ref_type/div.rs b/src/uint/ref_type/div.rs
@@ -277,7 +277,7 @@ impl UintRef {
 
             // This loop is a no-op once xi is smaller than the number of words in the divisor
             let done = ConstChoice::from_u32_lt(xi as u32, ywords - 1);
-            if vartime.and(done).is_true_vartime() {
+            if vartime.and(done).to_bool_vartime() {
                 break;
             }
             quo = done.select_word(quo, 0);
@@ -450,7 +450,7 @@ impl UintRef {
 
             // This loop is a no-op once xi is smaller than the number of words in the divisor
             let done = ConstChoice::from_u32_lt(xi as u32, ywords - 1);
-            if vartime.and(done).is_true_vartime() {
+            if vartime.and(done).to_bool_vartime() {
                 break;
             }
             quo = done.select_word(quo, 0);
diff --git a/src/uint/shl.rs b/src/uint/shl.rs
@@ -321,8 +321,8 @@ mod tests {
 
     #[test]
     fn shl256_const() {
-        assert!(N.overflowing_shl(256).is_none().is_true_vartime());
-        assert!(N.overflowing_shl_vartime(256).is_none().is_true_vartime());
+        assert!(N.overflowing_shl(256).is_none().to_bool_vartime());
+        assert!(N.overflowing_shl_vartime(256).is_none().to_bool_vartime());
     }
 
     #[test]
@@ -361,7 +361,7 @@ mod tests {
         assert!(
             Uint::overflowing_shl_vartime_wide((U128::MAX, U128::MAX), 256)
                 .is_none()
-                .is_true_vartime(),
+                .to_bool_vartime(),
         );
     }
 
diff --git a/src/uint/shr.rs b/src/uint/shr.rs
@@ -306,8 +306,8 @@ mod tests {
 
     #[test]
     fn shr256_const() {
-        assert!(N.overflowing_shr(256).is_none().is_true_vartime());
-        assert!(N.overflowing_shr_vartime(256).is_none().is_true_vartime());
+        assert!(N.overflowing_shr(256).is_none().to_bool_vartime());
+        assert!(N.overflowing_shr_vartime(256).is_none().to_bool_vartime());
     }
 
     #[test]
@@ -337,7 +337,7 @@ mod tests {
         assert!(
             Uint::overflowing_shr_vartime_wide((U128::MAX, U128::MAX), 256)
                 .is_none()
-                .is_true_vartime()
+                .to_bool_vartime()
         );
     }
 

Original file line number	Diff line number	Diff line change
`@@ -241,21 +241,16 @@ impl ConstChoice {`
`241`	`241`	`x & self.as_u32_mask()`
`242`	`242`	`}`
`243`	`243`
	`244`	`+ /// WARNING: this method should only be used in contexts that aren't constant-time critical!`
`244`	`245`	`#[inline]`
`245`		`- pub(crate) const fn is_true_vartime(&self) -> bool {`
`246`		`- self.0 == ConstChoice::TRUE.0`
	`246`	`+ pub(crate) const fn to_bool_vartime(&self) -> bool {`
	`247`	`+ self.0 != 0`
`247`	`248`	`}`
`248`	`249`
`249`	`250`	`#[inline]`
`250`	`251`	`pub(crate) const fn to_u8(self) -> u8 {`
`251`	`252`	`(self.0 as u8) & 1`
`252`	`253`	`}`
`253`		`-`
`254`		`- /// WARNING: this method should only be used in contexts that aren't constant-time critical!`
`255`		`- #[inline]`
`256`		`- pub(crate) const fn to_bool_vartime(self) -> bool {`
`257`		`- self.to_u8() != 0`
`258`		`- }`
`259`	`254`	`}`
`260`	`255`
`261`	`256`	/// `const` equivalent of `u32::max(a, b)`.
`@@ -284,7 +279,7 @@ impl From<Choice> for ConstChoice {`
`284`	`279`
`285`	`280`	`impl From<ConstChoice> for bool {`
`286`	`281`	`fn from(choice: ConstChoice) -> Self {`
`287`		`- choice.is_true_vartime()`
	`282`	`+ choice.to_bool_vartime()`
`288`	`283`	`}`
`289`	`284`	`}`
`290`	`285`
`@@ -351,7 +346,7 @@ impl<T> ConstCtOption<T> {`
`351`	`346`	`#[track_caller]`
`352`	`347`	`pub fn unwrap(self) -> T {`
`353`	`348`	`assert!(`
`354`		`- self.is_some.is_true_vartime(),`
	`349`	`+ self.is_some.to_bool_vartime(),`
`355`	`350`	"called `ConstCtOption::unwrap()` on a `None` value"
`356`	`351`	`);`
`357`	`352`	`self.value`
`@@ -403,7 +398,7 @@ impl<const LIMBS: usize> ConstCtOption<Uint<LIMBS>> {`
`403`	`398`	`#[inline]`
`404`	`399`	`#[track_caller]`
`405`	`400`	`pub const fn expect(self, msg: &str) -> Uint<LIMBS> {`
`406`		`- assert!(self.is_some.is_true_vartime(), "{}", msg);`
	`401`	`+ assert!(self.is_some.to_bool_vartime(), "{}", msg);`
`407`	`402`	`self.value`
`408`	`403`	`}`
`409`	`404`
`@@ -424,7 +419,7 @@ impl<const LIMBS: usize> ConstCtOption<(Uint<LIMBS>, Uint<LIMBS>)> {`
`424`	`419`	`#[inline]`
`425`	`420`	`#[track_caller]`
`426`	`421`	`pub const fn expect(self, msg: &str) -> (Uint<LIMBS>, Uint<LIMBS>) {`
`427`		`- assert!(self.is_some.is_true_vartime(), "{}", msg);`
	`422`	`+ assert!(self.is_some.to_bool_vartime(), "{}", msg);`
`428`	`423`	`self.value`
`429`	`424`	`}`
`430`	`425`	`}`
`@@ -439,7 +434,7 @@ impl<const LIMBS: usize> ConstCtOption<NonZero<Uint<LIMBS>>> {`
`439`	`434`	`#[inline]`
`440`	`435`	`#[track_caller]`
`441`	`436`	`pub const fn expect(self, msg: &str) -> NonZero<Uint<LIMBS>> {`
`442`		`- assert!(self.is_some.is_true_vartime(), "{}", msg);`
	`437`	`+ assert!(self.is_some.to_bool_vartime(), "{}", msg);`
`443`	`438`	`self.value`
`444`	`439`	`}`
`445`	`440`	`}`
`@@ -454,7 +449,7 @@ impl<const LIMBS: usize> ConstCtOption<Odd<Uint<LIMBS>>> {`
`454`	`449`	`#[inline]`
`455`	`450`	`#[track_caller]`
`456`	`451`	`pub const fn expect(self, msg: &str) -> Odd<Uint<LIMBS>> {`
`457`		`- assert!(self.is_some.is_true_vartime(), "{}", msg);`
	`452`	`+ assert!(self.is_some.to_bool_vartime(), "{}", msg);`
`458`	`453`	`self.value`
`459`	`454`	`}`
`460`	`455`	`}`
`@@ -475,7 +470,7 @@ impl<const LIMBS: usize> ConstCtOption<Int<LIMBS>> {`
`475`	`470`	`#[inline]`
`476`	`471`	`#[track_caller]`
`477`	`472`	`pub const fn expect(self, msg: &str) -> Int<LIMBS> {`
`478`		`- assert!(self.is_some.is_true_vartime(), "{}", msg);`
	`473`	`+ assert!(self.is_some.to_bool_vartime(), "{}", msg);`
`479`	`474`	`self.value`
`480`	`475`	`}`
`481`	`476`	`}`
`@@ -490,7 +485,7 @@ impl<const LIMBS: usize> ConstCtOption<NonZeroInt<LIMBS>> {`
`490`	`485`	`#[inline]`
`491`	`486`	`#[track_caller]`
`492`	`487`	`pub const fn expect(self, msg: &str) -> NonZeroInt<LIMBS> {`
`493`		`- assert!(self.is_some.is_true_vartime(), "{}", msg);`
	`488`	`+ assert!(self.is_some.to_bool_vartime(), "{}", msg);`
`494`	`489`	`self.value`
`495`	`490`	`}`
`496`	`491`	`}`
`@@ -505,7 +500,7 @@ impl<const LIMBS: usize> ConstCtOption<OddInt<LIMBS>> {`
`505`	`500`	`#[inline]`
`506`	`501`	`#[track_caller]`
`507`	`502`	`pub const fn expect(self, msg: &str) -> OddInt<LIMBS> {`
`508`		`- assert!(self.is_some.is_true_vartime(), "{}", msg);`
	`503`	`+ assert!(self.is_some.to_bool_vartime(), "{}", msg);`
`509`	`504`	`self.value`
`510`	`505`	`}`
`511`	`506`	`}`
`@@ -520,7 +515,7 @@ impl ConstCtOption<NonZero<Limb>> {`
`520`	`515`	`#[inline]`
`521`	`516`	`#[track_caller]`
`522`	`517`	`pub const fn expect(self, msg: &str) -> NonZero<Limb> {`
`523`		`- assert!(self.is_some.is_true_vartime(), "{}", msg);`
	`518`	`+ assert!(self.is_some.to_bool_vartime(), "{}", msg);`
`524`	`519`	`self.value`
`525`	`520`	`}`
`526`	`521`	`}`
`@@ -535,7 +530,7 @@ impl<const LIMBS: usize> ConstCtOption<SafeGcdInverter<LIMBS>> {`
`535`	`530`	`#[inline]`
`536`	`531`	`#[track_caller]`
`537`	`532`	`pub const fn expect(self, msg: &str) -> SafeGcdInverter<LIMBS> {`
`538`		`- assert!(self.is_some.is_true_vartime(), "{}", msg);`
	`533`	`+ assert!(self.is_some.to_bool_vartime(), "{}", msg);`
`539`	`534`	`self.value`
`540`	`535`	`}`
`541`	`536`	`}`
`@@ -555,7 +550,7 @@ impl<MOD: ConstMontyParams<LIMBS>, const LIMBS: usize> ConstCtOption<ConstMontyF`
`555`	`550`	`#[inline]`
`556`	`551`	`#[track_caller]`
`557`	`552`	`pub const fn expect(self, msg: &str) -> ConstMontyForm<MOD, LIMBS> {`
`558`		`- assert!(self.is_some.is_true_vartime(), "{}", msg);`
	`553`	`+ assert!(self.is_some.to_bool_vartime(), "{}", msg);`
`559`	`554`	`self.value`
`560`	`555`	`}`
`561`	`556`	`}`
Original file line number	Diff line number	Diff line change
`@@ -153,8 +153,8 @@ mod tests {`
`153`	`153`
`154`	`154`	`#[test]`
`155`	`155`	`fn shl256_const() {`
`156`		`- assert!(N.overflowing_shl(256).is_none().is_true_vartime());`
`157`		`- assert!(N.overflowing_shl_vartime(256).is_none().is_true_vartime());`
	`156`	`+ assert!(N.overflowing_shl(256).is_none().to_bool_vartime());`
	`157`	`+ assert!(N.overflowing_shl_vartime(256).is_none().to_bool_vartime());`
`158`	`158`	`}`
`159`	`159`
`160`	`160`	`#[test]`
Original file line number	Diff line number	Diff line change
`@@ -227,8 +227,8 @@ mod tests {`
`227`	`227`
`228`	`228`	`#[test]`
`229`	`229`	`fn shr256_const() {`
`230`		`- assert!(N.overflowing_shr(256).is_none().is_true_vartime());`
`231`		`- assert!(N.overflowing_shr_vartime(256).is_none().is_true_vartime());`
	`230`	`+ assert!(N.overflowing_shr(256).is_none().to_bool_vartime());`
	`231`	`+ assert!(N.overflowing_shr_vartime(256).is_none().to_bool_vartime());`
`232`	`232`	`}`
`233`	`233`
`234`	`234`	`#[test]`