about summary refs log tree commit diff
path: root/src/libcore
diff options
context:
space:
mode:
Diffstat (limited to 'src/libcore')
-rw-r--r--src/libcore/cell.rs10
-rw-r--r--src/libcore/convert/num.rs6
-rw-r--r--src/libcore/num/mod.rs66
-rw-r--r--src/libcore/num/wrapping.rs7
-rw-r--r--src/libcore/ptr/const_ptr.rs4
-rw-r--r--src/libcore/ptr/mod.rs4
-rw-r--r--src/libcore/slice/mod.rs12
-rw-r--r--src/libcore/str/mod.rs18
-rw-r--r--src/libcore/tests/num/mod.rs32
-rw-r--r--src/libcore/tests/ptr.rs2
-rw-r--r--src/libcore/tests/slice.rs4
11 files changed, 80 insertions, 85 deletions
diff --git a/src/libcore/cell.rs b/src/libcore/cell.rs
index c4c1d2824b0..cadc2e631b0 100644
--- a/src/libcore/cell.rs
+++ b/src/libcore/cell.rs
@@ -1163,8 +1163,8 @@ impl<'b> BorrowRef<'b> {
             // Incrementing borrow can result in a non-reading value (<= 0) in these cases:
             // 1. It was < 0, i.e. there are writing borrows, so we can't allow a read borrow
             //    due to Rust's reference aliasing rules
-            // 2. It was isize::max_value() (the max amount of reading borrows) and it overflowed
-            //    into isize::min_value() (the max amount of writing borrows) so we can't allow
+            // 2. It was isize::MAX (the max amount of reading borrows) and it overflowed
+            //    into isize::MIN (the max amount of writing borrows) so we can't allow
             //    an additional read borrow because isize can't represent so many read borrows
             //    (this can only happen if you mem::forget more than a small constant amount of
             //    `Ref`s, which is not good practice)
@@ -1172,7 +1172,7 @@ impl<'b> BorrowRef<'b> {
         } else {
             // Incrementing borrow can result in a reading value (> 0) in these cases:
             // 1. It was = 0, i.e. it wasn't borrowed, and we are taking the first read borrow
-            // 2. It was > 0 and < isize::max_value(), i.e. there were read borrows, and isize
+            // 2. It was > 0 and < isize::MAX, i.e. there were read borrows, and isize
             //    is large enough to represent having one more read borrow
             borrow.set(b);
             Some(BorrowRef { borrow })
@@ -1198,7 +1198,7 @@ impl Clone for BorrowRef<'_> {
         debug_assert!(is_reading(borrow));
         // Prevent the borrow counter from overflowing into
         // a writing borrow.
-        assert!(borrow != isize::max_value());
+        assert!(borrow != isize::MAX);
         self.borrow.set(borrow + 1);
         BorrowRef { borrow: self.borrow }
     }
@@ -1489,7 +1489,7 @@ impl<'b> BorrowRefMut<'b> {
         let borrow = self.borrow.get();
         debug_assert!(is_writing(borrow));
         // Prevent the borrow counter from underflowing.
-        assert!(borrow != isize::min_value());
+        assert!(borrow != isize::MIN);
         self.borrow.set(borrow - 1);
         BorrowRefMut { borrow: self.borrow }
     }
diff --git a/src/libcore/convert/num.rs b/src/libcore/convert/num.rs
index 6dd0522f7f6..5ff52a9a11b 100644
--- a/src/libcore/convert/num.rs
+++ b/src/libcore/convert/num.rs
@@ -217,7 +217,7 @@ macro_rules! try_from_upper_bounded {
             /// is outside of the range of the target type.
             #[inline]
             fn try_from(u: $source) -> Result<Self, Self::Error> {
-                if u > (Self::max_value() as $source) {
+                if u > (Self::MAX as $source) {
                     Err(TryFromIntError(()))
                 } else {
                     Ok(u as Self)
@@ -239,8 +239,8 @@ macro_rules! try_from_both_bounded {
             /// is outside of the range of the target type.
             #[inline]
             fn try_from(u: $source) -> Result<Self, Self::Error> {
-                let min = Self::min_value() as $source;
-                let max = Self::max_value() as $source;
+                let min = Self::MIN as $source;
+                let max = Self::MAX as $source;
                 if u < min || u > max {
                     Err(TryFromIntError(()))
                 } else {
diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs
index c164e893b4f..3e5114f3361 100644
--- a/src/libcore/num/mod.rs
+++ b/src/libcore/num/mod.rs
@@ -750,9 +750,9 @@ $EndFeature, "
         }
 
         doc_comment! {
-            concat!("Unchecked integer addition. Computes `self + rhs, assuming overflow
+            concat!("Unchecked integer addition. Computes `self + rhs`, assuming overflow
 cannot occur. This results in undefined behavior when `self + rhs > ", stringify!($SelfT),
-"::max_value()` or `self + rhs < ", stringify!($SelfT), "::min_value()`."),
+"::MAX` or `self + rhs < ", stringify!($SelfT), "::MIN`."),
             #[unstable(
                 feature = "unchecked_math",
                 reason = "niche optimization path",
@@ -792,9 +792,9 @@ $EndFeature, "
         }
 
         doc_comment! {
-            concat!("Unchecked integer subtraction. Computes `self - rhs, assuming overflow
+            concat!("Unchecked integer subtraction. Computes `self - rhs`, assuming overflow
 cannot occur. This results in undefined behavior when `self - rhs > ", stringify!($SelfT),
-"::max_value()` or `self - rhs < ", stringify!($SelfT), "::min_value()`."),
+"::MAX` or `self - rhs < ", stringify!($SelfT), "::MIN`."),
             #[unstable(
                 feature = "unchecked_math",
                 reason = "niche optimization path",
@@ -834,9 +834,9 @@ $EndFeature, "
         }
 
         doc_comment! {
-            concat!("Unchecked integer multiplication. Computes `self * rhs, assuming overflow
+            concat!("Unchecked integer multiplication. Computes `self * rhs`, assuming overflow
 cannot occur. This results in undefined behavior when `self * rhs > ", stringify!($SelfT),
-"::max_value()` or `self * rhs < ", stringify!($SelfT), "::min_value()`."),
+"::MAX` or `self * rhs < ", stringify!($SelfT), "::MIN`."),
             #[unstable(
                 feature = "unchecked_math",
                 reason = "niche optimization path",
@@ -871,7 +871,7 @@ $EndFeature, "
                           without modifying the original"]
             #[inline]
             pub const fn checked_div(self, rhs: Self) -> Option<Self> {
-                if rhs == 0 || (self == Self::min_value() && rhs == -1) {
+                if rhs == 0 || (self == Self::MIN && rhs == -1) {
                     None
                 } else {
                     // SAFETY: div by zero and by INT_MIN have been checked above
@@ -900,7 +900,7 @@ assert_eq!((1", stringify!($SelfT), ").checked_div_euclid(0), None);
                           without modifying the original"]
             #[inline]
             pub const fn checked_div_euclid(self, rhs: Self) -> Option<Self> {
-                if rhs == 0 || (self == Self::min_value() && rhs == -1) {
+                if rhs == 0 || (self == Self::MIN && rhs == -1) {
                     None
                 } else {
                     Some(self.div_euclid(rhs))
@@ -929,7 +929,7 @@ $EndFeature, "
                           without modifying the original"]
             #[inline]
             pub const fn checked_rem(self, rhs: Self) -> Option<Self> {
-                if rhs == 0 || (self == Self::min_value() && rhs == -1) {
+                if rhs == 0 || (self == Self::MIN && rhs == -1) {
                     None
                 } else {
                     // SAFETY: div by zero and by INT_MIN have been checked above
@@ -957,7 +957,7 @@ assert_eq!(", stringify!($SelfT), "::MIN.checked_rem_euclid(-1), None);
                           without modifying the original"]
             #[inline]
             pub const fn checked_rem_euclid(self, rhs: Self) -> Option<Self> {
-                if rhs == 0 || (self == Self::min_value() && rhs == -1) {
+                if rhs == 0 || (self == Self::MIN && rhs == -1) {
                     None
                 } else {
                     Some(self.rem_euclid(rhs))
@@ -1236,9 +1236,9 @@ $EndFeature, "
                 match self.checked_mul(rhs) {
                     Some(x) => x,
                     None => if (self < 0) == (rhs < 0) {
-                        Self::max_value()
+                        Self::MAX
                     } else {
-                        Self::min_value()
+                        Self::MIN
                     }
                 }
             }
@@ -1267,8 +1267,8 @@ $EndFeature, "
             pub const fn saturating_pow(self, exp: u32) -> Self {
                 match self.checked_pow(exp) {
                     Some(x) => x,
-                    None if self < 0 && exp % 2 == 1 => Self::min_value(),
-                    None => Self::max_value(),
+                    None if self < 0 && exp % 2 == 1 => Self::MIN,
+                    None => Self::MAX,
                 }
             }
         }
@@ -1738,7 +1738,7 @@ $EndFeature, "
             #[must_use = "this returns the result of the operation, \
                           without modifying the original"]
             pub const fn overflowing_div(self, rhs: Self) -> (Self, bool) {
-                if self == Self::min_value() && rhs == -1 {
+                if self == Self::MIN && rhs == -1 {
                     (self, true)
                 } else {
                     (self / rhs, false)
@@ -1771,7 +1771,7 @@ assert_eq!(", stringify!($SelfT), "::MIN.overflowing_div_euclid(-1), (", stringi
             #[must_use = "this returns the result of the operation, \
                           without modifying the original"]
             pub const fn overflowing_div_euclid(self, rhs: Self) -> (Self, bool) {
-                if self == Self::min_value() && rhs == -1 {
+                if self == Self::MIN && rhs == -1 {
                     (self, true)
                 } else {
                     (self.div_euclid(rhs), false)
@@ -1805,7 +1805,7 @@ $EndFeature, "
             #[must_use = "this returns the result of the operation, \
                           without modifying the original"]
             pub const fn overflowing_rem(self, rhs: Self) -> (Self, bool) {
-                if self == Self::min_value() && rhs == -1 {
+                if self == Self::MIN && rhs == -1 {
                     (0, true)
                 } else {
                     (self % rhs, false)
@@ -1838,7 +1838,7 @@ assert_eq!(", stringify!($SelfT), "::MIN.overflowing_rem_euclid(-1), (0, true));
                           without modifying the original"]
             #[inline]
             pub const fn overflowing_rem_euclid(self, rhs: Self) -> (Self, bool) {
-                if self == Self::min_value() && rhs == -1 {
+                if self == Self::MIN && rhs == -1 {
                     (0, true)
                 } else {
                     (self.rem_euclid(rhs), false)
@@ -1869,8 +1869,8 @@ assert_eq!(", stringify!($SelfT), "::MIN.overflowing_neg(), (", stringify!($Self
             #[allow(unused_attributes)]
             #[allow_internal_unstable(const_if_match)]
             pub const fn overflowing_neg(self) -> (Self, bool) {
-                if self == Self::min_value() {
-                    (Self::min_value(), true)
+                if self == Self::MIN {
+                    (Self::MIN, true)
                 } else {
                     (-self, false)
                 }
@@ -1952,7 +1952,7 @@ $EndFeature, "
             #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
             #[inline]
             pub const fn overflowing_abs(self) -> (Self, bool) {
-                (self.wrapping_abs(), self == Self::min_value())
+                (self.wrapping_abs(), self == Self::MIN)
             }
         }
 
@@ -2986,9 +2986,9 @@ assert_eq!((", stringify!($SelfT), "::MAX - 2).checked_add(3), None);", $EndFeat
         }
 
         doc_comment! {
-            concat!("Unchecked integer addition. Computes `self + rhs, assuming overflow
+            concat!("Unchecked integer addition. Computes `self + rhs`, assuming overflow
 cannot occur. This results in undefined behavior when `self + rhs > ", stringify!($SelfT),
-"::max_value()` or `self + rhs < ", stringify!($SelfT), "::min_value()`."),
+"::MAX` or `self + rhs < ", stringify!($SelfT), "::MIN`."),
             #[unstable(
                 feature = "unchecked_math",
                 reason = "niche optimization path",
@@ -3026,9 +3026,9 @@ assert_eq!(0", stringify!($SelfT), ".checked_sub(1), None);", $EndFeature, "
         }
 
         doc_comment! {
-            concat!("Unchecked integer subtraction. Computes `self - rhs, assuming overflow
+            concat!("Unchecked integer subtraction. Computes `self - rhs`, assuming overflow
 cannot occur. This results in undefined behavior when `self - rhs > ", stringify!($SelfT),
-"::max_value()` or `self - rhs < ", stringify!($SelfT), "::min_value()`."),
+"::MAX` or `self - rhs < ", stringify!($SelfT), "::MIN`."),
             #[unstable(
                 feature = "unchecked_math",
                 reason = "niche optimization path",
@@ -3066,9 +3066,9 @@ assert_eq!(", stringify!($SelfT), "::MAX.checked_mul(2), None);", $EndFeature, "
         }
 
         doc_comment! {
-            concat!("Unchecked integer multiplication. Computes `self * rhs, assuming overflow
+            concat!("Unchecked integer multiplication. Computes `self * rhs`, assuming overflow
 cannot occur. This results in undefined behavior when `self * rhs > ", stringify!($SelfT),
-"::max_value()` or `self * rhs < ", stringify!($SelfT), "::min_value()`."),
+"::MAX` or `self * rhs < ", stringify!($SelfT), "::MIN`."),
             #[unstable(
                 feature = "unchecked_math",
                 reason = "niche optimization path",
@@ -3366,7 +3366,7 @@ assert_eq!((", stringify!($SelfT), "::MAX).saturating_mul(10), ", stringify!($Se
             pub const fn saturating_mul(self, rhs: Self) -> Self {
                 match self.checked_mul(rhs) {
                     Some(x) => x,
-                    None => Self::max_value(),
+                    None => Self::MAX,
                 }
             }
         }
@@ -3393,7 +3393,7 @@ $EndFeature, "
             pub const fn saturating_pow(self, exp: u32) -> Self {
                 match self.checked_pow(exp) {
                     Some(x) => x,
-                    None => Self::max_value(),
+                    None => Self::MAX,
                 }
             }
         }
@@ -4080,7 +4080,7 @@ Basic usage:
         }
     }
 
-            doc_comment! {
+        doc_comment! {
             concat!("Performs Euclidean division.
 
 Since, for the positive integers, all common
@@ -4178,7 +4178,7 @@ assert!(!10", stringify!($SelfT), ".is_power_of_two());", $EndFeature, "
             // (such as intel pre-haswell) have more efficient ctlz
             // intrinsics when the argument is non-zero.
             let z = unsafe { intrinsics::ctlz_nonzero(p) };
-            <$SelfT>::max_value() >> z
+            <$SelfT>::MAX >> z
         }
 
         doc_comment! {
@@ -5160,9 +5160,9 @@ trait FromStrRadixHelper: PartialOrd + Copy {
 macro_rules! doit {
     ($($t:ty)*) => ($(impl FromStrRadixHelper for $t {
         #[inline]
-        fn min_value() -> Self { Self::min_value() }
+        fn min_value() -> Self { Self::MIN }
         #[inline]
-        fn max_value() -> Self { Self::max_value() }
+        fn max_value() -> Self { Self::MAX }
         #[inline]
         fn from_u32(u: u32) -> Self { u as Self }
         #[inline]
diff --git a/src/libcore/num/wrapping.rs b/src/libcore/num/wrapping.rs
index bb648ba8c25..f6acb8f8b9a 100644
--- a/src/libcore/num/wrapping.rs
+++ b/src/libcore/num/wrapping.rs
@@ -694,7 +694,7 @@ Basic usage:
 #![feature(wrapping_int_impl)]
 use std::num::Wrapping;
 
-let n = Wrapping(", stringify!($t), "::max_value()) >> 2;
+let n = Wrapping(", stringify!($t), "::MAX) >> 2;
 
 assert_eq!(n.leading_zeros(), 3);
 ```"),
@@ -723,8 +723,7 @@ use std::num::Wrapping;
 
 assert_eq!(Wrapping(100", stringify!($t), ").abs(), Wrapping(100));
 assert_eq!(Wrapping(-100", stringify!($t), ").abs(), Wrapping(100));
-assert_eq!(Wrapping(", stringify!($t), "::min_value()).abs(), Wrapping(", stringify!($t),
-"::min_value()));
+assert_eq!(Wrapping(", stringify!($t), "::MIN).abs(), Wrapping(", stringify!($t), "::MIN));
 assert_eq!(Wrapping(-128i8).abs().0 as u8, 128u8);
 ```"),
                 #[inline]
@@ -823,7 +822,7 @@ Basic usage:
 #![feature(wrapping_int_impl)]
 use std::num::Wrapping;
 
-let n = Wrapping(", stringify!($t), "::max_value()) >> 2;
+let n = Wrapping(", stringify!($t), "::MAX) >> 2;
 
 assert_eq!(n.leading_zeros(), 2);
 ```"),
diff --git a/src/libcore/ptr/const_ptr.rs b/src/libcore/ptr/const_ptr.rs
index 835183d171a..e39d18d7733 100644
--- a/src/libcore/ptr/const_ptr.rs
+++ b/src/libcore/ptr/const_ptr.rs
@@ -291,7 +291,7 @@ impl<T: ?Sized> *const T {
         T: Sized,
     {
         let pointee_size = mem::size_of::<T>();
-        assert!(0 < pointee_size && pointee_size <= isize::max_value() as usize);
+        assert!(0 < pointee_size && pointee_size <= isize::MAX as usize);
         intrinsics::ptr_offset_from(self, origin)
     }
 
@@ -336,7 +336,7 @@ impl<T: ?Sized> *const T {
         T: Sized,
     {
         let pointee_size = mem::size_of::<T>();
-        assert!(0 < pointee_size && pointee_size <= isize::max_value() as usize);
+        assert!(0 < pointee_size && pointee_size <= isize::MAX as usize);
 
         let d = isize::wrapping_sub(self as _, origin as _);
         d.wrapping_div(pointee_size as _)
diff --git a/src/libcore/ptr/mod.rs b/src/libcore/ptr/mod.rs
index ecc70adda41..57d0008e6f8 100644
--- a/src/libcore/ptr/mod.rs
+++ b/src/libcore/ptr/mod.rs
@@ -1128,7 +1128,7 @@ pub(crate) unsafe fn align_offset<T: Sized>(p: *const T, a: usize) -> usize {
                 //
                 // Note, that we use wrapping operations here intentionally – the original formula
                 // uses e.g., subtraction `mod n`. It is entirely fine to do them `mod
-                // usize::max_value()` instead, because we take the result `mod n` at the end
+                // usize::MAX` instead, because we take the result `mod n` at the end
                 // anyway.
                 inverse = inverse.wrapping_mul(2usize.wrapping_sub(x.wrapping_mul(inverse)));
                 if going_mod >= m {
@@ -1193,7 +1193,7 @@ pub(crate) unsafe fn align_offset<T: Sized>(p: *const T, a: usize) -> usize {
     }
 
     // Cannot be aligned at all.
-    usize::max_value()
+    usize::MAX
 }
 
 /// Compares raw pointers for equality.
diff --git a/src/libcore/slice/mod.rs b/src/libcore/slice/mod.rs
index ff333f77334..8f0b662aa28 100644
--- a/src/libcore/slice/mod.rs
+++ b/src/libcore/slice/mod.rs
@@ -3043,16 +3043,12 @@ impl<T> SliceIndex<[T]> for ops::RangeInclusive<usize> {
 
     #[inline]
     fn get(self, slice: &[T]) -> Option<&[T]> {
-        if *self.end() == usize::max_value() {
-            None
-        } else {
-            (*self.start()..self.end() + 1).get(slice)
-        }
+        if *self.end() == usize::MAX { None } else { (*self.start()..self.end() + 1).get(slice) }
     }
 
     #[inline]
     fn get_mut(self, slice: &mut [T]) -> Option<&mut [T]> {
-        if *self.end() == usize::max_value() {
+        if *self.end() == usize::MAX {
             None
         } else {
             (*self.start()..self.end() + 1).get_mut(slice)
@@ -3071,7 +3067,7 @@ impl<T> SliceIndex<[T]> for ops::RangeInclusive<usize> {
 
     #[inline]
     fn index(self, slice: &[T]) -> &[T] {
-        if *self.end() == usize::max_value() {
+        if *self.end() == usize::MAX {
             slice_index_overflow_fail();
         }
         (*self.start()..self.end() + 1).index(slice)
@@ -3079,7 +3075,7 @@ impl<T> SliceIndex<[T]> for ops::RangeInclusive<usize> {
 
     #[inline]
     fn index_mut(self, slice: &mut [T]) -> &mut [T] {
-        if *self.end() == usize::max_value() {
+        if *self.end() == usize::MAX {
             slice_index_overflow_fail();
         }
         (*self.start()..self.end() + 1).index_mut(slice)
diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs
index 316c2cd55ac..6c4b28499a6 100644
--- a/src/libcore/str/mod.rs
+++ b/src/libcore/str/mod.rs
@@ -1651,7 +1651,7 @@ fn run_utf8_validation(v: &[u8]) -> Result<(), Utf8Error> {
             // Ascii case, try to skip forward quickly.
             // When the pointer is aligned, read 2 words of data per iteration
             // until we find a word containing a non-ascii byte.
-            if align != usize::max_value() && align.wrapping_sub(index) % usize_bytes == 0 {
+            if align != usize::MAX && align.wrapping_sub(index) % usize_bytes == 0 {
                 let ptr = v.as_ptr();
                 while index < blocks_end {
                     // SAFETY: since `align - index` and `ascii_block_size` are
@@ -2083,7 +2083,7 @@ mod traits {
         type Output = str;
         #[inline]
         fn get(self, slice: &str) -> Option<&Self::Output> {
-            if *self.end() == usize::max_value() {
+            if *self.end() == usize::MAX {
                 None
             } else {
                 (*self.start()..self.end() + 1).get(slice)
@@ -2091,7 +2091,7 @@ mod traits {
         }
         #[inline]
         fn get_mut(self, slice: &mut str) -> Option<&mut Self::Output> {
-            if *self.end() == usize::max_value() {
+            if *self.end() == usize::MAX {
                 None
             } else {
                 (*self.start()..self.end() + 1).get_mut(slice)
@@ -2107,14 +2107,14 @@ mod traits {
         }
         #[inline]
         fn index(self, slice: &str) -> &Self::Output {
-            if *self.end() == usize::max_value() {
+            if *self.end() == usize::MAX {
                 str_index_overflow_fail();
             }
             (*self.start()..self.end() + 1).index(slice)
         }
         #[inline]
         fn index_mut(self, slice: &mut str) -> &mut Self::Output {
-            if *self.end() == usize::max_value() {
+            if *self.end() == usize::MAX {
                 str_index_overflow_fail();
             }
             (*self.start()..self.end() + 1).index_mut(slice)
@@ -2140,11 +2140,11 @@ mod traits {
         type Output = str;
         #[inline]
         fn get(self, slice: &str) -> Option<&Self::Output> {
-            if self.end == usize::max_value() { None } else { (..self.end + 1).get(slice) }
+            if self.end == usize::MAX { None } else { (..self.end + 1).get(slice) }
         }
         #[inline]
         fn get_mut(self, slice: &mut str) -> Option<&mut Self::Output> {
-            if self.end == usize::max_value() { None } else { (..self.end + 1).get_mut(slice) }
+            if self.end == usize::MAX { None } else { (..self.end + 1).get_mut(slice) }
         }
         #[inline]
         unsafe fn get_unchecked(self, slice: &str) -> &Self::Output {
@@ -2156,14 +2156,14 @@ mod traits {
         }
         #[inline]
         fn index(self, slice: &str) -> &Self::Output {
-            if self.end == usize::max_value() {
+            if self.end == usize::MAX {
                 str_index_overflow_fail();
             }
             (..self.end + 1).index(slice)
         }
         #[inline]
         fn index_mut(self, slice: &mut str) -> &mut Self::Output {
-            if self.end == usize::max_value() {
+            if self.end == usize::MAX {
                 str_index_overflow_fail();
             }
             (..self.end + 1).index_mut(slice)
diff --git a/src/libcore/tests/num/mod.rs b/src/libcore/tests/num/mod.rs
index 181bbb8e187..939f1325c84 100644
--- a/src/libcore/tests/num/mod.rs
+++ b/src/libcore/tests/num/mod.rs
@@ -140,8 +140,8 @@ macro_rules! test_impl_from {
     ($fn_name: ident, $Small: ty, $Large: ty) => {
         #[test]
         fn $fn_name() {
-            let small_max = <$Small>::max_value();
-            let small_min = <$Small>::min_value();
+            let small_max = <$Small>::MAX;
+            let small_min = <$Small>::MIN;
             let large_max: $Large = small_max.into();
             let large_min: $Large = small_min.into();
             assert_eq!(large_max as $Small, small_max);
@@ -248,8 +248,8 @@ macro_rules! test_impl_try_from_always_ok {
     ($fn_name:ident, $source:ty, $target: ty) => {
         #[test]
         fn $fn_name() {
-            let max = <$source>::max_value();
-            let min = <$source>::min_value();
+            let max = <$source>::MAX;
+            let min = <$source>::MIN;
             let zero: $source = 0;
             assert_eq!(<$target as TryFrom<$source>>::try_from(max).unwrap(), max as $target);
             assert_eq!(<$target as TryFrom<$source>>::try_from(min).unwrap(), min as $target);
@@ -361,8 +361,8 @@ macro_rules! test_impl_try_from_signed_to_unsigned_upper_ok {
     ($fn_name:ident, $source:ty, $target:ty) => {
         #[test]
         fn $fn_name() {
-            let max = <$source>::max_value();
-            let min = <$source>::min_value();
+            let max = <$source>::MAX;
+            let min = <$source>::MIN;
             let zero: $source = 0;
             let neg_one: $source = -1;
             assert_eq!(<$target as TryFrom<$source>>::try_from(max).unwrap(), max as $target);
@@ -426,8 +426,8 @@ macro_rules! test_impl_try_from_unsigned_to_signed_upper_err {
     ($fn_name:ident, $source:ty, $target:ty) => {
         #[test]
         fn $fn_name() {
-            let max = <$source>::max_value();
-            let min = <$source>::min_value();
+            let max = <$source>::MAX;
+            let min = <$source>::MIN;
             let zero: $source = 0;
             assert!(<$target as TryFrom<$source>>::try_from(max).is_err());
             assert_eq!(<$target as TryFrom<$source>>::try_from(min).unwrap(), min as $target);
@@ -487,11 +487,11 @@ macro_rules! test_impl_try_from_same_sign_err {
     ($fn_name:ident, $source:ty, $target:ty) => {
         #[test]
         fn $fn_name() {
-            let max = <$source>::max_value();
-            let min = <$source>::min_value();
+            let max = <$source>::MAX;
+            let min = <$source>::MIN;
             let zero: $source = 0;
-            let t_max = <$target>::max_value();
-            let t_min = <$target>::min_value();
+            let t_max = <$target>::MAX;
+            let t_min = <$target>::MIN;
             assert!(<$target as TryFrom<$source>>::try_from(max).is_err());
             if min != 0 {
                 assert!(<$target as TryFrom<$source>>::try_from(min).is_err());
@@ -576,11 +576,11 @@ macro_rules! test_impl_try_from_signed_to_unsigned_err {
     ($fn_name:ident, $source:ty, $target:ty) => {
         #[test]
         fn $fn_name() {
-            let max = <$source>::max_value();
-            let min = <$source>::min_value();
+            let max = <$source>::MAX;
+            let min = <$source>::MIN;
             let zero: $source = 0;
-            let t_max = <$target>::max_value();
-            let t_min = <$target>::min_value();
+            let t_max = <$target>::MAX;
+            let t_min = <$target>::MIN;
             assert!(<$target as TryFrom<$source>>::try_from(max).is_err());
             assert!(<$target as TryFrom<$source>>::try_from(min).is_err());
             assert_eq!(<$target as TryFrom<$source>>::try_from(zero).unwrap(), zero as $target);
diff --git a/src/libcore/tests/ptr.rs b/src/libcore/tests/ptr.rs
index a008b3319f3..9fea34d668f 100644
--- a/src/libcore/tests/ptr.rs
+++ b/src/libcore/tests/ptr.rs
@@ -357,7 +357,7 @@ fn align_offset_weird_strides() {
 
     unsafe fn test_weird_stride<T>(ptr: *const T, align: usize) -> bool {
         let numptr = ptr as usize;
-        let mut expected = usize::max_value();
+        let mut expected = usize::MAX;
         // Naive but definitely correct way to find the *first* aligned element of stride::<T>.
         for el in 0..align {
             if (numptr + el * ::std::mem::size_of::<T>()) % align == 0 {
diff --git a/src/libcore/tests/slice.rs b/src/libcore/tests/slice.rs
index 54a585415bc..cd46117f763 100644
--- a/src/libcore/tests/slice.rs
+++ b/src/libcore/tests/slice.rs
@@ -1691,8 +1691,8 @@ fn test_copy_within_panics_src_inverted() {
 #[should_panic(expected = "attempted to index slice up to maximum usize")]
 fn test_copy_within_panics_src_out_of_bounds() {
     let mut bytes = *b"Hello, World!";
-    // an inclusive range ending at usize::max_value() would make src_end overflow
-    bytes.copy_within(usize::max_value()..=usize::max_value(), 0);
+    // an inclusive range ending at usize::MAX would make src_end overflow
+    bytes.copy_within(usize::MAX..=usize::MAX, 0);
 }
 
 #[test]
generated by cgit-pink 1.4.1-3-g733a5 (git 2.37.1) at 2025-10-27 07:44:48 +0000