Make wrapping int fns const

With #49146 merged, these can be const; see #53718.

Author: 9999years

src/libcore/num/mod.rs

@@ -1338,11 +1338,23 @@ $EndFeature, "
             #[must_use = "this returns the result of the operation, \
                           without modifying the original"]
             #[inline]
-            pub fn wrapping_div(self, rhs: Self) -> Self {
+            #[rustc_const_unstable(feature = "const_int_wrapping")]
+            #[cfg(not(bootstrap))]
+            pub const fn wrapping_div(self, rhs: Self) -> Self {
                 self.overflowing_div(rhs).0
             }
         }
 
+        /// No docs for bootstrap.
+        #[stable(feature = "num_wrapping", since = "1.2.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        #[cfg(bootstrap)]
+        pub fn wrapping_div(self, rhs: Self) -> Self {
+            self.overflowing_div(rhs).0
+        }
+
         doc_comment! {
             concat!("Wrapping Euclidean division. Computes `self.div_euclid(rhs)`,
 wrapping around at the boundary of the type.
@@ -1397,11 +1409,23 @@ $EndFeature, "
             #[must_use = "this returns the result of the operation, \
                           without modifying the original"]
             #[inline]
-            pub fn wrapping_rem(self, rhs: Self) -> Self {
+            #[rustc_const_unstable(feature = "const_int_wrapping")]
+            #[cfg(not(bootstrap))]
+            pub const fn wrapping_rem(self, rhs: Self) -> Self {
                 self.overflowing_rem(rhs).0
             }
         }
 
+        /// No docs for bootstrap.
+        #[stable(feature = "num_wrapping", since = "1.2.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        #[cfg(bootstrap)]
+        pub fn wrapping_rem(self, rhs: Self) -> Self {
+            self.overflowing_rem(rhs).0
+        }
+
         doc_comment! {
             concat!("Wrapping Euclidean remainder. Computes `self.rem_euclid(rhs)`, wrapping around
 at the boundary of the type.
@@ -3422,7 +3446,7 @@ $EndFeature, "
         #[stable(feature = "rust1", since = "1.0.0")]
         #[rustc_const_stable(feature = "const_wrapping_math", since = "1.32.0")]
         #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
+                      without modifying the original"]
         #[inline]
         pub const fn wrapping_mul(self, rhs: Self) -> Self {
             intrinsics::wrapping_mul(self, rhs)
@@ -3446,11 +3470,23 @@ Basic usage:
             #[must_use = "this returns the result of the operation, \
                           without modifying the original"]
             #[inline]
-            pub fn wrapping_div(self, rhs: Self) -> Self {
+            #[rustc_const_unstable(feature = "const_int_wrapping")]
+            #[cfg(not(bootstrap))]
+            pub const fn wrapping_div(self, rhs: Self) -> Self {
                 self / rhs
             }
         }
 
+        /// No docs for bootstrap.
+        #[stable(feature = "num_wrapping", since = "1.2.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        #[cfg(bootstrap)]
+        pub fn wrapping_div(self, rhs: Self) -> Self {
+            self / rhs
+        }
+
         doc_comment! {
             concat!("Wrapping Euclidean division. Computes `self.div_euclid(rhs)`.
 Wrapped division on unsigned types is just normal division.
@@ -3496,11 +3532,23 @@ Basic usage:
             #[must_use = "this returns the result of the operation, \
                           without modifying the original"]
             #[inline]
-            pub fn wrapping_rem(self, rhs: Self) -> Self {
+            #[rustc_const_unstable(feature = "const_int_wrapping")]
+            #[cfg(not(bootstrap))]
+            pub const fn wrapping_rem(self, rhs: Self) -> Self {
                 self % rhs
             }
         }
 
+        /// No docs for bootstrap.
+        #[stable(feature = "num_wrapping", since = "1.2.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        #[cfg(bootstrap)]
+        pub fn wrapping_rem(self, rhs: Self) -> Self {
+            self % rhs
+        }
+
         doc_comment! {
             concat!("Wrapping Euclidean modulo. Computes `self.rem_euclid(rhs)`.
 Wrapped modulo calculation on unsigned types is

src/test/ui/consts/const-int-wrapping-rpass.rs

@@ -1,4 +1,5 @@
 // run-pass
+#![feature(const_int_wrapping)]
 
 const ADD_A: u32 = 200u32.wrapping_add(55);
 const ADD_B: u32 = 200u32.wrapping_add(u32::max_value());
@@ -22,6 +23,18 @@ const ABS_POS: i32 = 10i32.wrapping_abs();
 const ABS_NEG: i32 = (-10i32).wrapping_abs();
 const ABS_MIN: i32 = i32::min_value().wrapping_abs();
 
+const DIV_A: i8 = 8i8.wrapping_div(2);
+const DIV_B: i8 = 8i8.wrapping_div(3);
+const DIV_C: i8 = i8::min_value().wrapping_div(-1i8);
+const DIV_D: u8 = 8u8.wrapping_div(2);
+const DIV_E: u8 = 8u8.wrapping_div(3);
+
+const REM_A: i8 = 8i8.wrapping_rem(2);
+const REM_B: i8 = 8i8.wrapping_rem(3);
+const REM_C: i8 = i8::min_value().wrapping_rem(-1i8);
+const REM_D: u8 = 8u8.wrapping_rem(2);
+const REM_E: u8 = 8u8.wrapping_rem(3);
+
 fn main() {
     assert_eq!(ADD_A, 255);
     assert_eq!(ADD_B, 199);
@@ -44,4 +57,16 @@ fn main() {
     assert_eq!(ABS_POS, 10);
     assert_eq!(ABS_NEG, 10);
     assert_eq!(ABS_MIN, i32::min_value());
+
+    assert_eq!(DIV_A, 4i8);
+    assert_eq!(DIV_B, 2i8);
+    assert_eq!(DIV_C, i8::min_value());
+    assert_eq!(DIV_D, 4u8);
+    assert_eq!(DIV_E, 2u8);
+
+    assert_eq!(REM_A, 0i8);
+    assert_eq!(REM_B, 2i8);
+    assert_eq!(REM_C, 0i8);
+    assert_eq!(REM_D, 0u8);
+    assert_eq!(REM_E, 2u8);
 }