added unchecked_rem for signed and unsigned types

Author: madhav-madhusoodanan

library/core/src/num/int_macros.rs

@@ -1080,6 +1080,36 @@ macro_rules! int_impl {
             }
         }
 
+        /// Unchecked integer remainder. Computes `self % rhs`, assuming `rhs != 0`
+        /// and overflow cannot occur.
+        ///
+        /// # Safety
+        ///
+        /// This results in undefined behavior when `rhs == 0` or
+        #[doc = concat!("(`self == ", stringify!($SelfT), "::MIN` and `rhs == -1`),")]
+        /// i.e. when [`checked_rem`] would return `None`.
+        ///
+        #[doc = concat!("[`checked_rem`]: ", stringify!($SelfT), "::checked_rem")]
+        #[unstable(feature = "unchecked_div_rem", issue = "136716")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
+        pub const unsafe fn unchecked_rem(self, rhs: Self) -> Self {
+            assert_unsafe_precondition!(
+                check_language_ub,
+                concat!(stringify!($SelfT), "::unchecked_rem cannot overflow or divide by zero"),
+                (
+                    lhs: $SelfT = self,
+                    rhs: $SelfT = rhs
+                ) => rhs != 0 && !lhs.overflowing_rem(rhs).1,
+            );
+
+            // SAFETY: this is guaranteed to be safe by the caller.
+            unsafe {
+                intrinsics::unchecked_rem(self, rhs)
+            }
+        }
+
         /// Strict integer remainder. Computes `self % rhs`, panicking if
         /// the division results in overflow.
         ///

library/core/src/num/uint_macros.rs

@@ -1027,7 +1027,7 @@ macro_rules! uint_impl {
         ///
         /// # Safety
         ///
-        /// This results in undefined behavior when `rhs == 0`
+        /// This results in undefined behavior when `rhs == 0`,
         /// i.e. when [`checked_div`] would return `None`.
         ///
         /// [`unwrap_unchecked`]: option/enum.Option.html#method.unwrap_unchecked
@@ -1169,6 +1169,33 @@ macro_rules! uint_impl {
             }
         }
 
+        /// Unchecked integer remainder. Computes `self % rhs`, assuming `rhs` is not zero.
+        ///
+        /// # Safety
+        ///
+        /// This results in undefined behavior when `rhs == 0`,
+        /// i.e. when [`checked_rem`] would return `None`.
+        ///
+        #[doc = concat!("[`checked_rem`]: ", stringify!($SelfT), "::checked_rem")]
+        #[unstable(feature = "unchecked_div_rem", issue = "136716")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
+        pub const unsafe fn unchecked_rem(self, rhs: Self) -> Self {
+            assert_unsafe_precondition!(
+                check_language_ub,
+                concat!(stringify!($SelfT), "::unchecked_rem cannot divide by zero"),
+                (
+                    rhs: $SelfT = rhs
+                ) => rhs != 0,
+            );
+
+            // SAFETY: this is guaranteed to be safe by the caller.
+            unsafe {
+                intrinsics::unchecked_rem(self, rhs)
+            }
+        }
+
         /// Strict integer remainder. Computes `self % rhs`.
         ///
         /// Strict remainder calculation on unsigned types is just the regular