requested changes

Author: Qelxiros

library/core/src/num/int_macros.rs

@@ -1413,32 +1413,40 @@ macro_rules! int_impl {
             }
         }
 
-        /// Exact shift left. Computes `self << rhs`, returning `None` if any bits disagreeing with
-        /// the resulting sign bit would be shifted out.
+        /// Exact shift left. Computes `self << rhs` as long as it can be reversed losslessly.
+        ///
+        /// Returns `None` if any bits that would be shifted out differ from the resulting sign bit
+        /// or if `rhs` >=
+        #[doc = concat!("`", stringify!($SelfT), "::BITS`.")]
+        /// Otherwise, returns `Some(self << rhs)`.
         ///
         /// # Examples
         ///
         /// ```
         /// #![feature(exact_bitshifts)]
         ///
         #[doc = concat!("assert_eq!(0x1", stringify!($SelfT), ".exact_shl(4), Some(0x10));")]
-        #[doc = concat!("assert_eq!(0x1", stringify!($SelfT), ".exact_shl(129), None);")]
+        #[doc = concat!("assert_eq!(0x1", stringify!($SelfT), ".exact_shl(", stringify!($SelfT), "::BITS - 2), Some(1 << ", stringify!($SelfT), "::BITS - 2));")]
+        #[doc = concat!("assert_eq!(0x1", stringify!($SelfT), ".exact_shl(", stringify!($SelfT), "::BITS - 1), None);")]
+        #[doc = concat!("assert_eq!((-0x2", stringify!($SelfT), ").exact_shl(", stringify!($SelfT), "::BITS - 2), Some(-0x2 << ", stringify!($SelfT), "::BITS - 2));")]
+        #[doc = concat!("assert_eq!((-0x2", stringify!($SelfT), ").exact_shl(", stringify!($SelfT), "::BITS - 1), None);")]
         /// ```
         #[unstable(feature = "exact_bitshifts", issue = "144336")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
-        pub fn exact_shl(self, rhs: u32) -> Option<$SelfT> {
-            if rhs < self.leading_zeros().max(self.leading_ones()) {
+        pub const fn exact_shl(self, rhs: u32) -> Option<$SelfT> {
+            if rhs < self.leading_zeros() || rhs < self.leading_ones() {
                 // SAFETY: rhs is checked above
                 Some(unsafe { self.unchecked_shl(rhs) })
             } else {
                 None
             }
         }
 
-        /// Unchecked exact shift left. Computes `self << rhs`, assuming bits disagreeing with the
-        /// resulting sign bit cannot be shifted out.
+        /// Unchecked exact shift left. Computes `self << rhs`, assuming the operation can be
+        /// losslessly reversed and `rhs` cannot be larger than
+        #[doc = concat!("`", stringify!($SelfT), "::BITS`.")]
         ///
         /// # Safety
         ///
@@ -1450,14 +1458,15 @@ macro_rules! int_impl {
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
-        pub unsafe fn exact_shl_unchecked(self, rhs: u32) -> $SelfT {
+        pub const unsafe fn unchecked_exact_shl(self, rhs: u32) -> $SelfT {
             assert_unsafe_precondition!(
                 check_language_ub,
-                concat!(stringify!($SelfT), "::exact_shl_unchecked cannot shift out non-zero bits"),
+                concat!(stringify!($SelfT), "::unchecked_exact_shl cannot shift out non-zero bits"),
                 (
-                    len: u32 = self.leading_zeros().max(self.leading_ones()),
+                    zeros: u32 = self.leading_zeros(),
+                    ones: u32 = self.leading_ones(),
                     rhs: u32 = rhs,
-                ) => rhs < len,
+                ) => rhs < zeros || rhs < ones,
             );
 
             // SAFETY: this is guaranteed to be safe by the caller
@@ -1585,33 +1594,35 @@ macro_rules! int_impl {
             }
         }
 
-        /// Exact shift right. Computes `self >> rhs`, returning `None` if any non-zero bits would be
-        /// shifted out or if `rhs` >=
+        /// Exact shift right. Computes `self >> rhs` as long as it can be reversed losslessly.
+        ///
+        /// Returns `None` if any non-zero bits would be shifted out or if `rhs` >=
         #[doc = concat!("`", stringify!($SelfT), "::BITS`.")]
+        /// Otherwise, returns `Some(self >> rhs)`.
         ///
         /// # Examples
         ///
         /// ```
         /// #![feature(exact_bitshifts)]
         ///
         #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".exact_shr(4), Some(0x1));")]
-        #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".exact_shr(129), None);")]
+        #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".exact_shr(5), None);")]
         /// ```
         #[unstable(feature = "exact_bitshifts", issue = "144336")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
-        pub fn exact_shr(self, rhs: u32) -> Option<$SelfT> {
-            if rhs <= self.trailing_zeros().max(<$SelfT>::BITS - 1) {
+        pub const fn exact_shr(self, rhs: u32) -> Option<$SelfT> {
+            if rhs <= self.trailing_zeros() && rhs < <$SelfT>::BITS {
                 // SAFETY: rhs is checked above
                 Some(unsafe { self.unchecked_shr(rhs) })
             } else {
                 None
             }
         }
 
-        /// Unchecked exact shift right. Computes `self >> rhs`, assuming non-zero bits cannot be
-        /// shifted out and `rhs` cannot be larger than
+        /// Unchecked exact shift right. Computes `self >> rhs`, assuming the operation can be
+        /// losslessly reversed and `rhs` cannot be larger than
         #[doc = concat!("`", stringify!($SelfT), "::BITS`.")]
         ///
         /// # Safety
@@ -1625,14 +1636,15 @@ macro_rules! int_impl {
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
-        pub unsafe fn exact_shr_unchecked(self, rhs: u32) -> $SelfT {
+        pub const unsafe fn unchecked_exact_shr(self, rhs: u32) -> $SelfT {
             assert_unsafe_precondition!(
                 check_language_ub,
-                concat!(stringify!($SelfT), "::exact_shr_unchecked cannot shift out non-zero bits"),
+                concat!(stringify!($SelfT), "::unchecked_exact_shr cannot shift out non-zero bits"),
                 (
-                    len: u32 = self.trailing_zeros().max(<$SelfT>::BITS - 1),
+                    zeros: u32 = self.trailing_zeros(),
+                    bits: u32 =  <$SelfT>::BITS,
                     rhs: u32 = rhs,
-                ) => rhs <= len,
+                ) => rhs <= zeros && rhs < bits,
             );
 
             // SAFETY: this is guaranteed to be safe by the caller

library/core/src/num/uint_macros.rs

@@ -1734,9 +1734,11 @@ macro_rules! uint_impl {
             }
         }
 
-        /// Exact shift left. Computes `self << rhs`, returning `None` if any non-zero bits would be
-        /// shifted out or if `rhs` >=
+        /// Exact shift left. Computes `self << rhs` as long as it can be reversed losslessly.
+        ///
+        /// Returns `None` if any non-zero bits would be shifted out or if `rhs` >=
         #[doc = concat!("`", stringify!($SelfT), "::BITS`.")]
+        /// Otherwise, returns `Some(self << rhs)`.
         ///
         /// # Examples
         ///
@@ -1750,17 +1752,17 @@ macro_rules! uint_impl {
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
-        pub fn exact_shl(self, rhs: u32) -> Option<$SelfT> {
-            if rhs <= self.leading_zeros().max(<$SelfT>::BITS - 1) {
+        pub const fn exact_shl(self, rhs: u32) -> Option<$SelfT> {
+            if rhs <= self.leading_zeros() && rhs < <$SelfT>::BITS {
                 // SAFETY: rhs is checked above
                 Some(unsafe { self.unchecked_shl(rhs) })
             } else {
                 None
             }
         }
 
-        /// Unchecked exact shift left. Computes `self << rhs`, assuming non-zero bits cannot be
-        /// shifted out and `rhs` cannot be larger than
+        /// Unchecked exact shift left. Computes `self << rhs`, assuming the operation can be
+        /// losslessly reversed `rhs` cannot be larger than
         #[doc = concat!("`", stringify!($SelfT), "::BITS`.")]
         ///
         /// # Safety
@@ -1774,14 +1776,15 @@ macro_rules! uint_impl {
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
-        pub unsafe fn exact_shl_unchecked(self, rhs: u32) -> $SelfT {
+        pub const unsafe fn unchecked_exact_shl(self, rhs: u32) -> $SelfT {
             assert_unsafe_precondition!(
                 check_language_ub,
                 concat!(stringify!($SelfT), "::exact_shl_unchecked cannot shift out non-zero bits"),
                 (
-                    len: u32 = self.leading_zeros().max(<$SelfT>::BITS - 1),
+                    zeros: u32 = self.leading_zeros(),
+                    bits: u32 =  <$SelfT>::BITS,
                     rhs: u32 = rhs,
-                ) => rhs <= len,
+                ) => rhs <= zeros && rhs < bits,
             );
 
             // SAFETY: this is guaranteed to be safe by the caller
@@ -1903,33 +1906,35 @@ macro_rules! uint_impl {
             }
         }
 
-        /// Exact shift right. Computes `self >> rhs`, returning `None` if any non-zero bits would be
-        /// shifted out or if `rhs` >=
+        /// Exact shift right. Computes `self >> rhs` as long as it can be reversed losslessly.
+        ///
+        /// Returns `None` if any non-zero bits would be shifted out or if `rhs` >=
         #[doc = concat!("`", stringify!($SelfT), "::BITS`.")]
+        /// Otherwise, returns `Some(self >> rhs)`.
         ///
         /// # Examples
         ///
         /// ```
         /// #![feature(exact_bitshifts)]
         ///
         #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".exact_shr(4), Some(0x1));")]
-        #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".exact_shr(129), None);")]
+        #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".exact_shr(5), None);")]
         /// ```
         #[unstable(feature = "exact_bitshifts", issue = "144336")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
-        pub fn exact_shr(self, rhs: u32) -> Option<$SelfT> {
-            if rhs <= self.trailing_zeros().max(<$SelfT>::BITS - 1) {
+        pub const fn exact_shr(self, rhs: u32) -> Option<$SelfT> {
+            if rhs <= self.trailing_zeros() && rhs < <$SelfT>::BITS {
                 // SAFETY: rhs is checked above
                 Some(unsafe { self.unchecked_shr(rhs) })
             } else {
                 None
             }
         }
 
-        /// Unchecked exact shift right. Computes `self >> rhs`, assuming non-zero bits cannot be
-        /// shifted out and `rhs` cannot be larger than
+        /// Unchecked exact shift right. Computes `self >> rhs`, assuming the operation can be
+        /// losslessly reversed and `rhs` cannot be larger than
         #[doc = concat!("`", stringify!($SelfT), "::BITS`.")]
         ///
         /// # Safety
@@ -1943,14 +1948,15 @@ macro_rules! uint_impl {
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
-        pub unsafe fn exact_shr_unchecked(self, rhs: u32) -> $SelfT {
+        pub const unsafe fn unchecked_exact_shr(self, rhs: u32) -> $SelfT {
             assert_unsafe_precondition!(
                 check_language_ub,
                 concat!(stringify!($SelfT), "::exact_shr_unchecked cannot shift out non-zero bits"),
                 (
-                    len: u32 = self.trailing_zeros().max(<$SelfT>::BITS - 1),
+                    zeros: u32 = self.trailing_zeros(),
+                    bits: u32 =  <$SelfT>::BITS,
                     rhs: u32 = rhs,
-                ) => rhs <= len,
+                ) => rhs <= zeros && rhs < bits,
             );
 
             // SAFETY: this is guaranteed to be safe by the caller