Rollup merge of rust-lang#69860 - faern:use-assoc-int-consts, r=dtolnay

Use associated numeric consts in documentation

Now when the associated constants on int/float types are stabilized and the recommended way of accessing said constants (rust-lang#68952). We can start using it in this repository, and recommend it via documentation example code.

This PR is the reincarnation of rust-lang#67913 minus the actual adding + stabilization of said constants. (EDIT: Now it's only changing the documentation. So users will see the new consts, but we don't yet update the internal code)

Because of how fast bit rot happens to PRs that touch this many files, it does not try to replace 100% of the old usage of the constants in the entire repo, but a good chunk of them.

src/liballoc/slice.rs

@@ -432,7 +432,7 @@ impl<T> [T] {
  ///
  /// ```should_panic
  /// // this will panic at runtime
- /// b"0123456789abcdef".repeat(usize::max_value());
+ /// b"0123456789abcdef".repeat(usize::MAX);
  /// ```
  #[stable(feature = "repeat_generic_slice", since = "1.40.0")]
  pub fn repeat(&self, n: usize) -> Vec<T>

src/liballoc/str.rs

@@ -499,7 +499,7 @@ impl str {
  ///
  /// ```should_panic
  /// // this will panic at runtime
- /// "0123456789abcdef".repeat(usize::max_value());
+ /// "0123456789abcdef".repeat(usize::MAX);
  /// ```
  #[stable(feature = "repeat_str", since = "1.16.0")]
  pub fn repeat(&self, n: usize) -> String {

src/libcore/cmp.rs

@@ -817,7 +817,7 @@ pub trait PartialOrd<Rhs: ?Sized = Self>: PartialEq<Rhs> {
  /// When comparison is impossible:
  ///
  /// ```
- /// let result = std::f64::NAN.partial_cmp(&1.0);
+ /// let result = f64::NAN.partial_cmp(&1.0);
  /// assert_eq!(result, None);
  /// ```
  #[must_use]

src/libcore/fmt/mod.rs

@@ -852,7 +852,7 @@ pub trait LowerHex {
 /// }
 /// }
 ///
-/// let l = Length(i32::max_value());
+/// let l = Length(i32::MAX);
 ///
 /// assert_eq!(format!("l as hex is: {:X}", l), "l as hex is: 7FFFFFFF");
 ///

src/libcore/hint.rs

@@ -43,7 +43,7 @@ use crate::intrinsics;
 ///
 /// assert_eq!(div_1(7, 0), 7);
 /// assert_eq!(div_1(9, 1), 4);
-/// assert_eq!(div_1(11, std::u32::MAX), 0);
+/// assert_eq!(div_1(11, u32::MAX), 0);
 /// ```
 #[inline]
 #[stable(feature = "unreachable", since = "1.27.0")]

src/libcore/intrinsics.rs

@@ -1739,19 +1739,19 @@ extern "rust-intrinsic" {
  pub fn mul_with_overflow<T: Copy>(x: T, y: T) -> (T, bool);
 
  /// Performs an exact division, resulting in undefined behavior where
- /// `x % y != 0` or `y == 0` or `x == T::min_value() && y == -1`
+ /// `x % y != 0` or `y == 0` or `x == T::MIN && y == -1`
  pub fn exact_div<T: Copy>(x: T, y: T) -> T;
 
  /// Performs an unchecked division, resulting in undefined behavior
- /// where y = 0 or x = `T::min_value()` and y = -1
+ /// where y = 0 or x = `T::MIN` and y = -1
  ///
  /// The stabilized versions of this intrinsic are available on the integer
  /// primitives via the `checked_div` method. For example,
  /// [`std::u32::checked_div`](../../std/primitive.u32.html#method.checked_div)
  #[rustc_const_unstable(feature = "const_int_unchecked_arith", issue = "none")]
  pub fn unchecked_div<T: Copy>(x: T, y: T) -> T;
  /// Returns the remainder of an unchecked division, resulting in
- /// undefined behavior where y = 0 or x = `T::min_value()` and y = -1
+ /// undefined behavior where y = 0 or x = `T::MIN` and y = -1
  ///
  /// The stabilized versions of this intrinsic are available on the integer
  /// primitives via the `checked_rem` method. For example,
@@ -1777,17 +1777,17 @@ extern "rust-intrinsic" {
  pub fn unchecked_shr<T: Copy>(x: T, y: T) -> T;
 
  /// Returns the result of an unchecked addition, resulting in
- /// undefined behavior when `x + y > T::max_value()` or `x + y < T::min_value()`.
+ /// undefined behavior when `x + y > T::MAX` or `x + y < T::MIN`.
  #[rustc_const_unstable(feature = "const_int_unchecked_arith", issue = "none")]
  pub fn unchecked_add<T: Copy>(x: T, y: T) -> T;
 
  /// Returns the result of an unchecked subtraction, resulting in
- /// undefined behavior when `x - y > T::max_value()` or `x - y < T::min_value()`.
+ /// undefined behavior when `x - y > T::MAX` or `x - y < T::MIN`.
  #[rustc_const_unstable(feature = "const_int_unchecked_arith", issue = "none")]
  pub fn unchecked_sub<T: Copy>(x: T, y: T) -> T;
 
  /// Returns the result of an unchecked multiplication, resulting in
- /// undefined behavior when `x * y > T::max_value()` or `x * y < T::min_value()`.
+ /// undefined behavior when `x * y > T::MAX` or `x * y < T::MIN`.
  #[rustc_const_unstable(feature = "const_int_unchecked_arith", issue = "none")]
  pub fn unchecked_mul<T: Copy>(x: T, y: T) -> T;
 

src/libcore/iter/traits/iterator.rs

@@ -198,7 +198,7 @@ pub trait Iterator {
  /// // and the maximum possible lower bound
  /// let iter = 0..;
  ///
- /// assert_eq!((usize::max_value(), None), iter.size_hint());
+ /// assert_eq!((usize::MAX, None), iter.size_hint());
  /// ```
  #[inline]
  #[stable(feature = "rust1", since = "1.0.0")]
@@ -2920,7 +2920,7 @@ pub trait Iterator {
  /// assert_eq!([1.].iter().partial_cmp([1., 2.].iter()), Some(Ordering::Less));
  /// assert_eq!([1., 2.].iter().partial_cmp([1.].iter()), Some(Ordering::Greater));
  ///
- /// assert_eq!([std::f64::NAN].iter().partial_cmp([1.].iter()), None);
+ /// assert_eq!([f64::NAN].iter().partial_cmp([1.].iter()), None);
  /// ```
  #[stable(feature = "iter_order", since = "1.5.0")]
  fn partial_cmp<I>(self, other: I) -> Option<Ordering>
@@ -3170,7 +3170,7 @@ pub trait Iterator {
  /// assert!(![1, 3, 2, 4].iter().is_sorted());
  /// assert!([0].iter().is_sorted());
  /// assert!(std::iter::empty::<i32>().is_sorted());
- /// assert!(![0.0, 1.0, std::f32::NAN].iter().is_sorted());
+ /// assert!(![0.0, 1.0, f32::NAN].iter().is_sorted());
  /// ```
  #[inline]
  #[unstable(feature = "is_sorted", reason = "new API", issue = "53485")]
@@ -3197,7 +3197,7 @@ pub trait Iterator {
  /// assert!(![1, 3, 2, 4].iter().is_sorted_by(|a, b| a.partial_cmp(b)));
  /// assert!([0].iter().is_sorted_by(|a, b| a.partial_cmp(b)));
  /// assert!(std::iter::empty::<i32>().is_sorted_by(|a, b| a.partial_cmp(b)));
- /// assert!(![0.0, 1.0, std::f32::NAN].iter().is_sorted_by(|a, b| a.partial_cmp(b)));
+ /// assert!(![0.0, 1.0, f32::NAN].iter().is_sorted_by(|a, b| a.partial_cmp(b)));
  /// ```
  ///
  /// [`is_sorted`]: trait.Iterator.html#method.is_sorted

src/libcore/num/f32.rs

@@ -470,7 +470,7 @@ impl f32 {
  ///
  /// let value = -128.9_f32;
  /// let rounded = unsafe { value.to_int_unchecked::<i8>() };
- /// assert_eq!(rounded, std::i8::MIN);
+ /// assert_eq!(rounded, i8::MIN);
  /// ```
  ///
  /// # Safety

src/libcore/num/f64.rs

@@ -484,7 +484,7 @@ impl f64 {
  ///
  /// let value = -128.9_f32;
  /// let rounded = unsafe { value.to_int_unchecked::<i8>() };
- /// assert_eq!(rounded, std::i8::MIN);
+ /// assert_eq!(rounded, i8::MIN);
  /// ```
  ///
  /// # Safety

src/libcore/num/mod.rs

@@ -174,7 +174,7 @@ NonZeroI8 NonZeroI16 NonZeroI32 NonZeroI64 NonZeroI128 NonZeroIsize }
 /// let zero = Wrapping(0u32);
 /// let one = Wrapping(1u32);
 ///
-/// assert_eq!(std::u32::MAX, (zero - one).0);
+/// assert_eq!(u32::MAX, (zero - one).0);
 /// ```
 #[stable(feature = "rust1", since = "1.0.0")]
 #[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Default, Hash)]

src/libcore/ops/range.rs

@@ -139,10 +139,9 @@ impl<Idx: PartialOrd<Idx>> Range<Idx> {
  /// ```
  /// #![feature(range_is_empty)]
  ///
- /// use std::f32::NAN;
  /// assert!(!(3.0..5.0).is_empty());
- /// assert!( (3.0..NAN).is_empty());
- /// assert!( (NAN..5.0).is_empty());
+ /// assert!( (3.0..f32::NAN).is_empty());
+ /// assert!( (f32::NAN..5.0).is_empty());
  /// ```
  #[unstable(feature = "range_is_empty", reason = "recently added", issue = "48111")]
  pub fn is_empty(&self) -> bool {
@@ -496,10 +495,9 @@ impl<Idx: PartialOrd<Idx>> RangeInclusive<Idx> {
  /// ```
  /// #![feature(range_is_empty)]
  ///
- /// use std::f32::NAN;
  /// assert!(!(3.0..=5.0).is_empty());
- /// assert!( (3.0..=NAN).is_empty());
- /// assert!( (NAN..=5.0).is_empty());
+ /// assert!( (3.0..=f32::NAN).is_empty());
+ /// assert!( (f32::NAN..=5.0).is_empty());
  /// ```
  ///
  /// This method returns `true` after iteration has finished:

src/libcore/ptr/const_ptr.rs

@@ -659,8 +659,8 @@ impl<T: ?Sized> *const T {
  /// `align`.
  ///
  /// If it is not possible to align the pointer, the implementation returns
- /// `usize::max_value()`. It is permissible for the implementation to *always*
- /// return `usize::max_value()`. Only your algorithm's performance can depend
+ /// `usize::MAX`. It is permissible for the implementation to *always*
+ /// return `usize::MAX`. Only your algorithm's performance can depend
  /// on getting a usable offset here, not its correctness.
  ///
  /// The offset is expressed in number of `T` elements, and not bytes. The value returned can be

src/libcore/ptr/mut_ptr.rs

@@ -847,8 +847,8 @@ impl<T: ?Sized> *mut T {
  /// `align`.
  ///
  /// If it is not possible to align the pointer, the implementation returns
- /// `usize::max_value()`. It is permissible for the implementation to *always*
- /// return `usize::max_value()`. Only your algorithm's performance can depend
+ /// `usize::MAX`. It is permissible for the implementation to *always*
+ /// return `usize::MAX`. Only your algorithm's performance can depend
  /// on getting a usable offset here, not its correctness.
  ///
  /// The offset is expressed in number of `T` elements, and not bytes. The value returned can be

src/libcore/slice/mod.rs

@@ -2588,7 +2588,7 @@ impl<T> [T] {
  /// assert!(![1, 3, 2, 4].is_sorted());
  /// assert!([0].is_sorted());
  /// assert!(empty.is_sorted());
- /// assert!(![0.0, 1.0, std::f32::NAN].is_sorted());
+ /// assert!(![0.0, 1.0, f32::NAN].is_sorted());
  /// ```
  #[inline]
  #[unstable(feature = "is_sorted", reason = "new API", issue = "53485")]

src/libcore/time.rs

@@ -389,7 +389,7 @@ impl Duration {
  /// use std::time::Duration;
  ///
  /// assert_eq!(Duration::new(0, 0).checked_add(Duration::new(0, 1)), Some(Duration::new(0, 1)));
- /// assert_eq!(Duration::new(1, 0).checked_add(Duration::new(std::u64::MAX, 0)), None);
+ /// assert_eq!(Duration::new(1, 0).checked_add(Duration::new(u64::MAX, 0)), None);
  /// ```
  #[stable(feature = "duration_checked_ops", since = "1.16.0")]
  #[inline]
@@ -460,7 +460,7 @@ impl Duration {
  /// use std::time::Duration;
  ///
  /// assert_eq!(Duration::new(0, 500_000_001).checked_mul(2), Some(Duration::new(1, 2)));
- /// assert_eq!(Duration::new(std::u64::MAX - 1, 0).checked_mul(2), None);
+ /// assert_eq!(Duration::new(u64::MAX - 1, 0).checked_mul(2), None);
  /// ```
  #[stable(feature = "duration_checked_ops", since = "1.16.0")]
  #[inline]

src/librustc_target/abi/mod.rs

@@ -577,7 +577,7 @@ pub struct Scalar {
  pub value: Primitive,
 
  /// Inclusive wrap-around range of valid values, that is, if
- /// start > end, it represents `start..=max_value()`,
+ /// start > end, it represents `start..=MAX`,
  /// followed by `0..=end`.
  ///
  /// That is, for an i8 primitive, a range of `254..=2` means following

src/libstd/f32.rs

@@ -284,7 +284,7 @@ impl f32 {
  /// assert_eq!(a.rem_euclid(-b), 3.0);
  /// assert_eq!((-a).rem_euclid(-b), 1.0);
  /// // limitation due to round-off error
- /// assert!((-std::f32::EPSILON).rem_euclid(3.0) != 0.0);
+ /// assert!((-f32::EPSILON).rem_euclid(3.0) != 0.0);
  /// ```
  #[must_use = "method returns a new number and does not mutate the original value"]
  #[inline]
@@ -962,7 +962,7 @@ impl f32 {
  /// assert!((-3.0f32).clamp(-2.0, 1.0) == -2.0);
  /// assert!((0.0f32).clamp(-2.0, 1.0) == 0.0);
  /// assert!((2.0f32).clamp(-2.0, 1.0) == 1.0);
- /// assert!((std::f32::NAN).clamp(-2.0, 1.0).is_nan());
+ /// assert!((f32::NAN).clamp(-2.0, 1.0).is_nan());
  /// ```
  #[must_use = "method returns a new number and does not mutate the original value"]
  #[unstable(feature = "clamp", issue = "44095")]

src/libstd/f64.rs

@@ -280,7 +280,7 @@ impl f64 {
  /// assert_eq!(a.rem_euclid(-b), 3.0);
  /// assert_eq!((-a).rem_euclid(-b), 1.0);
  /// // limitation due to round-off error
- /// assert!((-std::f64::EPSILON).rem_euclid(3.0) != 0.0);
+ /// assert!((-f64::EPSILON).rem_euclid(3.0) != 0.0);
  /// ```
  #[must_use = "method returns a new number and does not mutate the original value"]
  #[inline]
@@ -928,7 +928,7 @@ impl f64 {
  /// assert!((-3.0f64).clamp(-2.0, 1.0) == -2.0);
  /// assert!((0.0f64).clamp(-2.0, 1.0) == 0.0);
  /// assert!((2.0f64).clamp(-2.0, 1.0) == 1.0);
- /// assert!((std::f64::NAN).clamp(-2.0, 1.0).is_nan());
+ /// assert!((f64::NAN).clamp(-2.0, 1.0).is_nan());
  /// ```
  #[must_use = "method returns a new number and does not mutate the original value"]
  #[unstable(feature = "clamp", issue = "44095")]