Auto merge of rust-lang#55278 - Centril:constification-1, r=alexcrichton

bors · bors · commit 65204a97d487 · 2018-11-12T18:54:11.000Z
Minor standard library constification This PR makes some bits of the standard library into `const fn`s. I've tried to be as aggressive as I possibly could in the constification. The list is rather small due to how restrictive `const fn` is at the moment. r? @oli-obk cc @rust-lang/libs Stable public APIs affected: + [x] `Cell::as_ptr` + [x] `UnsafeCell::get` + [x] `char::is_ascii` + [x] `iter::empty` + [x] `ManuallyDrop::{new, into_inner}` + [x] `RangeInclusive::{start, end}` + [x] `NonNull::as_ptr` + [x] `{[T], str}::as_ptr` + [x] `Duration::{as_secs, subsec_millis, subsec_micros, subsec_nanos}` + [x] `CStr::as_ptr` + [x] `Ipv4Addr::is_unspecified` + [x] `Ipv6Addr::new` + [x] `Ipv6Addr::octets` Unstable public APIs affected: + [x] `Duration::{as_millis, as_micros, as_nanos, as_float_secs}` + [x] `Wrapping::{count_ones, count_zeros, trailing_zeros, rotate_left, rotate_right, swap_bytes, reverse_bits, from_be, from_le, to_be, to_le, leading_zeros, is_positive, is_negative, leading_zeros}` + [x] `core::convert::identity` -------------------------- ## Removed from list in first pass: Stable public APIs affected: + [ ] `BTree{Map, Set}::{len, is_empty}` + [ ] `VecDeque::is_empty` + [ ] `String::{is_empty, len}` + [ ] `FromUtf8Error::utf8_error` + [ ] `Vec<T>::{is_empty, len}` + [ ] `Layout::size` + [ ] `DecodeUtf16Error::unpaired_surrogate` + [ ] `core::fmt::{fill, width, precision, sign_plus, sign_minus, alternate, sign_aware_zero_pad}` + [ ] `panic::Location::{file, line, column}` + [ ] `{ChunksExact, RChunksExact}::remainder` + [ ] `Utf8Error::valid_up_to` + [ ] `VacantEntry::key` + [ ] `NulError::nul_position` + [ ] `IntoStringError::utf8_error` + [ ] `IntoInnerError::error` + [ ] `io::Chain::get_ref` + [ ] `io::Take::{limit, get_ref}` + [ ] `SocketAddrV6::{flowinfo, scope_id}` + [ ] `PrefixComponent::{kind, as_os_str}` + [ ] `Path::{ancestors, display}` + [ ] `WaitTimeoutResult::timed_out` + [ ] `Receiver::{iter, try_iter}` + [ ] `thread::JoinHandle::thread` + [ ] `SystemTimeError::duration` Unstable public APIs affected: + [ ] `core::fmt::Arguments::new_v1` + [ ] `core::fmt::Arguments::new_v1_formatted` + [ ] `Pin::{get_ref, into_ref}` + [ ] `Utf8Lossy::chunks` + [ ] `LocalWaker::as_waker` + [ ] `panic::PanicInfo::{internal_constructor, message, location}` + [ ] `panic::Location::{internal_constructor }` ## Removed from list in 2nd pass: Stable public APIs affected: + [ ] `LinkedList::{new, iter, is_empty, len}` + [ ] `mem::forget` + [ ] `Cursor::{new, get_ref, position}` + [ ] `io::{empty, repeat, sink}` + [ ] `PoisonError::new` + [ ] `thread::Builder::new` + [ ] `process::Stdio::{piped, inherit, null}` Unstable public APIs affected: + [ ] `io::Initializer::{zeroing, should_initialize}`
diff --git a/src/libcore/cell.rs b/src/libcore/cell.rs
@@ -474,7 +474,7 @@ impl<T: ?Sized> Cell<T> {
     /// ```
     #[inline]
     #[stable(feature = "cell_as_ptr", since = "1.12.0")]
-    pub fn as_ptr(&self) -> *mut T {
+    pub const fn as_ptr(&self) -> *mut T {
         self.value.get()
     }
 
@@ -1508,7 +1508,7 @@ impl<T: ?Sized> UnsafeCell<T> {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn get(&self) -> *mut T {
+    pub const fn get(&self) -> *mut T {
         &self.value as *const T as *mut T
     }
 }
diff --git a/src/libcore/char/methods.rs b/src/libcore/char/methods.rs
@@ -903,7 +903,7 @@ impl char {
     /// ```
     #[stable(feature = "ascii_methods_on_intrinsics", since = "1.23.0")]
     #[inline]
-    pub fn is_ascii(&self) -> bool {
+    pub const fn is_ascii(&self) -> bool {
         *self as u32 <= 0x7F
     }
 
diff --git a/src/libcore/convert.rs b/src/libcore/convert.rs
@@ -104,7 +104,6 @@
 /// assert_eq!(vec![1, 3], filtered);
 /// ```
 #[unstable(feature = "convert_id", issue = "53500")]
-#[rustc_const_unstable(feature = "const_convert_id")]
 #[inline]
 pub const fn identity<T>(x: T) -> T { x }
 
diff --git a/src/libcore/iter/sources.rs b/src/libcore/iter/sources.rs
@@ -283,7 +283,7 @@ impl<T> Default for Empty<T> {
 /// assert_eq!(None, nope.next());
 /// ```
 #[stable(feature = "iter_empty", since = "1.2.0")]
-pub fn empty<T>() -> Empty<T> {
+pub const fn empty<T>() -> Empty<T> {
     Empty(marker::PhantomData)
 }
 
diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs
@@ -82,7 +82,6 @@
 #![feature(const_fn)]
 #![feature(const_int_ops)]
 #![feature(const_fn_union)]
-#![feature(const_manually_drop_new)]
 #![feature(custom_attribute)]
 #![feature(doc_cfg)]
 #![feature(doc_spotlight)]
diff --git a/src/libcore/mem.rs b/src/libcore/mem.rs
@@ -942,7 +942,6 @@ impl<T> ManuallyDrop<T> {
     /// ManuallyDrop::new(Box::new(()));
     /// ```
     #[stable(feature = "manually_drop", since = "1.20.0")]
-    #[rustc_const_unstable(feature = "const_manually_drop_new")]
     #[inline]
     pub const fn new(value: T) -> ManuallyDrop<T> {
         ManuallyDrop { value }
@@ -961,7 +960,7 @@ impl<T> ManuallyDrop<T> {
     /// ```
     #[stable(feature = "manually_drop", since = "1.20.0")]
     #[inline]
-    pub fn into_inner(slot: ManuallyDrop<T>) -> T {
+    pub const fn into_inner(slot: ManuallyDrop<T>) -> T {
         slot.value
     }
 
diff --git a/src/libcore/num/flt2dec/estimator.rs b/src/libcore/num/flt2dec/estimator.rs
@@ -22,4 +22,3 @@ pub fn estimate_scaling_factor(mant: u64, exp: i16) -> i16 {
     // therefore this always underestimates (or is exact), but not much.
     (((nbits + exp as i64) * 1292913986) >> 32) as i16
 }
-
diff --git a/src/libcore/num/flt2dec/mod.rs b/src/libcore/num/flt2dec/mod.rs
@@ -658,4 +658,3 @@ pub fn to_exact_fixed_str<'a, T, F>(mut format_exact: F, v: T,
         }
     }
 }
-
diff --git a/src/libcore/num/wrapping.rs b/src/libcore/num/wrapping.rs
@@ -387,7 +387,7 @@ assert_eq!(n.count_ones(), 3);
 ```"),
                 #[inline]
                 #[unstable(feature = "wrapping_int_impl", issue = "32463")]
-                pub fn count_ones(self) -> u32 {
+                pub const fn count_ones(self) -> u32 {
                     self.0.count_ones()
                 }
             }
@@ -407,7 +407,7 @@ assert_eq!(Wrapping(!0", stringify!($t), ").count_zeros(), 0);
 ```"),
                 #[inline]
                 #[unstable(feature = "wrapping_int_impl", issue = "32463")]
-                pub fn count_zeros(self) -> u32 {
+                pub const fn count_zeros(self) -> u32 {
                     self.0.count_zeros()
                 }
             }
@@ -430,7 +430,7 @@ assert_eq!(n.trailing_zeros(), 3);
 ```"),
                 #[inline]
                 #[unstable(feature = "wrapping_int_impl", issue = "32463")]
-                pub fn trailing_zeros(self) -> u32 {
+                pub const fn trailing_zeros(self) -> u32 {
                     self.0.trailing_zeros()
                 }
             }
@@ -456,7 +456,7 @@ assert_eq!(n.trailing_zeros(), 3);
             /// ```
             #[inline]
             #[unstable(feature = "wrapping_int_impl", issue = "32463")]
-            pub fn rotate_left(self, n: u32) -> Self {
+            pub const fn rotate_left(self, n: u32) -> Self {
                 Wrapping(self.0.rotate_left(n))
             }
 
@@ -481,7 +481,7 @@ assert_eq!(n.trailing_zeros(), 3);
             /// ```
             #[inline]
             #[unstable(feature = "wrapping_int_impl", issue = "32463")]
-            pub fn rotate_right(self, n: u32) -> Self {
+            pub const fn rotate_right(self, n: u32) -> Self {
                 Wrapping(self.0.rotate_right(n))
             }
 
@@ -505,7 +505,7 @@ assert_eq!(n.trailing_zeros(), 3);
             /// ```
             #[inline]
             #[unstable(feature = "wrapping_int_impl", issue = "32463")]
-            pub fn swap_bytes(self) -> Self {
+            pub const fn swap_bytes(self) -> Self {
                 Wrapping(self.0.swap_bytes())
             }
 
@@ -532,7 +532,7 @@ assert_eq!(n.trailing_zeros(), 3);
             /// ```
             #[unstable(feature = "reverse_bits", issue = "48763")]
             #[inline]
-            pub fn reverse_bits(self) -> Self {
+            pub const fn reverse_bits(self) -> Self {
                 Wrapping(self.0.reverse_bits())
             }
 
@@ -560,7 +560,7 @@ if cfg!(target_endian = \"big\") {
 ```"),
                 #[inline]
                 #[unstable(feature = "wrapping_int_impl", issue = "32463")]
-                pub fn from_be(x: Self) -> Self {
+                pub const fn from_be(x: Self) -> Self {
                     Wrapping(<$t>::from_be(x.0))
                 }
             }
@@ -589,7 +589,7 @@ if cfg!(target_endian = \"little\") {
 ```"),
                 #[inline]
                 #[unstable(feature = "wrapping_int_impl", issue = "32463")]
-                pub fn from_le(x: Self) -> Self {
+                pub const fn from_le(x: Self) -> Self {
                     Wrapping(<$t>::from_le(x.0))
                 }
             }
@@ -618,7 +618,7 @@ if cfg!(target_endian = \"big\") {
 ```"),
                 #[inline]
                 #[unstable(feature = "wrapping_int_impl", issue = "32463")]
-                pub fn to_be(self) -> Self {
+                pub const fn to_be(self) -> Self {
                     Wrapping(self.0.to_be())
                 }
             }
@@ -647,7 +647,7 @@ if cfg!(target_endian = \"little\") {
 ```"),
                 #[inline]
                 #[unstable(feature = "wrapping_int_impl", issue = "32463")]
-                pub fn to_le(self) -> Self {
+                pub const fn to_le(self) -> Self {
                     Wrapping(self.0.to_le())
                 }
             }
@@ -707,7 +707,7 @@ assert_eq!(n.leading_zeros(), 3);
 ```"),
                 #[inline]
                 #[unstable(feature = "wrapping_int_impl", issue = "32463")]
-                pub fn leading_zeros(self) -> u32 {
+                pub const fn leading_zeros(self) -> u32 {
                     self.0.leading_zeros()
                 }
             }
@@ -784,7 +784,7 @@ assert!(!Wrapping(-10", stringify!($t), ").is_positive());
 ```"),
                 #[inline]
                 #[unstable(feature = "wrapping_int_impl", issue = "32463")]
-                pub fn is_positive(self) -> bool {
+                pub const fn is_positive(self) -> bool {
                     self.0.is_positive()
                 }
             }
@@ -806,7 +806,7 @@ assert!(!Wrapping(10", stringify!($t), ").is_negative());
 ```"),
                 #[inline]
                 #[unstable(feature = "wrapping_int_impl", issue = "32463")]
-                pub fn is_negative(self) -> bool {
+                pub const fn is_negative(self) -> bool {
                     self.0.is_negative()
                 }
             }
@@ -836,7 +836,7 @@ assert_eq!(n.leading_zeros(), 2);
 ```"),
                 #[inline]
                 #[unstable(feature = "wrapping_int_impl", issue = "32463")]
-                pub fn leading_zeros(self) -> u32 {
+                pub const fn leading_zeros(self) -> u32 {
                     self.0.leading_zeros()
                 }
             }
diff --git a/src/libcore/ops/range.rs b/src/libcore/ops/range.rs
@@ -416,7 +416,7 @@ impl<Idx> RangeInclusive<Idx> {
     /// ```
     #[stable(feature = "inclusive_range_methods", since = "1.27.0")]
     #[inline]
-    pub fn start(&self) -> &Idx {
+    pub const fn start(&self) -> &Idx {
         &self.start
     }
 
@@ -440,7 +440,7 @@ impl<Idx> RangeInclusive<Idx> {
     /// ```
     #[stable(feature = "inclusive_range_methods", since = "1.27.0")]
     #[inline]
-    pub fn end(&self) -> &Idx {
+    pub const fn end(&self) -> &Idx {
         &self.end
     }
 
diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs
@@ -2905,7 +2905,7 @@ impl<T: ?Sized> NonNull<T> {
     /// Acquires the underlying `*mut` pointer.
     #[stable(feature = "nonnull", since = "1.25.0")]
     #[inline]
-    pub fn as_ptr(self) -> *mut T {
+    pub const fn as_ptr(self) -> *mut T {
         self.pointer.0 as *mut T
     }
 
diff --git a/src/libcore/slice/mod.rs b/src/libcore/slice/mod.rs
@@ -385,7 +385,6 @@ impl<T> [T] {
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
-    #[rustc_const_unstable(feature = "const_slice_as_ptr")]
     pub const fn as_ptr(&self) -> *const T {
         self as *const [T] as *const T
     }
diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs
@@ -2277,7 +2277,6 @@ impl str {
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
-    #[rustc_const_unstable(feature = "const_str_as_ptr")]
     pub const fn as_ptr(&self) -> *const u8 {
         self as *const str as *const u8
     }
diff --git a/src/libcore/time.rs b/src/libcore/time.rs
@@ -209,7 +209,6 @@ impl Duration {
     ///
     /// [`subsec_nanos`]: #method.subsec_nanos
     #[stable(feature = "duration", since = "1.3.0")]
-    #[rustc_const_unstable(feature="duration_getters")]
     #[inline]
     pub const fn as_secs(&self) -> u64 { self.secs }
 
@@ -229,7 +228,6 @@ impl Duration {
     /// assert_eq!(duration.subsec_millis(), 432);
     /// ```
     #[stable(feature = "duration_extras", since = "1.27.0")]
-    #[rustc_const_unstable(feature="duration_getters")]
     #[inline]
     pub const fn subsec_millis(&self) -> u32 { self.nanos / NANOS_PER_MILLI }
 
@@ -249,7 +247,6 @@ impl Duration {
     /// assert_eq!(duration.subsec_micros(), 234_567);
     /// ```
     #[stable(feature = "duration_extras", since = "1.27.0")]
-    #[rustc_const_unstable(feature="duration_getters")]
     #[inline]
     pub const fn subsec_micros(&self) -> u32 { self.nanos / NANOS_PER_MICRO }
 
@@ -269,7 +266,6 @@ impl Duration {
     /// assert_eq!(duration.subsec_nanos(), 10_000_000);
     /// ```
     #[stable(feature = "duration", since = "1.3.0")]
-    #[rustc_const_unstable(feature="duration_getters")]
     #[inline]
     pub const fn subsec_nanos(&self) -> u32 { self.nanos }
 
@@ -286,7 +282,7 @@ impl Duration {
     /// ```
     #[unstable(feature = "duration_as_u128", issue = "50202")]
     #[inline]
-    pub fn as_millis(&self) -> u128 {
+    pub const fn as_millis(&self) -> u128 {
         self.secs as u128 * MILLIS_PER_SEC as u128 + (self.nanos / NANOS_PER_MILLI) as u128
     }
 
@@ -303,7 +299,7 @@ impl Duration {
     /// ```
     #[unstable(feature = "duration_as_u128", issue = "50202")]
     #[inline]
-    pub fn as_micros(&self) -> u128 {
+    pub const fn as_micros(&self) -> u128 {
         self.secs as u128 * MICROS_PER_SEC as u128 + (self.nanos / NANOS_PER_MICRO) as u128
     }
 
@@ -320,7 +316,7 @@ impl Duration {
     /// ```
     #[unstable(feature = "duration_as_u128", issue = "50202")]
     #[inline]
-    pub fn as_nanos(&self) -> u128 {
+    pub const fn as_nanos(&self) -> u128 {
         self.secs as u128 * NANOS_PER_SEC as u128 + self.nanos as u128
     }
 
@@ -478,7 +474,7 @@ impl Duration {
     /// ```
     #[unstable(feature = "duration_float", issue = "54361")]
     #[inline]
-    pub fn as_float_secs(&self) -> f64 {
+    pub const fn as_float_secs(&self) -> f64 {
         (self.secs as f64) + (self.nanos as f64) / (NANOS_PER_SEC as f64)
     }
 
diff --git a/src/libcore/unicode/tables.rs b/src/libcore/unicode/tables.rs
@@ -2598,4 +2598,3 @@ pub mod conversions {
     ];
 
 }
-
diff --git a/src/libstd/ffi/c_str.rs b/src/libstd/ffi/c_str.rs
@@ -1091,7 +1091,7 @@ impl CStr {
     /// [`CString`]: struct.CString.html
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn as_ptr(&self) -> *const c_char {
+    pub const fn as_ptr(&self) -> *const c_char {
         self.inner.as_ptr()
     }
 
diff --git a/src/libstd/net/ip.rs b/src/libstd/net/ip.rs
@@ -424,7 +424,7 @@ impl Ipv4Addr {
     /// assert_eq!(Ipv4Addr::new(45, 22, 13, 197).is_unspecified(), false);
     /// ```
     #[stable(feature = "ip_shared", since = "1.12.0")]
-    pub fn is_unspecified(&self) -> bool {
+    pub const fn is_unspecified(&self) -> bool {
         self.inner.s_addr == 0
     }
 
@@ -862,7 +862,6 @@ impl Ipv6Addr {
     /// let addr = Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_const_unstable(feature = "const_ip")]
     pub const fn new(a: u16, b: u16, c: u16, d: u16, e: u16, f: u16,
                      g: u16, h: u16) -> Ipv6Addr {
         Ipv6Addr {
@@ -1224,7 +1223,7 @@ impl Ipv6Addr {
     ///            [255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
     /// ```
     #[stable(feature = "ipv6_to_octets", since = "1.12.0")]
-    pub fn octets(&self) -> [u8; 16] {
+    pub const fn octets(&self) -> [u8; 16] {
         self.inner.s6_addr
     }
 }
diff --git a/src/test/ui/consts/const-eval/duration_conversion.rs b/src/test/ui/consts/const-eval/duration_conversion.rs
@@ -10,8 +10,6 @@
 
 // compile-pass
 
-#![feature(duration_getters)]
-
 use std::time::Duration;
 
 fn main() {
diff --git a/src/test/ui/consts/const-eval/mod-static-with-const-fn.rs b/src/test/ui/consts/const-eval/mod-static-with-const-fn.rs
@@ -23,13 +23,16 @@ unsafe impl Sync for Foo {}
 
 static FOO: Foo = Foo(UnsafeCell::new(42));
 
+fn foo() {}
+
 static BAR: () = unsafe {
     *FOO.0.get() = 5;
-    //~^ ERROR calls in statics are limited to constant functions, tuple structs and tuple variants
-
+    //~^ ERROR statements in statics are unstable (see issue #48821)
     // This error is caused by a separate bug that the feature gate error is reported
     // even though the feature gate "const_let" is active.
-    //~| statements in statics are unstable (see issue #48821)
+
+    foo();
+    //~^ ERROR calls in statics are limited to constant functions, tuple structs and tuple variants
 };
 
 fn main() {
diff --git a/src/test/ui/consts/const-eval/mod-static-with-const-fn.stderr b/src/test/ui/consts/const-eval/mod-static-with-const-fn.stderr
diff --git a/src/test/ui/consts/std/cell.rs b/src/test/ui/consts/std/cell.rs
diff --git a/src/test/ui/consts/std/cell.stderr b/src/test/ui/consts/std/cell.stderr
diff --git a/src/test/ui/consts/std/char.rs b/src/test/ui/consts/std/char.rs
diff --git a/src/test/ui/consts/std/iter.rs b/src/test/ui/consts/std/iter.rs
diff --git a/src/test/ui/consts/std/slice.rs b/src/test/ui/consts/std/slice.rs
diff --git a/src/test/ui/rfc-2306/convert-id-const-no-gate.rs b/src/test/ui/rfc-2306/convert-id-const-no-gate.rs
diff --git a/src/test/ui/rfc-2306/convert-id-const-no-gate.stderr b/src/test/ui/rfc-2306/convert-id-const-no-gate.stderr
diff --git a/src/test/ui/rfc-2306/convert-id-const-with-gate.rs b/src/test/ui/rfc-2306/convert-id-const-with-gate.rs

Original file line number	Diff line number	Diff line change
`@@ -474,7 +474,7 @@ impl<T: ?Sized> Cell<T> {`
`474`	`474`	/// ```
`475`	`475`	`#[inline]`
`476`	`476`	`#[stable(feature = "cell_as_ptr", since = "1.12.0")]`
`477`		`- pub fn as_ptr(&self) -> *mut T {`
	`477`	`+ pub const fn as_ptr(&self) -> *mut T {`
`478`	`478`	`self.value.get()`
`479`	`479`	`}`
`480`	`480`
`@@ -1508,7 +1508,7 @@ impl<T: ?Sized> UnsafeCell<T> {`
`1508`	`1508`	/// ```
`1509`	`1509`	`#[inline]`
`1510`	`1510`	`#[stable(feature = "rust1", since = "1.0.0")]`
`1511`		`- pub fn get(&self) -> *mut T {`
	`1511`	`+ pub const fn get(&self) -> *mut T {`
`1512`	`1512`	`&self.value as const T as mut T`
`1513`	`1513`	`}`
`1514`	`1514`	`}`
Original file line number	Diff line number	Diff line change
`@@ -903,7 +903,7 @@ impl char {`
`903`	`903`	/// ```
`904`	`904`	`#[stable(feature = "ascii_methods_on_intrinsics", since = "1.23.0")]`
`905`	`905`	`#[inline]`
`906`		`- pub fn is_ascii(&self) -> bool {`
	`906`	`+ pub const fn is_ascii(&self) -> bool {`
`907`	`907`	`*self as u32 <= 0x7F`
`908`	`908`	`}`
`909`	`909`
Original file line number	Diff line number	Diff line change
`@@ -283,7 +283,7 @@ impl<T> Default for Empty<T> {`
`283`	`283`	`/// assert_eq!(None, nope.next());`
`284`	`284`	/// ```
`285`	`285`	`#[stable(feature = "iter_empty", since = "1.2.0")]`
`286`		`-pub fn empty<T>() -> Empty<T> {`
	`286`	`+pub const fn empty<T>() -> Empty<T> {`
`287`	`287`	`Empty(marker::PhantomData)`
`288`	`288`	`}`
`289`	`289`
Original file line number	Diff line number	Diff line change
`@@ -22,4 +22,3 @@ pub fn estimate_scaling_factor(mant: u64, exp: i16) -> i16 {`
`22`	`22`	`// therefore this always underestimates (or is exact), but not much.`
`23`	`23`	`(((nbits + exp as i64) * 1292913986) >> 32) as i16`
`24`	`24`	`}`
`25`		`-`
Original file line number	Diff line number	Diff line change
`@@ -658,4 +658,3 @@ pub fn to_exact_fixed_str<'a, T, F>(mut format_exact: F, v: T,`
`658`	`658`	`}`
`659`	`659`	`}`
`660`	`660`	`}`
`661`		`-`
Original file line number	Diff line number	Diff line change
`@@ -387,7 +387,7 @@ assert_eq!(n.count_ones(), 3);`
`387`	`387`	```"),
`388`	`388`	`#[inline]`
`389`	`389`	`#[unstable(feature = "wrapping_int_impl", issue = "32463")]`
`390`		`- pub fn count_ones(self) -> u32 {`
	`390`	`+ pub const fn count_ones(self) -> u32 {`
`391`	`391`	`self.0.count_ones()`
`392`	`392`	`}`
`393`	`393`	`}`
`@@ -407,7 +407,7 @@ assert_eq!(Wrapping(!0", stringify!($t), ").count_zeros(), 0);`
`407`	`407`	```"),
`408`	`408`	`#[inline]`
`409`	`409`	`#[unstable(feature = "wrapping_int_impl", issue = "32463")]`
`410`		`- pub fn count_zeros(self) -> u32 {`
	`410`	`+ pub const fn count_zeros(self) -> u32 {`
`411`	`411`	`self.0.count_zeros()`
`412`	`412`	`}`
`413`	`413`	`}`
`@@ -430,7 +430,7 @@ assert_eq!(n.trailing_zeros(), 3);`
`430`	`430`	```"),
`431`	`431`	`#[inline]`
`432`	`432`	`#[unstable(feature = "wrapping_int_impl", issue = "32463")]`
`433`		`- pub fn trailing_zeros(self) -> u32 {`
	`433`	`+ pub const fn trailing_zeros(self) -> u32 {`
`434`	`434`	`self.0.trailing_zeros()`
`435`	`435`	`}`
`436`	`436`	`}`
`@@ -456,7 +456,7 @@ assert_eq!(n.trailing_zeros(), 3);`
`456`	`456`	/// ```
`457`	`457`	`#[inline]`
`458`	`458`	`#[unstable(feature = "wrapping_int_impl", issue = "32463")]`
`459`		`- pub fn rotate_left(self, n: u32) -> Self {`
	`459`	`+ pub const fn rotate_left(self, n: u32) -> Self {`
`460`	`460`	`Wrapping(self.0.rotate_left(n))`
`461`	`461`	`}`
`462`	`462`
`@@ -481,7 +481,7 @@ assert_eq!(n.trailing_zeros(), 3);`
`481`	`481`	/// ```
`482`	`482`	`#[inline]`
`483`	`483`	`#[unstable(feature = "wrapping_int_impl", issue = "32463")]`
`484`		`- pub fn rotate_right(self, n: u32) -> Self {`
	`484`	`+ pub const fn rotate_right(self, n: u32) -> Self {`
`485`	`485`	`Wrapping(self.0.rotate_right(n))`
`486`	`486`	`}`
`487`	`487`
`@@ -505,7 +505,7 @@ assert_eq!(n.trailing_zeros(), 3);`
`505`	`505`	/// ```
`506`	`506`	`#[inline]`
`507`	`507`	`#[unstable(feature = "wrapping_int_impl", issue = "32463")]`
`508`		`- pub fn swap_bytes(self) -> Self {`
	`508`	`+ pub const fn swap_bytes(self) -> Self {`
`509`	`509`	`Wrapping(self.0.swap_bytes())`
`510`	`510`	`}`
`511`	`511`
`@@ -532,7 +532,7 @@ assert_eq!(n.trailing_zeros(), 3);`
`532`	`532`	/// ```
`533`	`533`	`#[unstable(feature = "reverse_bits", issue = "48763")]`
`534`	`534`	`#[inline]`
`535`		`- pub fn reverse_bits(self) -> Self {`
	`535`	`+ pub const fn reverse_bits(self) -> Self {`
`536`	`536`	`Wrapping(self.0.reverse_bits())`
`537`	`537`	`}`
`538`	`538`
`@@ -560,7 +560,7 @@ if cfg!(target_endian = \"big\") {`
`560`	`560`	```"),
`561`	`561`	`#[inline]`
`562`	`562`	`#[unstable(feature = "wrapping_int_impl", issue = "32463")]`
`563`		`- pub fn from_be(x: Self) -> Self {`
	`563`	`+ pub const fn from_be(x: Self) -> Self {`
`564`	`564`	`Wrapping(<$t>::from_be(x.0))`
`565`	`565`	`}`
`566`	`566`	`}`
`@@ -589,7 +589,7 @@ if cfg!(target_endian = \"little\") {`
`589`	`589`	```"),
`590`	`590`	`#[inline]`
`591`	`591`	`#[unstable(feature = "wrapping_int_impl", issue = "32463")]`
`592`		`- pub fn from_le(x: Self) -> Self {`
	`592`	`+ pub const fn from_le(x: Self) -> Self {`
`593`	`593`	`Wrapping(<$t>::from_le(x.0))`
`594`	`594`	`}`
`595`	`595`	`}`
`@@ -618,7 +618,7 @@ if cfg!(target_endian = \"big\") {`
`618`	`618`	```"),
`619`	`619`	`#[inline]`
`620`	`620`	`#[unstable(feature = "wrapping_int_impl", issue = "32463")]`
`621`		`- pub fn to_be(self) -> Self {`
	`621`	`+ pub const fn to_be(self) -> Self {`
`622`	`622`	`Wrapping(self.0.to_be())`
`623`	`623`	`}`
`624`	`624`	`}`
`@@ -647,7 +647,7 @@ if cfg!(target_endian = \"little\") {`
`647`	`647`	```"),
`648`	`648`	`#[inline]`
`649`	`649`	`#[unstable(feature = "wrapping_int_impl", issue = "32463")]`
`650`		`- pub fn to_le(self) -> Self {`
	`650`	`+ pub const fn to_le(self) -> Self {`
`651`	`651`	`Wrapping(self.0.to_le())`
`652`	`652`	`}`
`653`	`653`	`}`
`@@ -707,7 +707,7 @@ assert_eq!(n.leading_zeros(), 3);`
`707`	`707`	```"),
`708`	`708`	`#[inline]`
`709`	`709`	`#[unstable(feature = "wrapping_int_impl", issue = "32463")]`
`710`		`- pub fn leading_zeros(self) -> u32 {`
	`710`	`+ pub const fn leading_zeros(self) -> u32 {`
`711`	`711`	`self.0.leading_zeros()`
`712`	`712`	`}`
`713`	`713`	`}`
`@@ -784,7 +784,7 @@ assert!(!Wrapping(-10", stringify!($t), ").is_positive());`
`784`	`784`	```"),
`785`	`785`	`#[inline]`
`786`	`786`	`#[unstable(feature = "wrapping_int_impl", issue = "32463")]`
`787`		`- pub fn is_positive(self) -> bool {`
	`787`	`+ pub const fn is_positive(self) -> bool {`
`788`	`788`	`self.0.is_positive()`
`789`	`789`	`}`
`790`	`790`	`}`
`@@ -806,7 +806,7 @@ assert!(!Wrapping(10", stringify!($t), ").is_negative());`
`806`	`806`	```"),
`807`	`807`	`#[inline]`
`808`	`808`	`#[unstable(feature = "wrapping_int_impl", issue = "32463")]`
`809`		`- pub fn is_negative(self) -> bool {`
	`809`	`+ pub const fn is_negative(self) -> bool {`
`810`	`810`	`self.0.is_negative()`
`811`	`811`	`}`
`812`	`812`	`}`
`@@ -836,7 +836,7 @@ assert_eq!(n.leading_zeros(), 2);`
`836`	`836`	```"),
`837`	`837`	`#[inline]`
`838`	`838`	`#[unstable(feature = "wrapping_int_impl", issue = "32463")]`
`839`		`- pub fn leading_zeros(self) -> u32 {`
	`839`	`+ pub const fn leading_zeros(self) -> u32 {`
`840`	`840`	`self.0.leading_zeros()`
`841`	`841`	`}`
`842`	`842`	`}`