Do sign extension for signed int shift left saturation

Author: kellerkindt

library/core/src/num/int_macros.rs

@@ -989,7 +989,7 @@ macro_rules! int_impl {
             intrinsics::saturating_sub(0, self)
         }
 
-        /// Panic-free bitwise shift-left; yields `0` where the shift exceeds the bitwidth of the type.
+        /// Panic-free bitwise shift-left; saturates to `MIN` or `MAX` instead of wrapping around.
         ///
         /// Note that this is *not* the same as a rotate-left; the RHS of a saturating shift-left is restricted to
         /// the range of the type, rather than the bits shifted out of the LHS being returned to the other end.
@@ -1002,19 +1002,34 @@ macro_rules! int_impl {
         ///
         /// ```
         /// #![feature(saturating_bit_shifts)]
-        #[doc = concat!("assert_eq!(0b0000_0001_u8.saturating_shl(u8::BITS - 1), 0b1000_0000_u8);")]
-        #[doc = concat!("assert_eq!(0b0000_0001_u8.saturating_shl(u8::BITS), 0b0000_0000_u8);")]
+        #[doc = concat!("assert_eq!(1_", stringify!($SelfT), ".saturating_shl(", stringify!($SelfT), "::BITS - 2), 1_", stringify!($SelfT), " << ", stringify!($SelfT), "::BITS - 2);")]
+        #[doc = concat!("assert_eq!(1_", stringify!($SelfT), ".saturating_shl(", stringify!($SelfT), "::BITS - 1), ", stringify!($SelfT), "::MAX);")]
+        #[doc = concat!("assert_eq!(-1_", stringify!($SelfT), ".saturating_shl(", stringify!($SelfT), "::BITS - 2), -1_", stringify!($SelfT), " << ", stringify!($SelfT), "::BITS - 2);")]
+        #[doc = concat!("assert_eq!(-1_", stringify!($SelfT), ".saturating_shl(", stringify!($SelfT), "::BITS - 1), ", stringify!($SelfT), "::MIN);")]
+        #[doc = concat!("assert_eq!(-1_", stringify!($SelfT), ".saturating_shl(", stringify!($SelfT), "::BITS), ", stringify!($SelfT), "::MIN);")]
         /// ```
         #[unstable(feature = "saturating_bit_shifts", issue = "103440")]
         #[rustc_const_unstable(feature = "saturating_bit_shifts", issue = "103440")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline(always)]
         pub const fn saturating_shl(self, rhs: u32) -> Self {
-            if rhs >= <$SelfT>::BITS {
-                0
+            if rhs == 0 {
+                self
             } else {
-                self << rhs
+                // leading zeros ignoring first bit (which indicates negative values)
+                let leading_zeros = (self << 1).leading_zeros();
+                let leading_ones = (self << 1).leading_ones();
+
+                // would overflow => MIN / MAX depending on whether the value is negative or not
+                if self >= 0 && leading_zeros <  rhs {
+                    <$SelfT>::MAX
+                } else if self < 0 && leading_ones < rhs {
+                    <$SelfT>::MIN
+                } else {
+                    // normal shift left
+                    self << rhs
+                }
             }
         }
 

library/core/src/num/uint_macros.rs

@@ -1164,7 +1164,7 @@ macro_rules! uint_impl {
             }
         }
 
-        /// Panic-free bitwise shift-left; yields `0` where the shift exceeds the bitwidth of the type.
+        /// Panic-free bitwise shift-left; saturates `MAX` instead of wrapping around.
         ///
         /// Note that this is *not* the same as a rotate-left; the RHS of a saturating shift-left is restricted to
         /// the range of the type, rather than the bits shifted out of the LHS being returned to the other end.
@@ -1177,17 +1177,17 @@ macro_rules! uint_impl {
         ///
         /// ```
         /// #![feature(saturating_bit_shifts)]
-        #[doc = concat!("assert_eq!(0b0000_0001_u8.saturating_shl(u8::BITS - 1), 0b1000_0000_u8);")]
-        #[doc = concat!("assert_eq!(0b0000_0001_u8.saturating_shl(u8::BITS), 0b0000_0000_u8);")]
+        #[doc = concat!("assert_eq!(1_", stringify!($SelfT), ".saturating_shl(", stringify!($SelfT), "::BITS - 1), 1_", stringify!($SelfT), " << ", stringify!($SelfT), "::BITS - 1);")]
+        #[doc = concat!("assert_eq!(1_", stringify!($SelfT), ".saturating_shl(", stringify!($SelfT), "::BITS), ", stringify!($SelfT), "::MAX);")]
         /// ```
         #[unstable(feature = "saturating_bit_shifts", issue = "103440")]
         #[rustc_const_unstable(feature = "saturating_bit_shifts", issue = "103440")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline(always)]
         pub const fn saturating_shl(self, rhs: u32) -> Self {
-            if rhs >= <$SelfT>::BITS {
-                0
+            if rhs > self.leading_zeros() {
+                <$SelfT>::MAX
             } else {
                 self << rhs
             }