Remove all doc_comment!{} hacks by using #[doc = expr] where needed.

8 files changed, 4627 insertions, 5124 deletions

diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index eb474792dc4..099b98b824d 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -113,6 +113,7 @@
 #![feature(doc_spotlight)]
 #![feature(duration_consts_2)]
 #![feature(duration_saturating_ops)]
+#![feature(extended_key_value_attributes)]
 #![feature(extern_types)]
 #![feature(fundamental)]
 #![feature(intrinsics)]
diff --git a/library/core/src/num/int_macros.rs b/library/core/src/num/int_macros.rs
index 2cde5d9995b..162ed7d1b8d 100644
--- a/library/core/src/num/int_macros.rs
+++ b/library/core/src/num/int_macros.rs
@@ -1,2240 +1,2008 @@
 macro_rules! int_impl {
-    ($SelfT:ty, $ActualT:ident, $UnsignedT:ty, $BITS:expr, $Min:expr, $Max:expr, $Feature:expr,
-     $EndFeature:expr, $rot:expr, $rot_op:expr, $rot_result:expr, $swap_op:expr, $swapped:expr,
+    ($SelfT:ty, $ActualT:ident, $UnsignedT:ty, $BITS:expr, $Min:expr, $Max:expr,
+     $rot:expr, $rot_op:expr, $rot_result:expr, $swap_op:expr, $swapped:expr,
      $reversed:expr, $le_bytes:expr, $be_bytes:expr,
      $to_xe_bytes_doc:expr, $from_xe_bytes_doc:expr) => {
-        doc_comment! {
-            concat!("The smallest value that can be represented by this integer type.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(", stringify!($SelfT), "::MIN, ", stringify!($Min), ");",
-$EndFeature, "
-```"),
-            #[stable(feature = "assoc_int_consts", since = "1.43.0")]
-            pub const MIN: Self = !0 ^ ((!0 as $UnsignedT) >> 1) as Self;
-        }
-
-        doc_comment! {
-            concat!("The largest value that can be represented by this integer type.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(", stringify!($SelfT), "::MAX, ", stringify!($Max), ");",
-$EndFeature, "
-```"),
-            #[stable(feature = "assoc_int_consts", since = "1.43.0")]
-            pub const MAX: Self = !Self::MIN;
-        }
-
-        doc_comment! {
-            concat!("The size of this integer type in bits.
-
-# Examples
-
-```
-", $Feature, "#![feature(int_bits_const)]
-assert_eq!(", stringify!($SelfT), "::BITS, ", stringify!($BITS), ");",
-$EndFeature, "
-```"),
-            #[unstable(feature = "int_bits_const", issue = "76904")]
-            pub const BITS: u32 = $BITS;
-        }
-
-        doc_comment! {
-            concat!("Converts a string slice in a given base to an integer.
-
-The string is expected to be an optional `+` or `-` sign followed by digits.
-Leading and trailing whitespace represent an error. Digits are a subset of these characters,
-depending on `radix`:
-
- * `0-9`
- * `a-z`
- * `A-Z`
-
-# Panics
-
-This function panics if `radix` is not in the range from 2 to 36.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(", stringify!($SelfT), "::from_str_radix(\"A\", 16), Ok(10));",
-$EndFeature, "
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            pub fn from_str_radix(src: &str, radix: u32) -> Result<Self, ParseIntError> {
-                from_str_radix(src, radix)
-            }
-        }
-
-        doc_comment! {
-            concat!("Returns the number of ones in the binary representation of `self`.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "let n = 0b100_0000", stringify!($SelfT), ";
-
-assert_eq!(n.count_ones(), 1);",
-$EndFeature, "
-```
-"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
-            #[doc(alias = "popcount")]
-            #[doc(alias = "popcnt")]
-            #[inline]
-            pub const fn count_ones(self) -> u32 { (self as $UnsignedT).count_ones() }
-        }
-
-        doc_comment! {
-            concat!("Returns the number of zeros in the binary representation of `self`.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(", stringify!($SelfT), "::MAX.count_zeros(), 1);", $EndFeature, "
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
-            #[inline]
-            pub const fn count_zeros(self) -> u32 {
-                (!self).count_ones()
-            }
-        }
-
-        doc_comment! {
-            concat!("Returns the number of leading zeros in the binary representation of `self`.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "let n = -1", stringify!($SelfT), ";
-
-assert_eq!(n.leading_zeros(), 0);",
-$EndFeature, "
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
-            #[inline]
-            pub const fn leading_zeros(self) -> u32 {
-                (self as $UnsignedT).leading_zeros()
-            }
-        }
-
-        doc_comment! {
-            concat!("Returns the number of trailing zeros in the binary representation of `self`.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "let n = -4", stringify!($SelfT), ";
-
-assert_eq!(n.trailing_zeros(), 2);",
-$EndFeature, "
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
-            #[inline]
-            pub const fn trailing_zeros(self) -> u32 {
-                (self as $UnsignedT).trailing_zeros()
-            }
-        }
-
-        doc_comment! {
-            concat!("Returns the number of leading ones in the binary representation of `self`.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "let n = -1", stringify!($SelfT), ";
-
-assert_eq!(n.leading_ones(), ", stringify!($BITS), ");",
-$EndFeature, "
-```"),
-            #[stable(feature = "leading_trailing_ones", since = "1.46.0")]
-            #[rustc_const_stable(feature = "leading_trailing_ones", since = "1.46.0")]
-            #[inline]
-            pub const fn leading_ones(self) -> u32 {
-                (self as $UnsignedT).leading_ones()
-            }
-        }
-
-        doc_comment! {
-            concat!("Returns the number of trailing ones in the binary representation of `self`.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "let n = 3", stringify!($SelfT), ";
-
-assert_eq!(n.trailing_ones(), 2);",
-$EndFeature, "
-```"),
-            #[stable(feature = "leading_trailing_ones", since = "1.46.0")]
-            #[rustc_const_stable(feature = "leading_trailing_ones", since = "1.46.0")]
-            #[inline]
-            pub const fn trailing_ones(self) -> u32 {
-                (self as $UnsignedT).trailing_ones()
-            }
-        }
-
-        doc_comment! {
-            concat!("Shifts the bits to the left by a specified amount, `n`,
-wrapping the truncated bits to the end of the resulting integer.
-
-Please note this isn't the same operation as the `<<` shifting operator!
-
-# Examples
-
-Basic usage:
-
-```
-let n = ", $rot_op, stringify!($SelfT), ";
-let m = ", $rot_result, ";
-
-assert_eq!(n.rotate_left(", $rot, "), m);
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn rotate_left(self, n: u32) -> Self {
-                (self as $UnsignedT).rotate_left(n) as Self
-            }
-        }
-
-        doc_comment! {
-            concat!("Shifts the bits to the right by a specified amount, `n`,
-wrapping the truncated bits to the beginning of the resulting
-integer.
-
-Please note this isn't the same operation as the `>>` shifting operator!
-
-# Examples
-
-Basic usage:
-
-```
-let n = ", $rot_result, stringify!($SelfT), ";
-let m = ", $rot_op, ";
-
-assert_eq!(n.rotate_right(", $rot, "), m);
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn rotate_right(self, n: u32) -> Self {
-                (self as $UnsignedT).rotate_right(n) as Self
-            }
-        }
-
-        doc_comment! {
-            concat!("Reverses the byte order of the integer.
-
-# Examples
-
-Basic usage:
-
-```
-let n = ", $swap_op, stringify!($SelfT), ";
-
-let m = n.swap_bytes();
-
-assert_eq!(m, ", $swapped, ");
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
-            #[inline]
-            pub const fn swap_bytes(self) -> Self {
-                (self as $UnsignedT).swap_bytes() as Self
-            }
-        }
-
-        doc_comment! {
-            concat!("Reverses the order of bits in the integer. The least significant bit becomes the most significant bit,
-                second least-significant bit becomes second most-significant bit, etc.
-
-# Examples
-
-Basic usage:
-
-```
-let n = ", $swap_op, stringify!($SelfT), ";
-let m = n.reverse_bits();
-
-assert_eq!(m, ", $reversed, ");
-assert_eq!(0, 0", stringify!($SelfT), ".reverse_bits());
-```"),
-            #[stable(feature = "reverse_bits", since = "1.37.0")]
-            #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
-            #[inline]
-            #[must_use]
-            pub const fn reverse_bits(self) -> Self {
-                (self as $UnsignedT).reverse_bits() as Self
-            }
-        }
-
-        doc_comment! {
-            concat!("Converts an integer from big endian to the target's endianness.
-
-On big endian this is a no-op. On little endian the bytes are swapped.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "let n = 0x1A", stringify!($SelfT), ";
-
-if cfg!(target_endian = \"big\") {
-    assert_eq!(", stringify!($SelfT), "::from_be(n), n)
-} else {
-    assert_eq!(", stringify!($SelfT), "::from_be(n), n.swap_bytes())
-}",
-$EndFeature, "
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_int_conversions", since = "1.32.0")]
-            #[inline]
-            pub const fn from_be(x: Self) -> Self {
-                #[cfg(target_endian = "big")]
-                {
-                    x
-                }
-                #[cfg(not(target_endian = "big"))]
-                {
-                    x.swap_bytes()
+        /// The smallest value that can be represented by this integer type.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MIN, ", stringify!($Min), ");")]
+        /// ```
+        #[stable(feature = "assoc_int_consts", since = "1.43.0")]
+        pub const MIN: Self = !0 ^ ((!0 as $UnsignedT) >> 1) as Self;
+
+        /// The largest value that can be represented by this integer type.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MAX, ", stringify!($Max), ");")]
+        /// ```
+        #[stable(feature = "assoc_int_consts", since = "1.43.0")]
+        pub const MAX: Self = !Self::MIN;
+
+        /// The size of this integer type in bits.
+        ///
+        /// # Examples
+        ///
+        /// ```
+        /// #![feature(int_bits_const)]
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::BITS, ", stringify!($BITS), ");")]
+        /// ```
+        #[unstable(feature = "int_bits_const", issue = "76904")]
+        pub const BITS: u32 = $BITS;
+
+        /// Converts a string slice in a given base to an integer.
+        ///
+        /// The string is expected to be an optional `+` or `-` sign followed by digits.
+        /// Leading and trailing whitespace represent an error. Digits are a subset of these characters,
+        /// depending on `radix`:
+        ///
+        ///  * `0-9`
+        ///  * `a-z`
+        ///  * `A-Z`
+        ///
+        /// # Panics
+        ///
+        /// This function panics if `radix` is not in the range from 2 to 36.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::from_str_radix(\"A\", 16), Ok(10));")]
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        pub fn from_str_radix(src: &str, radix: u32) -> Result<Self, ParseIntError> {
+            from_str_radix(src, radix)
+        }
+
+        /// Returns the number of ones in the binary representation of `self`.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("let n = 0b100_0000", stringify!($SelfT), ";")]
+        ///
+        /// assert_eq!(n.count_ones(), 1);
+        /// ```
+        ///
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
+        #[doc(alias = "popcount")]
+        #[doc(alias = "popcnt")]
+        #[inline]
+        pub const fn count_ones(self) -> u32 { (self as $UnsignedT).count_ones() }
+
+        /// Returns the number of zeros in the binary representation of `self`.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MAX.count_zeros(), 1);")]
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
+        #[inline]
+        pub const fn count_zeros(self) -> u32 {
+            (!self).count_ones()
+        }
+
+        /// Returns the number of leading zeros in the binary representation of `self`.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("let n = -1", stringify!($SelfT), ";")]
+        ///
+        /// assert_eq!(n.leading_zeros(), 0);
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
+        #[inline]
+        pub const fn leading_zeros(self) -> u32 {
+            (self as $UnsignedT).leading_zeros()
+        }
+
+        /// Returns the number of trailing zeros in the binary representation of `self`.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("let n = -4", stringify!($SelfT), ";")]
+        ///
+        /// assert_eq!(n.trailing_zeros(), 2);
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
+        #[inline]
+        pub const fn trailing_zeros(self) -> u32 {
+            (self as $UnsignedT).trailing_zeros()
+        }
+
+        /// Returns the number of leading ones in the binary representation of `self`.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("let n = -1", stringify!($SelfT), ";")]
+        ///
+        #[doc = concat!("assert_eq!(n.leading_ones(), ", stringify!($BITS), ");")]
+        /// ```
+        #[stable(feature = "leading_trailing_ones", since = "1.46.0")]
+        #[rustc_const_stable(feature = "leading_trailing_ones", since = "1.46.0")]
+        #[inline]
+        pub const fn leading_ones(self) -> u32 {
+            (self as $UnsignedT).leading_ones()
+        }
+
+        /// Returns the number of trailing ones in the binary representation of `self`.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("let n = 3", stringify!($SelfT), ";")]
+        ///
+        /// assert_eq!(n.trailing_ones(), 2);
+        /// ```
+        #[stable(feature = "leading_trailing_ones", since = "1.46.0")]
+        #[rustc_const_stable(feature = "leading_trailing_ones", since = "1.46.0")]
+        #[inline]
+        pub const fn trailing_ones(self) -> u32 {
+            (self as $UnsignedT).trailing_ones()
+        }
+
+        /// Shifts the bits to the left by a specified amount, `n`,
+        /// wrapping the truncated bits to the end of the resulting integer.
+        ///
+        /// Please note this isn't the same operation as the `<<` shifting operator!
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("let n = ", $rot_op, stringify!($SelfT), ";")]
+        #[doc = concat!("let m = ", $rot_result, ";")]
+        ///
+        #[doc = concat!("assert_eq!(n.rotate_left(", $rot, "), m);")]
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn rotate_left(self, n: u32) -> Self {
+            (self as $UnsignedT).rotate_left(n) as Self
+        }
+
+        /// Shifts the bits to the right by a specified amount, `n`,
+        /// wrapping the truncated bits to the beginning of the resulting
+        /// integer.
+        ///
+        /// Please note this isn't the same operation as the `>>` shifting operator!
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("let n = ", $rot_result, stringify!($SelfT), ";")]
+        #[doc = concat!("let m = ", $rot_op, ";")]
+        ///
+        #[doc = concat!("assert_eq!(n.rotate_right(", $rot, "), m);")]
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn rotate_right(self, n: u32) -> Self {
+            (self as $UnsignedT).rotate_right(n) as Self
+        }
+
+        /// Reverses the byte order of the integer.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("let n = ", $swap_op, stringify!($SelfT), ";")]
+        ///
+        /// let m = n.swap_bytes();
+        ///
+        #[doc = concat!("assert_eq!(m, ", $swapped, ");")]
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
+        #[inline]
+        pub const fn swap_bytes(self) -> Self {
+            (self as $UnsignedT).swap_bytes() as Self
+        }
+
+        /// Reverses the order of bits in the integer. The least significant bit becomes the most significant bit,
+        ///                 second least-significant bit becomes second most-significant bit, etc.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("let n = ", $swap_op, stringify!($SelfT), ";")]
+        /// let m = n.reverse_bits();
+        ///
+        #[doc = concat!("assert_eq!(m, ", $reversed, ");")]
+        #[doc = concat!("assert_eq!(0, 0", stringify!($SelfT), ".reverse_bits());")]
+        /// ```
+        #[stable(feature = "reverse_bits", since = "1.37.0")]
+        #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
+        #[inline]
+        #[must_use]
+        pub const fn reverse_bits(self) -> Self {
+            (self as $UnsignedT).reverse_bits() as Self
+        }
+
+        /// Converts an integer from big endian to the target's endianness.
+        ///
+        /// On big endian this is a no-op. On little endian the bytes are swapped.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("let n = 0x1A", stringify!($SelfT), ";")]
+        ///
+        /// if cfg!(target_endian = "big") {
+        #[doc = concat!("    assert_eq!(", stringify!($SelfT), "::from_be(n), n)")]
+        /// } else {
+        #[doc = concat!("    assert_eq!(", stringify!($SelfT), "::from_be(n), n.swap_bytes())")]
+        /// }
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_int_conversions", since = "1.32.0")]
+        #[inline]
+        pub const fn from_be(x: Self) -> Self {
+            #[cfg(target_endian = "big")]
+            {
+                x
+            }
+            #[cfg(not(target_endian = "big"))]
+            {
+                x.swap_bytes()
+            }
+        }
+
+        /// Converts an integer from little endian to the target's endianness.
+        ///
+        /// On little endian this is a no-op. On big endian the bytes are swapped.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("let n = 0x1A", stringify!($SelfT), ";")]
+        ///
+        /// if cfg!(target_endian = "little") {
+        #[doc = concat!("    assert_eq!(", stringify!($SelfT), "::from_le(n), n)")]
+        /// } else {
+        #[doc = concat!("    assert_eq!(", stringify!($SelfT), "::from_le(n), n.swap_bytes())")]
+        /// }
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_int_conversions", since = "1.32.0")]
+        #[inline]
+        pub const fn from_le(x: Self) -> Self {
+            #[cfg(target_endian = "little")]
+            {
+                x
+            }
+            #[cfg(not(target_endian = "little"))]
+            {
+                x.swap_bytes()
+            }
+        }
+
+        /// Converts `self` to big endian from the target's endianness.
+        ///
+        /// On big endian this is a no-op. On little endian the bytes are swapped.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("let n = 0x1A", stringify!($SelfT), ";")]
+        ///
+        /// if cfg!(target_endian = "big") {
+        ///     assert_eq!(n.to_be(), n)
+        /// } else {
+        ///     assert_eq!(n.to_be(), n.swap_bytes())
+        /// }
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_int_conversions", since = "1.32.0")]
+        #[inline]
+        pub const fn to_be(self) -> Self { // or not to be?
+            #[cfg(target_endian = "big")]
+            {
+                self
+            }
+            #[cfg(not(target_endian = "big"))]
+            {
+                self.swap_bytes()
+            }
+        }
+
+        /// Converts `self` to little endian from the target's endianness.
+        ///
+        /// On little endian this is a no-op. On big endian the bytes are swapped.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("let n = 0x1A", stringify!($SelfT), ";")]
+        ///
+        /// if cfg!(target_endian = "little") {
+        ///     assert_eq!(n.to_le(), n)
+        /// } else {
+        ///     assert_eq!(n.to_le(), n.swap_bytes())
+        /// }
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_int_conversions", since = "1.32.0")]
+        #[inline]
+        pub const fn to_le(self) -> Self {
+            #[cfg(target_endian = "little")]
+            {
+                self
+            }
+            #[cfg(not(target_endian = "little"))]
+            {
+                self.swap_bytes()
+            }
+        }
+
+        /// Checked integer addition. Computes `self + rhs`, returning `None`
+        /// if overflow occurred.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!((", stringify!($SelfT), "::MAX - 2).checked_add(1), Some(", stringify!($SelfT), "::MAX - 1));")]
+        #[doc = concat!("assert_eq!((", stringify!($SelfT), "::MAX - 2).checked_add(3), None);")]
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_checked_int_methods", since = "1.47.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn checked_add(self, rhs: Self) -> Option<Self> {
+            let (a, b) = self.overflowing_add(rhs);
+            if unlikely!(b) {None} else {Some(a)}
+        }
+
+        /// Unchecked integer addition. Computes `self + rhs`, assuming overflow
+        /// cannot occur. This results in undefined behavior when
+        #[doc = concat!("`self + rhs > ", stringify!($SelfT), "::MAX` or `self + rhs < ", stringify!($SelfT), "::MIN`.")]
+        #[unstable(
+            feature = "unchecked_math",
+            reason = "niche optimization path",
+            issue = "none",
+        )]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub unsafe fn unchecked_add(self, rhs: Self) -> Self {
+            // SAFETY: the caller must uphold the safety contract for
+            // `unchecked_add`.
+            unsafe { intrinsics::unchecked_add(self, rhs) }
+        }
+
+        /// Checked integer subtraction. Computes `self - rhs`, returning `None` if
+        /// overflow occurred.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!((", stringify!($SelfT), "::MIN + 2).checked_sub(1), Some(", stringify!($SelfT), "::MIN + 1));")]
+        #[doc = concat!("assert_eq!((", stringify!($SelfT), "::MIN + 2).checked_sub(3), None);")]
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_checked_int_methods", since = "1.47.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn checked_sub(self, rhs: Self) -> Option<Self> {
+            let (a, b) = self.overflowing_sub(rhs);
+            if unlikely!(b) {None} else {Some(a)}
+        }
+
+        /// Unchecked integer subtraction. Computes `self - rhs`, assuming overflow
+        /// cannot occur. This results in undefined behavior when
+        #[doc = concat!("`self - rhs > ", stringify!($SelfT), "::MAX` or `self - rhs < ", stringify!($SelfT), "::MIN`.")]
+        #[unstable(
+            feature = "unchecked_math",
+            reason = "niche optimization path",
+            issue = "none",
+        )]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub unsafe fn unchecked_sub(self, rhs: Self) -> Self {
+            // SAFETY: the caller must uphold the safety contract for
+            // `unchecked_sub`.
+            unsafe { intrinsics::unchecked_sub(self, rhs) }
+        }
+
+        /// Checked integer multiplication. Computes `self * rhs`, returning `None` if
+        /// overflow occurred.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MAX.checked_mul(1), Some(", stringify!($SelfT), "::MAX));")]
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MAX.checked_mul(2), None);")]
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_checked_int_methods", since = "1.47.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn checked_mul(self, rhs: Self) -> Option<Self> {
+            let (a, b) = self.overflowing_mul(rhs);
+            if unlikely!(b) {None} else {Some(a)}
+        }
+
+        /// Unchecked integer multiplication. Computes `self * rhs`, assuming overflow
+        /// cannot occur. This results in undefined behavior when
+        #[doc = concat!("`self * rhs > ", stringify!($SelfT), "::MAX` or `self * rhs < ", stringify!($SelfT), "::MIN`.")]
+        #[unstable(
+            feature = "unchecked_math",
+            reason = "niche optimization path",
+            issue = "none",
+        )]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub unsafe fn unchecked_mul(self, rhs: Self) -> Self {
+            // SAFETY: the caller must uphold the safety contract for
+            // `unchecked_mul`.
+            unsafe { intrinsics::unchecked_mul(self, rhs) }
+        }
+
+        /// Checked integer division. Computes `self / rhs`, returning `None` if `rhs == 0`
+        /// or the division results in overflow.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!((", stringify!($SelfT), "::MIN + 1).checked_div(-1), Some(", stringify!($Max), "));")]
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MIN.checked_div(-1), None);")]
+        #[doc = concat!("assert_eq!((1", stringify!($SelfT), ").checked_div(0), None);")]
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_unstable(feature = "const_checked_int_methods", issue = "53718")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn checked_div(self, rhs: Self) -> Option<Self> {
+            if unlikely!(rhs == 0 || (self == Self::MIN && rhs == -1)) {
+                None
+            } else {
+                // SAFETY: div by zero and by INT_MIN have been checked above
+                Some(unsafe { intrinsics::unchecked_div(self, rhs) })
+            }
+        }
+
+        /// Checked Euclidean division. Computes `self.div_euclid(rhs)`,
+        /// returning `None` if `rhs == 0` or the division results in overflow.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!((", stringify!($SelfT), "::MIN + 1).checked_div_euclid(-1), Some(", stringify!($Max), "));")]
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MIN.checked_div_euclid(-1), None);")]
+        #[doc = concat!("assert_eq!((1", stringify!($SelfT), ").checked_div_euclid(0), None);")]
+        /// ```
+        #[stable(feature = "euclidean_division", since = "1.38.0")]
+        #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn checked_div_euclid(self, rhs: Self) -> Option<Self> {
+            if unlikely!(rhs == 0 || (self == Self::MIN && rhs == -1)) {
+                None
+            } else {
+                Some(self.div_euclid(rhs))
+            }
+        }
+
+        /// Checked integer remainder. Computes `self % rhs`, returning `None` if
+        /// `rhs == 0` or the division results in overflow.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        ///
+        #[doc = concat!("assert_eq!(5", stringify!($SelfT), ".checked_rem(2), Some(1));")]
+        #[doc = concat!("assert_eq!(5", stringify!($SelfT), ".checked_rem(0), None);")]
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MIN.checked_rem(-1), None);")]
+        /// ```
+        #[stable(feature = "wrapping", since = "1.7.0")]
+        #[rustc_const_unstable(feature = "const_checked_int_methods", issue = "53718")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn checked_rem(self, rhs: Self) -> Option<Self> {
+            if unlikely!(rhs == 0 || (self == Self::MIN && rhs == -1)) {
+                None
+            } else {
+                // SAFETY: div by zero and by INT_MIN have been checked above
+                Some(unsafe { intrinsics::unchecked_rem(self, rhs) })
+            }
+        }
+
+        /// Checked Euclidean remainder. Computes `self.rem_euclid(rhs)`, returning `None`
+        /// if `rhs == 0` or the division results in overflow.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(5", stringify!($SelfT), ".checked_rem_euclid(2), Some(1));")]
+        #[doc = concat!("assert_eq!(5", stringify!($SelfT), ".checked_rem_euclid(0), None);")]
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MIN.checked_rem_euclid(-1), None);")]
+        /// ```
+        #[stable(feature = "euclidean_division", since = "1.38.0")]
+        #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn checked_rem_euclid(self, rhs: Self) -> Option<Self> {
+            if unlikely!(rhs == 0 || (self == Self::MIN && rhs == -1)) {
+                None
+            } else {
+                Some(self.rem_euclid(rhs))
+            }
+        }
+
+        /// Checked negation. Computes `-self`, returning `None` if `self == MIN`.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        ///
+        #[doc = concat!("assert_eq!(5", stringify!($SelfT), ".checked_neg(), Some(-5));")]
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MIN.checked_neg(), None);")]
+        /// ```
+        #[stable(feature = "wrapping", since = "1.7.0")]
+        #[rustc_const_stable(feature = "const_checked_int_methods", since = "1.47.0")]
+        #[inline]
+        pub const fn checked_neg(self) -> Option<Self> {
+            let (a, b) = self.overflowing_neg();
+            if unlikely!(b) {None} else {Some(a)}
+        }
+
+        /// Checked shift left. Computes `self << rhs`, returning `None` if `rhs` is larger
+        /// than or equal to the number of bits in `self`.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(0x1", stringify!($SelfT), ".checked_shl(4), Some(0x10));")]
+        #[doc = concat!("assert_eq!(0x1", stringify!($SelfT), ".checked_shl(129), None);")]
+        /// ```
+        #[stable(feature = "wrapping", since = "1.7.0")]
+        #[rustc_const_stable(feature = "const_checked_int_methods", since = "1.47.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn checked_shl(self, rhs: u32) -> Option<Self> {
+            let (a, b) = self.overflowing_shl(rhs);
+            if unlikely!(b) {None} else {Some(a)}
+        }
+
+        /// Checked shift right. Computes `self >> rhs`, returning `None` if `rhs` is
+        /// larger than or equal to the number of bits in `self`.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".checked_shr(4), Some(0x1));")]
+        #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".checked_shr(128), None);")]
+        /// ```
+        #[stable(feature = "wrapping", since = "1.7.0")]
+        #[rustc_const_stable(feature = "const_checked_int_methods", since = "1.47.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn checked_shr(self, rhs: u32) -> Option<Self> {
+            let (a, b) = self.overflowing_shr(rhs);
+            if unlikely!(b) {None} else {Some(a)}
+        }
+
+        /// Checked absolute value. Computes `self.abs()`, returning `None` if
+        /// `self == MIN`.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        ///
+        #[doc = concat!("assert_eq!((-5", stringify!($SelfT), ").checked_abs(), Some(5));")]
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MIN.checked_abs(), None);")]
+        /// ```
+        #[stable(feature = "no_panic_abs", since = "1.13.0")]
+        #[rustc_const_stable(feature = "const_checked_int_methods", since = "1.47.0")]
+        #[inline]
+        pub const fn checked_abs(self) -> Option<Self> {
+            if self.is_negative() {
+                self.checked_neg()
+            } else {
+                Some(self)
+            }
+        }
+
+        /// Checked exponentiation. Computes `self.pow(exp)`, returning `None` if
+        /// overflow occurred.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(8", stringify!($SelfT), ".checked_pow(2), Some(64));")]
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MAX.checked_pow(2), None);")]
+        /// ```
+
+        #[stable(feature = "no_panic_pow", since = "1.34.0")]
+        #[rustc_const_stable(feature = "const_int_pow", since = "1.50.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn checked_pow(self, mut exp: u32) -> Option<Self> {
+            if exp == 0 {
+                return Some(1);
+            }
+            let mut base = self;
+            let mut acc: Self = 1;
+
+            while exp > 1 {
+                if (exp & 1) == 1 {
+                    acc = try_opt!(acc.checked_mul(base));
                 }
-            }
-        }
-
-        doc_comment! {
-            concat!("Converts an integer from little endian to the target's endianness.
-
-On little endian this is a no-op. On big endian the bytes are swapped.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "let n = 0x1A", stringify!($SelfT), ";
-
-if cfg!(target_endian = \"little\") {
-    assert_eq!(", stringify!($SelfT), "::from_le(n), n)
-} else {
-    assert_eq!(", stringify!($SelfT), "::from_le(n), n.swap_bytes())
-}",
-$EndFeature, "
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_int_conversions", since = "1.32.0")]
-            #[inline]
-            pub const fn from_le(x: Self) -> Self {
-                #[cfg(target_endian = "little")]
-                {
-                    x
-                }
-                #[cfg(not(target_endian = "little"))]
-                {
-                    x.swap_bytes()
-                }
-            }
-        }
-
-        doc_comment! {
-            concat!("Converts `self` to big endian from the target's endianness.
-
-On big endian this is a no-op. On little endian the bytes are swapped.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "let n = 0x1A", stringify!($SelfT), ";
-
-if cfg!(target_endian = \"big\") {
-    assert_eq!(n.to_be(), n)
-} else {
-    assert_eq!(n.to_be(), n.swap_bytes())
-}",
-$EndFeature, "
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_int_conversions", since = "1.32.0")]
-            #[inline]
-            pub const fn to_be(self) -> Self { // or not to be?
-                #[cfg(target_endian = "big")]
-                {
-                    self
-                }
-                #[cfg(not(target_endian = "big"))]
-                {
-                    self.swap_bytes()
-                }
-            }
-        }
-
-        doc_comment! {
-            concat!("Converts `self` to little endian from the target's endianness.
-
-On little endian this is a no-op. On big endian the bytes are swapped.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "let n = 0x1A", stringify!($SelfT), ";
-
-if cfg!(target_endian = \"little\") {
-    assert_eq!(n.to_le(), n)
-} else {
-    assert_eq!(n.to_le(), n.swap_bytes())
-}",
-$EndFeature, "
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_int_conversions", since = "1.32.0")]
-            #[inline]
-            pub const fn to_le(self) -> Self {
-                #[cfg(target_endian = "little")]
-                {
-                    self
-                }
-                #[cfg(not(target_endian = "little"))]
-                {
-                    self.swap_bytes()
-                }
-            }
-        }
-
-        doc_comment! {
-            concat!("Checked integer addition. Computes `self + rhs`, returning `None`
-if overflow occurred.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!((", stringify!($SelfT),
-"::MAX - 2).checked_add(1), Some(", stringify!($SelfT), "::MAX - 1));
-assert_eq!((", stringify!($SelfT), "::MAX - 2).checked_add(3), None);",
-$EndFeature, "
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_checked_int_methods", since = "1.47.0")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn checked_add(self, rhs: Self) -> Option<Self> {
-                let (a, b) = self.overflowing_add(rhs);
-                if unlikely!(b) {None} else {Some(a)}
-            }
-        }
-
-        doc_comment! {
-            concat!("Unchecked integer addition. Computes `self + rhs`, assuming overflow
-cannot occur. This results in undefined behavior when `self + rhs > ", stringify!($SelfT),
-"::MAX` or `self + rhs < ", stringify!($SelfT), "::MIN`."),
-            #[unstable(
-                feature = "unchecked_math",
-                reason = "niche optimization path",
-                issue = "none",
-            )]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub unsafe fn unchecked_add(self, rhs: Self) -> Self {
-                // SAFETY: the caller must uphold the safety contract for
-                // `unchecked_add`.
-                unsafe { intrinsics::unchecked_add(self, rhs) }
-            }
-        }
-
-        doc_comment! {
-            concat!("Checked integer subtraction. Computes `self - rhs`, returning `None` if
-overflow occurred.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!((", stringify!($SelfT),
-"::MIN + 2).checked_sub(1), Some(", stringify!($SelfT), "::MIN + 1));
-assert_eq!((", stringify!($SelfT), "::MIN + 2).checked_sub(3), None);",
-$EndFeature, "
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_checked_int_methods", since = "1.47.0")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn checked_sub(self, rhs: Self) -> Option<Self> {
-                let (a, b) = self.overflowing_sub(rhs);
-                if unlikely!(b) {None} else {Some(a)}
-            }
-        }
-
-        doc_comment! {
-            concat!("Unchecked integer subtraction. Computes `self - rhs`, assuming overflow
-cannot occur. This results in undefined behavior when `self - rhs > ", stringify!($SelfT),
-"::MAX` or `self - rhs < ", stringify!($SelfT), "::MIN`."),
-            #[unstable(
-                feature = "unchecked_math",
-                reason = "niche optimization path",
-                issue = "none",
-            )]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub unsafe fn unchecked_sub(self, rhs: Self) -> Self {
-                // SAFETY: the caller must uphold the safety contract for
-                // `unchecked_sub`.
-                unsafe { intrinsics::unchecked_sub(self, rhs) }
-            }
-        }
-
-        doc_comment! {
-            concat!("Checked integer multiplication. Computes `self * rhs`, returning `None` if
-overflow occurred.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(", stringify!($SelfT),
-"::MAX.checked_mul(1), Some(", stringify!($SelfT), "::MAX));
-assert_eq!(", stringify!($SelfT), "::MAX.checked_mul(2), None);",
-$EndFeature, "
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_checked_int_methods", since = "1.47.0")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn checked_mul(self, rhs: Self) -> Option<Self> {
-                let (a, b) = self.overflowing_mul(rhs);
-                if unlikely!(b) {None} else {Some(a)}
-            }
-        }
-
-        doc_comment! {
-            concat!("Unchecked integer multiplication. Computes `self * rhs`, assuming overflow
-cannot occur. This results in undefined behavior when `self * rhs > ", stringify!($SelfT),
-"::MAX` or `self * rhs < ", stringify!($SelfT), "::MIN`."),
-            #[unstable(
-                feature = "unchecked_math",
-                reason = "niche optimization path",
-                issue = "none",
-            )]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub unsafe fn unchecked_mul(self, rhs: Self) -> Self {
-                // SAFETY: the caller must uphold the safety contract for
-                // `unchecked_mul`.
-                unsafe { intrinsics::unchecked_mul(self, rhs) }
-            }
-        }
-
-        doc_comment! {
-            concat!("Checked integer division. Computes `self / rhs`, returning `None` if `rhs == 0`
-or the division results in overflow.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!((", stringify!($SelfT),
-"::MIN + 1).checked_div(-1), Some(", stringify!($Max), "));
-assert_eq!(", stringify!($SelfT), "::MIN.checked_div(-1), None);
-assert_eq!((1", stringify!($SelfT), ").checked_div(0), None);",
-$EndFeature, "
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_unstable(feature = "const_checked_int_methods", issue = "53718")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn checked_div(self, rhs: Self) -> Option<Self> {
-                if unlikely!(rhs == 0 || (self == Self::MIN && rhs == -1)) {
-                    None
-                } else {
-                    // SAFETY: div by zero and by INT_MIN have been checked above
-                    Some(unsafe { intrinsics::unchecked_div(self, rhs) })
-                }
-            }
-        }
-
-        doc_comment! {
-            concat!("Checked Euclidean division. Computes `self.div_euclid(rhs)`,
-returning `None` if `rhs == 0` or the division results in overflow.
-
-# Examples
-
-Basic usage:
-
-```
-assert_eq!((", stringify!($SelfT),
-"::MIN + 1).checked_div_euclid(-1), Some(", stringify!($Max), "));
-assert_eq!(", stringify!($SelfT), "::MIN.checked_div_euclid(-1), None);
-assert_eq!((1", stringify!($SelfT), ").checked_div_euclid(0), None);
-```"),
-            #[stable(feature = "euclidean_division", since = "1.38.0")]
-            #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn checked_div_euclid(self, rhs: Self) -> Option<Self> {
-                if unlikely!(rhs == 0 || (self == Self::MIN && rhs == -1)) {
-                    None
-                } else {
-                    Some(self.div_euclid(rhs))
-                }
-            }
-        }
-
-        doc_comment! {
-            concat!("Checked integer remainder. Computes `self % rhs`, returning `None` if
-`rhs == 0` or the division results in overflow.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "
-assert_eq!(5", stringify!($SelfT), ".checked_rem(2), Some(1));
-assert_eq!(5", stringify!($SelfT), ".checked_rem(0), None);
-assert_eq!(", stringify!($SelfT), "::MIN.checked_rem(-1), None);",
-$EndFeature, "
-```"),
-            #[stable(feature = "wrapping", since = "1.7.0")]
-            #[rustc_const_unstable(feature = "const_checked_int_methods", issue = "53718")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn checked_rem(self, rhs: Self) -> Option<Self> {
-                if unlikely!(rhs == 0 || (self == Self::MIN && rhs == -1)) {
-                    None
-                } else {
-                    // SAFETY: div by zero and by INT_MIN have been checked above
-                    Some(unsafe { intrinsics::unchecked_rem(self, rhs) })
-                }
-            }
-        }
-
-        doc_comment! {
-            concat!("Checked Euclidean remainder. Computes `self.rem_euclid(rhs)`, returning `None`
-if `rhs == 0` or the division results in overflow.
-
-# Examples
-
-Basic usage:
-
-```
-assert_eq!(5", stringify!($SelfT), ".checked_rem_euclid(2), Some(1));
-assert_eq!(5", stringify!($SelfT), ".checked_rem_euclid(0), None);
-assert_eq!(", stringify!($SelfT), "::MIN.checked_rem_euclid(-1), None);
-```"),
-            #[stable(feature = "euclidean_division", since = "1.38.0")]
-            #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn checked_rem_euclid(self, rhs: Self) -> Option<Self> {
-                if unlikely!(rhs == 0 || (self == Self::MIN && rhs == -1)) {
-                    None
+                exp /= 2;
+                base = try_opt!(base.checked_mul(base));
+            }
+            // since exp!=0, finally the exp must be 1.
+            // Deal with the final bit of the exponent separately, since
+            // squaring the base afterwards is not necessary and may cause a
+            // needless overflow.
+            Some(try_opt!(acc.checked_mul(base)))
+        }
+
+        /// Saturating integer addition. Computes `self + rhs`, saturating at the numeric
+        /// bounds instead of overflowing.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(100", stringify!($SelfT), ".saturating_add(1), 101);")]
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MAX.saturating_add(100), ", stringify!($SelfT), "::MAX);")]
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MIN.saturating_add(-1), ", stringify!($SelfT), "::MIN);")]
+        /// ```
+
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_saturating_int_methods", since = "1.47.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn saturating_add(self, rhs: Self) -> Self {
+            intrinsics::saturating_add(self, rhs)
+        }
+
+        /// Saturating integer subtraction. Computes `self - rhs`, saturating at the
+        /// numeric bounds instead of overflowing.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(100", stringify!($SelfT), ".saturating_sub(127), -27);")]
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MIN.saturating_sub(100), ", stringify!($SelfT), "::MIN);")]
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MAX.saturating_sub(-1), ", stringify!($SelfT), "::MAX);")]
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_saturating_int_methods", since = "1.47.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn saturating_sub(self, rhs: Self) -> Self {
+            intrinsics::saturating_sub(self, rhs)
+        }
+
+        /// Saturating integer negation. Computes `-self`, returning `MAX` if `self == MIN`
+        /// instead of overflowing.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(100", stringify!($SelfT), ".saturating_neg(), -100);")]
+        #[doc = concat!("assert_eq!((-100", stringify!($SelfT), ").saturating_neg(), 100);")]
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MIN.saturating_neg(), ", stringify!($SelfT), "::MAX);")]
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MAX.saturating_neg(), ", stringify!($SelfT), "::MIN + 1);")]
+        /// ```
+
+        #[stable(feature = "saturating_neg", since = "1.45.0")]
+        #[rustc_const_stable(feature = "const_saturating_int_methods", since = "1.47.0")]
+        #[inline]
+        pub const fn saturating_neg(self) -> Self {
+            intrinsics::saturating_sub(0, self)
+        }
+
+        /// Saturating absolute value. Computes `self.abs()`, returning `MAX` if `self ==
+        /// MIN` instead of overflowing.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(100", stringify!($SelfT), ".saturating_abs(), 100);")]
+        #[doc = concat!("assert_eq!((-100", stringify!($SelfT), ").saturating_abs(), 100);")]
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MIN.saturating_abs(), ", stringify!($SelfT), "::MAX);")]
+        #[doc = concat!("assert_eq!((", stringify!($SelfT), "::MIN + 1).saturating_abs(), ", stringify!($SelfT), "::MAX);")]
+        /// ```
+
+        #[stable(feature = "saturating_neg", since = "1.45.0")]
+        #[rustc_const_stable(feature = "const_saturating_int_methods", since = "1.47.0")]
+        #[inline]
+        pub const fn saturating_abs(self) -> Self {
+            if self.is_negative() {
+                self.saturating_neg()
+            } else {
+                self
+            }
+        }
+
+        /// Saturating integer multiplication. Computes `self * rhs`, saturating at the
+        /// numeric bounds instead of overflowing.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        ///
+        #[doc = concat!("assert_eq!(10", stringify!($SelfT), ".saturating_mul(12), 120);")]
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MAX.saturating_mul(10), ", stringify!($SelfT), "::MAX);")]
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MIN.saturating_mul(10), ", stringify!($SelfT), "::MIN);")]
+        /// ```
+        #[stable(feature = "wrapping", since = "1.7.0")]
+        #[rustc_const_stable(feature = "const_saturating_int_methods", since = "1.47.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn saturating_mul(self, rhs: Self) -> Self {
+            match self.checked_mul(rhs) {
+                Some(x) => x,
+                None => if (self < 0) == (rhs < 0) {
+                    Self::MAX
                 } else {
-                    Some(self.rem_euclid(rhs))
+                    Self::MIN
                 }
             }
         }
 
-        doc_comment! {
-            concat!("Checked negation. Computes `-self`, returning `None` if `self == MIN`.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "
-assert_eq!(5", stringify!($SelfT), ".checked_neg(), Some(-5));
-assert_eq!(", stringify!($SelfT), "::MIN.checked_neg(), None);",
-$EndFeature, "
-```"),
-            #[stable(feature = "wrapping", since = "1.7.0")]
-            #[rustc_const_stable(feature = "const_checked_int_methods", since = "1.47.0")]
-            #[inline]
-            pub const fn checked_neg(self) -> Option<Self> {
-                let (a, b) = self.overflowing_neg();
-                if unlikely!(b) {None} else {Some(a)}
-            }
-        }
-
-        doc_comment! {
-            concat!("Checked shift left. Computes `self << rhs`, returning `None` if `rhs` is larger
-than or equal to the number of bits in `self`.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(0x1", stringify!($SelfT), ".checked_shl(4), Some(0x10));
-assert_eq!(0x1", stringify!($SelfT), ".checked_shl(129), None);",
-$EndFeature, "
-```"),
-            #[stable(feature = "wrapping", since = "1.7.0")]
-            #[rustc_const_stable(feature = "const_checked_int_methods", since = "1.47.0")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn checked_shl(self, rhs: u32) -> Option<Self> {
-                let (a, b) = self.overflowing_shl(rhs);
-                if unlikely!(b) {None} else {Some(a)}
-            }
-        }
-
-        doc_comment! {
-            concat!("Checked shift right. Computes `self >> rhs`, returning `None` if `rhs` is
-larger than or equal to the number of bits in `self`.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(0x10", stringify!($SelfT), ".checked_shr(4), Some(0x1));
-assert_eq!(0x10", stringify!($SelfT), ".checked_shr(128), None);",
-$EndFeature, "
-```"),
-            #[stable(feature = "wrapping", since = "1.7.0")]
-            #[rustc_const_stable(feature = "const_checked_int_methods", since = "1.47.0")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn checked_shr(self, rhs: u32) -> Option<Self> {
-                let (a, b) = self.overflowing_shr(rhs);
-                if unlikely!(b) {None} else {Some(a)}
-            }
-        }
-
-        doc_comment! {
-            concat!("Checked absolute value. Computes `self.abs()`, returning `None` if
-`self == MIN`.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "
-assert_eq!((-5", stringify!($SelfT), ").checked_abs(), Some(5));
-assert_eq!(", stringify!($SelfT), "::MIN.checked_abs(), None);",
-$EndFeature, "
-```"),
-            #[stable(feature = "no_panic_abs", since = "1.13.0")]
-            #[rustc_const_stable(feature = "const_checked_int_methods", since = "1.47.0")]
-            #[inline]
-            pub const fn checked_abs(self) -> Option<Self> {
-                if self.is_negative() {
-                    self.checked_neg()
-                } else {
-                    Some(self)
+        /// Saturating integer exponentiation. Computes `self.pow(exp)`,
+        /// saturating at the numeric bounds instead of overflowing.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        ///
+        #[doc = concat!("assert_eq!((-4", stringify!($SelfT), ").saturating_pow(3), -64);")]
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MIN.saturating_pow(2), ", stringify!($SelfT), "::MAX);")]
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MIN.saturating_pow(3), ", stringify!($SelfT), "::MIN);")]
+        /// ```
+        #[stable(feature = "no_panic_pow", since = "1.34.0")]
+        #[rustc_const_stable(feature = "const_int_pow", since = "1.50.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        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,
+                None => Self::MAX,
+            }
+        }
+
+        /// Wrapping (modular) addition. Computes `self + rhs`, wrapping around at the
+        /// boundary of the type.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(100", stringify!($SelfT), ".wrapping_add(27), 127);")]
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MAX.wrapping_add(2), ", stringify!($SelfT), "::MIN + 1);")]
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn wrapping_add(self, rhs: Self) -> Self {
+            intrinsics::wrapping_add(self, rhs)
+        }
+
+        /// Wrapping (modular) subtraction. Computes `self - rhs`, wrapping around at the
+        /// boundary of the type.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(0", stringify!($SelfT), ".wrapping_sub(127), -127);")]
+        #[doc = concat!("assert_eq!((-2", stringify!($SelfT), ").wrapping_sub(", stringify!($SelfT), "::MAX), ", stringify!($SelfT), "::MAX);")]
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn wrapping_sub(self, rhs: Self) -> Self {
+            intrinsics::wrapping_sub(self, rhs)
+        }
+
+        /// Wrapping (modular) multiplication. Computes `self * rhs`, wrapping around at
+        /// the boundary of the type.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(10", stringify!($SelfT), ".wrapping_mul(12), 120);")]
+        /// assert_eq!(11i8.wrapping_mul(12), -124);
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn wrapping_mul(self, rhs: Self) -> Self {
+            intrinsics::wrapping_mul(self, rhs)
+        }
+
+        /// Wrapping (modular) division. Computes `self / rhs`, wrapping around at the
+        /// boundary of the type.
+        ///
+        /// The only case where such wrapping can occur is when one divides `MIN / -1` on a signed type (where
+        /// `MIN` is the negative minimal value for the type); this is equivalent to `-MIN`, a positive value
+        /// that is too large to represent in the type. In such a case, this function returns `MIN` itself.
+        ///
+        /// # Panics
+        ///
+        /// This function will panic if `rhs` is 0.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(100", stringify!($SelfT), ".wrapping_div(10), 10);")]
+        /// assert_eq!((-128i8).wrapping_div(-1), -128);
+        /// ```
+        #[stable(feature = "num_wrapping", since = "1.2.0")]
+        #[rustc_const_unstable(feature = "const_wrapping_int_methods", issue = "53718")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn wrapping_div(self, rhs: Self) -> Self {
+            self.overflowing_div(rhs).0
+        }
+
+        /// Wrapping Euclidean division. Computes `self.div_euclid(rhs)`,
+        /// wrapping around at the boundary of the type.
+        ///
+        /// Wrapping will only occur in `MIN / -1` on a signed type (where `MIN` is the negative minimal value
+        /// for the type). This is equivalent to `-MIN`, a positive value that is too large to represent in the
+        /// type. In this case, this method returns `MIN` itself.
+        ///
+        /// # Panics
+        ///
+        /// This function will panic if `rhs` is 0.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(100", stringify!($SelfT), ".wrapping_div_euclid(10), 10);")]
+        /// assert_eq!((-128i8).wrapping_div_euclid(-1), -128);
+        /// ```
+        #[stable(feature = "euclidean_division", since = "1.38.0")]
+        #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn wrapping_div_euclid(self, rhs: Self) -> Self {
+            self.overflowing_div_euclid(rhs).0
+        }
+
+        /// Wrapping (modular) remainder. Computes `self % rhs`, wrapping around at the
+        /// boundary of the type.
+        ///
+        /// Such wrap-around never actually occurs mathematically; implementation artifacts make `x % y`
+        /// invalid for `MIN / -1` on a signed type (where `MIN` is the negative minimal value). In such a case,
+        /// this function returns `0`.
+        ///
+        /// # Panics
+        ///
+        /// This function will panic if `rhs` is 0.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(100", stringify!($SelfT), ".wrapping_rem(10), 0);")]
+        /// assert_eq!((-128i8).wrapping_rem(-1), 0);
+        /// ```
+        #[stable(feature = "num_wrapping", since = "1.2.0")]
+        #[rustc_const_unstable(feature = "const_wrapping_int_methods", issue = "53718")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn wrapping_rem(self, rhs: Self) -> Self {
+            self.overflowing_rem(rhs).0
+        }
+
+        /// Wrapping Euclidean remainder. Computes `self.rem_euclid(rhs)`, wrapping around
+        /// at the boundary of the type.
+        ///
+        /// Wrapping will only occur in `MIN % -1` on a signed type (where `MIN` is the negative minimal value
+        /// for the type). In this case, this method returns 0.
+        ///
+        /// # Panics
+        ///
+        /// This function will panic if `rhs` is 0.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(100", stringify!($SelfT), ".wrapping_rem_euclid(10), 0);")]
+        /// assert_eq!((-128i8).wrapping_rem_euclid(-1), 0);
+        /// ```
+        #[stable(feature = "euclidean_division", since = "1.38.0")]
+        #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn wrapping_rem_euclid(self, rhs: Self) -> Self {
+            self.overflowing_rem_euclid(rhs).0
+        }
+
+        /// Wrapping (modular) negation. Computes `-self`, wrapping around at the boundary
+        /// of the type.
+        ///
+        /// The only case where such wrapping can occur is when one negates `MIN` on a signed type (where `MIN`
+        /// is the negative minimal value for the type); this is a positive value that is too large to represent
+        /// in the type. In such a case, this function returns `MIN` itself.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(100", stringify!($SelfT), ".wrapping_neg(), -100);")]
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MIN.wrapping_neg(), ", stringify!($SelfT), "::MIN);")]
+        /// ```
+        #[stable(feature = "num_wrapping", since = "1.2.0")]
+        #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
+        #[inline]
+        pub const fn wrapping_neg(self) -> Self {
+            self.overflowing_neg().0
+        }
+
+        /// Panic-free bitwise shift-left; yields `self << mask(rhs)`, where `mask` removes
+        /// any high-order bits of `rhs` that would cause the shift to exceed the bitwidth of the type.
+        ///
+        /// Note that this is *not* the same as a rotate-left; the RHS of a wrapping shift-left is restricted to
+        /// the range of the type, rather than the bits shifted out of the LHS being returned to the other end.
+        /// The primitive integer types all implement a [`rotate_left`](#method.rotate_left) function,
+        /// which may be what you want instead.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!((-1", stringify!($SelfT), ").wrapping_shl(7), -128);")]
+        #[doc = concat!("assert_eq!((-1", stringify!($SelfT), ").wrapping_shl(128), -1);")]
+        /// ```
+        #[stable(feature = "num_wrapping", since = "1.2.0")]
+        #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn wrapping_shl(self, rhs: u32) -> Self {
+            // SAFETY: the masking by the bitsize of the type ensures that we do not shift
+            // out of bounds
+            unsafe {
+                intrinsics::unchecked_shl(self, (rhs & ($BITS - 1)) as $SelfT)
+            }
+        }
+
+        /// Panic-free bitwise shift-right; yields `self >> mask(rhs)`, where `mask`
+        /// removes any high-order bits of `rhs` that would cause the shift to exceed the bitwidth of the type.
+        ///
+        /// Note that this is *not* the same as a rotate-right; the RHS of a wrapping shift-right is restricted
+        /// to the range of the type, rather than the bits shifted out of the LHS being returned to the other
+        /// end. The primitive integer types all implement a [`rotate_right`](#method.rotate_right) function,
+        /// which may be what you want instead.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!((-128", stringify!($SelfT), ").wrapping_shr(7), -1);")]
+        /// assert_eq!((-128i16).wrapping_shr(64), -128);
+        /// ```
+        #[stable(feature = "num_wrapping", since = "1.2.0")]
+        #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn wrapping_shr(self, rhs: u32) -> Self {
+            // SAFETY: the masking by the bitsize of the type ensures that we do not shift
+            // out of bounds
+            unsafe {
+                intrinsics::unchecked_shr(self, (rhs & ($BITS - 1)) as $SelfT)
+            }
+        }
+
+        /// Wrapping (modular) absolute value. Computes `self.abs()`, wrapping around at
+        /// the boundary of the type.
+        ///
+        /// The only case where such wrapping can occur is when one takes the absolute value of the negative
+        /// minimal value for the type; this is a positive value that is too large to represent in the type. In
+        /// such a case, this function returns `MIN` itself.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(100", stringify!($SelfT), ".wrapping_abs(), 100);")]
+        #[doc = concat!("assert_eq!((-100", stringify!($SelfT), ").wrapping_abs(), 100);")]
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MIN.wrapping_abs(), ", stringify!($SelfT), "::MIN);")]
+        /// assert_eq!((-128i8).wrapping_abs() as u8, 128);
+        /// ```
+        #[stable(feature = "no_panic_abs", since = "1.13.0")]
+        #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
+        #[allow(unused_attributes)]
+        #[inline]
+        pub const fn wrapping_abs(self) -> Self {
+             if self.is_negative() {
+                 self.wrapping_neg()
+             } else {
+                 self
+             }
+        }
+
+        /// Computes the absolute value of `self` without any wrapping
+        /// or panicking.
+        ///
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        /// #![feature(unsigned_abs)]
+        #[doc = concat!("assert_eq!(100", stringify!($SelfT), ".unsigned_abs(), 100", stringify!($UnsignedT), ");")]
+        #[doc = concat!("assert_eq!((-100", stringify!($SelfT), ").unsigned_abs(), 100", stringify!($UnsignedT), ");")]
+        /// assert_eq!((-128i8).unsigned_abs(), 128u8);
+        /// ```
+        #[unstable(feature = "unsigned_abs", issue = "74913")]
+        #[inline]
+        pub const fn unsigned_abs(self) -> $UnsignedT {
+             self.wrapping_abs() as $UnsignedT
+        }
+
+        /// Wrapping (modular) exponentiation. Computes `self.pow(exp)`,
+        /// wrapping around at the boundary of the type.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(3", stringify!($SelfT), ".wrapping_pow(4), 81);")]
+        /// assert_eq!(3i8.wrapping_pow(5), -13);
+        /// assert_eq!(3i8.wrapping_pow(6), -39);
+        /// ```
+        #[stable(feature = "no_panic_pow", since = "1.34.0")]
+        #[rustc_const_stable(feature = "const_int_pow", since = "1.50.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn wrapping_pow(self, mut exp: u32) -> Self {
+            if exp == 0 {
+                return 1;
+            }
+            let mut base = self;
+            let mut acc: Self = 1;
+
+            while exp > 1 {
+                if (exp & 1) == 1 {
+                    acc = acc.wrapping_mul(base);
                 }
-            }
-        }
-
-        doc_comment! {
-            concat!("Checked exponentiation. Computes `self.pow(exp)`, returning `None` if
-overflow occurred.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(8", stringify!($SelfT), ".checked_pow(2), Some(64));
-assert_eq!(", stringify!($SelfT), "::MAX.checked_pow(2), None);",
-$EndFeature, "
-```"),
-
-            #[stable(feature = "no_panic_pow", since = "1.34.0")]
-            #[rustc_const_stable(feature = "const_int_pow", since = "1.50.0")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn checked_pow(self, mut exp: u32) -> Option<Self> {
-                if exp == 0 {
-                    return Some(1);
-                }
-                let mut base = self;
-                let mut acc: Self = 1;
-
-                while exp > 1 {
-                    if (exp & 1) == 1 {
-                        acc = try_opt!(acc.checked_mul(base));
-                    }
-                    exp /= 2;
-                    base = try_opt!(base.checked_mul(base));
-                }
-                // since exp!=0, finally the exp must be 1.
-                // Deal with the final bit of the exponent separately, since
-                // squaring the base afterwards is not necessary and may cause a
-                // needless overflow.
-                Some(try_opt!(acc.checked_mul(base)))
-            }
-        }
-
-        doc_comment! {
-            concat!("Saturating integer addition. Computes `self + rhs`, saturating at the numeric
-bounds instead of overflowing.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(100", stringify!($SelfT), ".saturating_add(1), 101);
-assert_eq!(", stringify!($SelfT), "::MAX.saturating_add(100), ", stringify!($SelfT),
-"::MAX);
-assert_eq!(", stringify!($SelfT), "::MIN.saturating_add(-1), ", stringify!($SelfT),
-"::MIN);",
-$EndFeature, "
-```"),
-
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_saturating_int_methods", since = "1.47.0")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn saturating_add(self, rhs: Self) -> Self {
-                intrinsics::saturating_add(self, rhs)
-            }
-        }
-
-        doc_comment! {
-            concat!("Saturating integer subtraction. Computes `self - rhs`, saturating at the
-numeric bounds instead of overflowing.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(100", stringify!($SelfT), ".saturating_sub(127), -27);
-assert_eq!(", stringify!($SelfT), "::MIN.saturating_sub(100), ", stringify!($SelfT),
-"::MIN);
-assert_eq!(", stringify!($SelfT), "::MAX.saturating_sub(-1), ", stringify!($SelfT),
-"::MAX);",
-$EndFeature, "
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_saturating_int_methods", since = "1.47.0")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn saturating_sub(self, rhs: Self) -> Self {
-                intrinsics::saturating_sub(self, rhs)
-            }
-        }
-
-        doc_comment! {
-            concat!("Saturating integer negation. Computes `-self`, returning `MAX` if `self == MIN`
-instead of overflowing.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(100", stringify!($SelfT), ".saturating_neg(), -100);
-assert_eq!((-100", stringify!($SelfT), ").saturating_neg(), 100);
-assert_eq!(", stringify!($SelfT), "::MIN.saturating_neg(), ", stringify!($SelfT),
-"::MAX);
-assert_eq!(", stringify!($SelfT), "::MAX.saturating_neg(), ", stringify!($SelfT),
-"::MIN + 1);",
-$EndFeature, "
-```"),
-
-            #[stable(feature = "saturating_neg", since = "1.45.0")]
-            #[rustc_const_stable(feature = "const_saturating_int_methods", since = "1.47.0")]
-            #[inline]
-            pub const fn saturating_neg(self) -> Self {
-                intrinsics::saturating_sub(0, self)
-            }
-        }
-
-        doc_comment! {
-            concat!("Saturating absolute value. Computes `self.abs()`, returning `MAX` if `self ==
-MIN` instead of overflowing.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(100", stringify!($SelfT), ".saturating_abs(), 100);
-assert_eq!((-100", stringify!($SelfT), ").saturating_abs(), 100);
-assert_eq!(", stringify!($SelfT), "::MIN.saturating_abs(), ", stringify!($SelfT),
-"::MAX);
-assert_eq!((", stringify!($SelfT), "::MIN + 1).saturating_abs(), ", stringify!($SelfT),
-"::MAX);",
-$EndFeature, "
-```"),
-
-            #[stable(feature = "saturating_neg", since = "1.45.0")]
-            #[rustc_const_stable(feature = "const_saturating_int_methods", since = "1.47.0")]
-            #[inline]
-            pub const fn saturating_abs(self) -> Self {
-                if self.is_negative() {
-                    self.saturating_neg()
-                } else {
-                    self
-                }
-            }
-        }
-
-        doc_comment! {
-            concat!("Saturating integer multiplication. Computes `self * rhs`, saturating at the
-numeric bounds instead of overflowing.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "
-assert_eq!(10", stringify!($SelfT), ".saturating_mul(12), 120);
-assert_eq!(", stringify!($SelfT), "::MAX.saturating_mul(10), ", stringify!($SelfT), "::MAX);
-assert_eq!(", stringify!($SelfT), "::MIN.saturating_mul(10), ", stringify!($SelfT), "::MIN);",
-$EndFeature, "
-```"),
-            #[stable(feature = "wrapping", since = "1.7.0")]
-            #[rustc_const_stable(feature = "const_saturating_int_methods", since = "1.47.0")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn saturating_mul(self, rhs: Self) -> Self {
-                match self.checked_mul(rhs) {
-                    Some(x) => x,
-                    None => if (self < 0) == (rhs < 0) {
-                        Self::MAX
-                    } else {
-                        Self::MIN
-                    }
-                }
-            }
-        }
-
-        doc_comment! {
-            concat!("Saturating integer exponentiation. Computes `self.pow(exp)`,
-saturating at the numeric bounds instead of overflowing.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "
-assert_eq!((-4", stringify!($SelfT), ").saturating_pow(3), -64);
-assert_eq!(", stringify!($SelfT), "::MIN.saturating_pow(2), ", stringify!($SelfT), "::MAX);
-assert_eq!(", stringify!($SelfT), "::MIN.saturating_pow(3), ", stringify!($SelfT), "::MIN);",
-$EndFeature, "
-```"),
-            #[stable(feature = "no_panic_pow", since = "1.34.0")]
-            #[rustc_const_stable(feature = "const_int_pow", since = "1.50.0")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            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,
-                    None => Self::MAX,
-                }
-            }
-        }
-
-        doc_comment! {
-            concat!("Wrapping (modular) addition. Computes `self + rhs`, wrapping around at the
-boundary of the type.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(100", stringify!($SelfT), ".wrapping_add(27), 127);
-assert_eq!(", stringify!($SelfT), "::MAX.wrapping_add(2), ", stringify!($SelfT),
-"::MIN + 1);",
-$EndFeature, "
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn wrapping_add(self, rhs: Self) -> Self {
-                intrinsics::wrapping_add(self, rhs)
-            }
-        }
-
-        doc_comment! {
-            concat!("Wrapping (modular) subtraction. Computes `self - rhs`, wrapping around at the
-boundary of the type.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(0", stringify!($SelfT), ".wrapping_sub(127), -127);
-assert_eq!((-2", stringify!($SelfT), ").wrapping_sub(", stringify!($SelfT), "::MAX), ",
-stringify!($SelfT), "::MAX);",
-$EndFeature, "
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn wrapping_sub(self, rhs: Self) -> Self {
-                intrinsics::wrapping_sub(self, rhs)
-            }
-        }
-
-        doc_comment! {
-            concat!("Wrapping (modular) multiplication. Computes `self * rhs`, wrapping around at
-the boundary of the type.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(10", stringify!($SelfT), ".wrapping_mul(12), 120);
-assert_eq!(11i8.wrapping_mul(12), -124);",
-$EndFeature, "
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn wrapping_mul(self, rhs: Self) -> Self {
-                intrinsics::wrapping_mul(self, rhs)
-            }
-        }
-
-        doc_comment! {
-            concat!("Wrapping (modular) division. Computes `self / rhs`, wrapping around at the
-boundary of the type.
-
-The only case where such wrapping can occur is when one divides `MIN / -1` on a signed type (where
-`MIN` is the negative minimal value for the type); this is equivalent to `-MIN`, a positive value
-that is too large to represent in the type. In such a case, this function returns `MIN` itself.
-
-# Panics
-
-This function will panic if `rhs` is 0.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(100", stringify!($SelfT), ".wrapping_div(10), 10);
-assert_eq!((-128i8).wrapping_div(-1), -128);",
-$EndFeature, "
-```"),
-            #[stable(feature = "num_wrapping", since = "1.2.0")]
-            #[rustc_const_unstable(feature = "const_wrapping_int_methods", issue = "53718")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const 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.
-
-Wrapping will only occur in `MIN / -1` on a signed type (where `MIN` is the negative minimal value
-for the type). This is equivalent to `-MIN`, a positive value that is too large to represent in the
-type. In this case, this method returns `MIN` itself.
-
-# Panics
-
-This function will panic if `rhs` is 0.
-
-# Examples
-
-Basic usage:
-
-```
-assert_eq!(100", stringify!($SelfT), ".wrapping_div_euclid(10), 10);
-assert_eq!((-128i8).wrapping_div_euclid(-1), -128);
-```"),
-            #[stable(feature = "euclidean_division", since = "1.38.0")]
-            #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn wrapping_div_euclid(self, rhs: Self) -> Self {
-                self.overflowing_div_euclid(rhs).0
-            }
-        }
-
-        doc_comment! {
-            concat!("Wrapping (modular) remainder. Computes `self % rhs`, wrapping around at the
-boundary of the type.
-
-Such wrap-around never actually occurs mathematically; implementation artifacts make `x % y`
-invalid for `MIN / -1` on a signed type (where `MIN` is the negative minimal value). In such a case,
-this function returns `0`.
-
-# Panics
-
-This function will panic if `rhs` is 0.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(100", stringify!($SelfT), ".wrapping_rem(10), 0);
-assert_eq!((-128i8).wrapping_rem(-1), 0);",
-$EndFeature, "
-```"),
-            #[stable(feature = "num_wrapping", since = "1.2.0")]
-            #[rustc_const_unstable(feature = "const_wrapping_int_methods", issue = "53718")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const 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.
-
-Wrapping will only occur in `MIN % -1` on a signed type (where `MIN` is the negative minimal value
-for the type). In this case, this method returns 0.
-
-# Panics
-
-This function will panic if `rhs` is 0.
-
-# Examples
-
-Basic usage:
-
-```
-assert_eq!(100", stringify!($SelfT), ".wrapping_rem_euclid(10), 0);
-assert_eq!((-128i8).wrapping_rem_euclid(-1), 0);
-```"),
-            #[stable(feature = "euclidean_division", since = "1.38.0")]
-            #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn wrapping_rem_euclid(self, rhs: Self) -> Self {
-                self.overflowing_rem_euclid(rhs).0
-            }
-        }
-
-        doc_comment! {
-            concat!("Wrapping (modular) negation. Computes `-self`, wrapping around at the boundary
-of the type.
-
-The only case where such wrapping can occur is when one negates `MIN` on a signed type (where `MIN`
-is the negative minimal value for the type); this is a positive value that is too large to represent
-in the type. In such a case, this function returns `MIN` itself.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(100", stringify!($SelfT), ".wrapping_neg(), -100);
-assert_eq!(", stringify!($SelfT), "::MIN.wrapping_neg(), ", stringify!($SelfT),
-"::MIN);",
-$EndFeature, "
-```"),
-            #[stable(feature = "num_wrapping", since = "1.2.0")]
-            #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
-            #[inline]
-            pub const fn wrapping_neg(self) -> Self {
-                self.overflowing_neg().0
-            }
-        }
-
-        doc_comment! {
-            concat!("Panic-free bitwise shift-left; yields `self << mask(rhs)`, where `mask` removes
-any high-order bits of `rhs` that would cause the shift to exceed the bitwidth of the type.
-
-Note that this is *not* the same as a rotate-left; the RHS of a wrapping shift-left is restricted to
-the range of the type, rather than the bits shifted out of the LHS being returned to the other end.
-The primitive integer types all implement a [`rotate_left`](#method.rotate_left) function,
-which may be what you want instead.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!((-1", stringify!($SelfT), ").wrapping_shl(7), -128);
-assert_eq!((-1", stringify!($SelfT), ").wrapping_shl(128), -1);",
-$EndFeature, "
-```"),
-            #[stable(feature = "num_wrapping", since = "1.2.0")]
-            #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn wrapping_shl(self, rhs: u32) -> Self {
-                // SAFETY: the masking by the bitsize of the type ensures that we do not shift
-                // out of bounds
-                unsafe {
-                    intrinsics::unchecked_shl(self, (rhs & ($BITS - 1)) as $SelfT)
-                }
-            }
-        }
-
-        doc_comment! {
-            concat!("Panic-free bitwise shift-right; yields `self >> mask(rhs)`, where `mask`
-removes any high-order bits of `rhs` that would cause the shift to exceed the bitwidth of the type.
-
-Note that this is *not* the same as a rotate-right; the RHS of a wrapping shift-right is restricted
-to the range of the type, rather than the bits shifted out of the LHS being returned to the other
-end. The primitive integer types all implement a [`rotate_right`](#method.rotate_right) function,
-which may be what you want instead.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!((-128", stringify!($SelfT), ").wrapping_shr(7), -1);
-assert_eq!((-128i16).wrapping_shr(64), -128);",
-$EndFeature, "
-```"),
-            #[stable(feature = "num_wrapping", since = "1.2.0")]
-            #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn wrapping_shr(self, rhs: u32) -> Self {
-                // SAFETY: the masking by the bitsize of the type ensures that we do not shift
-                // out of bounds
-                unsafe {
-                    intrinsics::unchecked_shr(self, (rhs & ($BITS - 1)) as $SelfT)
-                }
-            }
-        }
-
-        doc_comment! {
-            concat!("Wrapping (modular) absolute value. Computes `self.abs()`, wrapping around at
-the boundary of the type.
-
-The only case where such wrapping can occur is when one takes the absolute value of the negative
-minimal value for the type; this is a positive value that is too large to represent in the type. In
-such a case, this function returns `MIN` itself.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(100", stringify!($SelfT), ".wrapping_abs(), 100);
-assert_eq!((-100", stringify!($SelfT), ").wrapping_abs(), 100);
-assert_eq!(", stringify!($SelfT), "::MIN.wrapping_abs(), ", stringify!($SelfT),
-"::MIN);
-assert_eq!((-128i8).wrapping_abs() as u8, 128);",
-$EndFeature, "
-```"),
-            #[stable(feature = "no_panic_abs", since = "1.13.0")]
-            #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
-            #[allow(unused_attributes)]
-            #[inline]
-            pub const fn wrapping_abs(self) -> Self {
-                 if self.is_negative() {
-                     self.wrapping_neg()
-                 } else {
-                     self
-                 }
-            }
-        }
-
-        doc_comment! {
-            concat!("Computes the absolute value of `self` without any wrapping
-or panicking.
-
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "#![feature(unsigned_abs)]
-assert_eq!(100", stringify!($SelfT), ".unsigned_abs(), 100", stringify!($UnsignedT), ");
-assert_eq!((-100", stringify!($SelfT), ").unsigned_abs(), 100", stringify!($UnsignedT), ");
-assert_eq!((-128i8).unsigned_abs(), 128u8);",
-$EndFeature, "
-```"),
-            #[unstable(feature = "unsigned_abs", issue = "74913")]
-            #[inline]
-            pub const fn unsigned_abs(self) -> $UnsignedT {
-                 self.wrapping_abs() as $UnsignedT
-            }
-        }
-
-        doc_comment! {
-            concat!("Wrapping (modular) exponentiation. Computes `self.pow(exp)`,
-wrapping around at the boundary of the type.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(3", stringify!($SelfT), ".wrapping_pow(4), 81);
-assert_eq!(3i8.wrapping_pow(5), -13);
-assert_eq!(3i8.wrapping_pow(6), -39);",
-$EndFeature, "
-```"),
-            #[stable(feature = "no_panic_pow", since = "1.34.0")]
-            #[rustc_const_stable(feature = "const_int_pow", since = "1.50.0")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn wrapping_pow(self, mut exp: u32) -> Self {
-                if exp == 0 {
-                    return 1;
-                }
-                let mut base = self;
-                let mut acc: Self = 1;
-
-                while exp > 1 {
-                    if (exp & 1) == 1 {
-                        acc = acc.wrapping_mul(base);
-                    }
-                    exp /= 2;
-                    base = base.wrapping_mul(base);
-                }
-
-                // since exp!=0, finally the exp must be 1.
-                // Deal with the final bit of the exponent separately, since
-                // squaring the base afterwards is not necessary and may cause a
-                // needless overflow.
-                acc.wrapping_mul(base)
-            }
-        }
-
-        doc_comment! {
-            concat!("Calculates `self` + `rhs`
-
-Returns a tuple of the addition along with a boolean indicating whether an arithmetic overflow would
-occur. If an overflow would have occurred then the wrapped value is returned.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "
-assert_eq!(5", stringify!($SelfT), ".overflowing_add(2), (7, false));
-assert_eq!(", stringify!($SelfT), "::MAX.overflowing_add(1), (", stringify!($SelfT),
-"::MIN, true));", $EndFeature, "
-```"),
-            #[stable(feature = "wrapping", since = "1.7.0")]
-            #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn overflowing_add(self, rhs: Self) -> (Self, bool) {
-                let (a, b) = intrinsics::add_with_overflow(self as $ActualT, rhs as $ActualT);
-                (a as Self, b)
-            }
-        }
-
-        doc_comment! {
-            concat!("Calculates `self` - `rhs`
-
-Returns a tuple of the subtraction along with a boolean indicating whether an arithmetic overflow
-would occur. If an overflow would have occurred then the wrapped value is returned.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "
-assert_eq!(5", stringify!($SelfT), ".overflowing_sub(2), (3, false));
-assert_eq!(", stringify!($SelfT), "::MIN.overflowing_sub(1), (", stringify!($SelfT),
-"::MAX, true));", $EndFeature, "
-```"),
-            #[stable(feature = "wrapping", since = "1.7.0")]
-            #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn overflowing_sub(self, rhs: Self) -> (Self, bool) {
-                let (a, b) = intrinsics::sub_with_overflow(self as $ActualT, rhs as $ActualT);
-                (a as Self, b)
-            }
-        }
-
-        doc_comment! {
-            concat!("Calculates the multiplication of `self` and `rhs`.
-
-Returns a tuple of the multiplication along with a boolean indicating whether an arithmetic overflow
-would occur. If an overflow would have occurred then the wrapped value is returned.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(5", stringify!($SelfT), ".overflowing_mul(2), (10, false));
-assert_eq!(1_000_000_000i32.overflowing_mul(10), (1410065408, true));",
-$EndFeature, "
-```"),
-            #[stable(feature = "wrapping", since = "1.7.0")]
-            #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn overflowing_mul(self, rhs: Self) -> (Self, bool) {
-                let (a, b) = intrinsics::mul_with_overflow(self as $ActualT, rhs as $ActualT);
-                (a as Self, b)
-            }
-        }
-
-        doc_comment! {
-            concat!("Calculates the divisor when `self` is divided by `rhs`.
-
-Returns a tuple of the divisor along with a boolean indicating whether an arithmetic overflow would
-occur. If an overflow would occur then self is returned.
-
-# Panics
-
-This function will panic if `rhs` is 0.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "
-assert_eq!(5", stringify!($SelfT), ".overflowing_div(2), (2, false));
-assert_eq!(", stringify!($SelfT), "::MIN.overflowing_div(-1), (", stringify!($SelfT),
-"::MIN, true));",
-$EndFeature, "
-```"),
-            #[inline]
-            #[stable(feature = "wrapping", since = "1.7.0")]
-            #[rustc_const_unstable(feature = "const_overflowing_int_methods", issue = "53718")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            pub const fn overflowing_div(self, rhs: Self) -> (Self, bool) {
-                if unlikely!(self == Self::MIN && rhs == -1) {
-                    (self, true)
-                } else {
-                    (self / rhs, false)
-                }
-            }
-        }
-
-        doc_comment! {
-            concat!("Calculates the quotient of Euclidean division `self.div_euclid(rhs)`.
-
-Returns a tuple of the divisor along with a boolean indicating whether an arithmetic overflow would
-occur. If an overflow would occur then `self` is returned.
-
-# Panics
-
-This function will panic if `rhs` is 0.
-
-# Examples
-
-Basic usage:
-
-```
-assert_eq!(5", stringify!($SelfT), ".overflowing_div_euclid(2), (2, false));
-assert_eq!(", stringify!($SelfT), "::MIN.overflowing_div_euclid(-1), (", stringify!($SelfT),
-"::MIN, true));
-```"),
-            #[inline]
-            #[stable(feature = "euclidean_division", since = "1.38.0")]
-            #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")]
-            #[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 unlikely!(self == Self::MIN && rhs == -1) {
-                    (self, true)
-                } else {
-                    (self.div_euclid(rhs), false)
-                }
-            }
-        }
-
-        doc_comment! {
-            concat!("Calculates the remainder when `self` is divided by `rhs`.
-
-Returns a tuple of the remainder after dividing along with a boolean indicating whether an
-arithmetic overflow would occur. If an overflow would occur then 0 is returned.
-
-# Panics
-
-This function will panic if `rhs` is 0.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "
-assert_eq!(5", stringify!($SelfT), ".overflowing_rem(2), (1, false));
-assert_eq!(", stringify!($SelfT), "::MIN.overflowing_rem(-1), (0, true));",
-$EndFeature, "
-```"),
-            #[inline]
-            #[stable(feature = "wrapping", since = "1.7.0")]
-            #[rustc_const_unstable(feature = "const_overflowing_int_methods", issue = "53718")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            pub const fn overflowing_rem(self, rhs: Self) -> (Self, bool) {
-                if unlikely!(self == Self::MIN && rhs == -1) {
-                    (0, true)
-                } else {
-                    (self % rhs, false)
-                }
-            }
-        }
-
-
-        doc_comment! {
-            concat!("Overflowing Euclidean remainder. Calculates `self.rem_euclid(rhs)`.
-
-Returns a tuple of the remainder after dividing along with a boolean indicating whether an
-arithmetic overflow would occur. If an overflow would occur then 0 is returned.
-
-# Panics
-
-This function will panic if `rhs` is 0.
-
-# Examples
-
-Basic usage:
-
-```
-assert_eq!(5", stringify!($SelfT), ".overflowing_rem_euclid(2), (1, false));
-assert_eq!(", stringify!($SelfT), "::MIN.overflowing_rem_euclid(-1), (0, true));
-```"),
-            #[stable(feature = "euclidean_division", since = "1.38.0")]
-            #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn overflowing_rem_euclid(self, rhs: Self) -> (Self, bool) {
-                if unlikely!(self == Self::MIN && rhs == -1) {
-                    (0, true)
-                } else {
-                    (self.rem_euclid(rhs), false)
-                }
-            }
-        }
-
-
-        doc_comment! {
-            concat!("Negates self, overflowing if this is equal to the minimum value.
-
-Returns a tuple of the negated version of self along with a boolean indicating whether an overflow
-happened. If `self` is the minimum value (e.g., `i32::MIN` for values of type `i32`), then the
-minimum value will be returned again and `true` will be returned for an overflow happening.
-
-# Examples
-
-Basic usage:
-
-```
-assert_eq!(2", stringify!($SelfT), ".overflowing_neg(), (-2, false));
-assert_eq!(", stringify!($SelfT), "::MIN.overflowing_neg(), (", stringify!($SelfT),
-"::MIN, true));", $EndFeature, "
-```"),
-            #[inline]
-            #[stable(feature = "wrapping", since = "1.7.0")]
-            #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
-            #[allow(unused_attributes)]
-            pub const fn overflowing_neg(self) -> (Self, bool) {
-                if unlikely!(self == Self::MIN) {
-                    (Self::MIN, true)
-                } else {
-                    (-self, false)
-                }
-            }
-        }
-
-        doc_comment! {
-            concat!("Shifts self left by `rhs` bits.
-
-Returns a tuple of the shifted version of self along with a boolean indicating whether the shift
-value was larger than or equal to the number of bits. If the shift value is too large, then value is
-masked (N-1) where N is the number of bits, and this value is then used to perform the shift.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(0x1", stringify!($SelfT),".overflowing_shl(4), (0x10, false));
-assert_eq!(0x1i32.overflowing_shl(36), (0x10, true));",
-$EndFeature, "
-```"),
-            #[stable(feature = "wrapping", since = "1.7.0")]
-            #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn overflowing_shl(self, rhs: u32) -> (Self, bool) {
-                (self.wrapping_shl(rhs), (rhs > ($BITS - 1)))
-            }
-        }
-
-        doc_comment! {
-            concat!("Shifts self right by `rhs` bits.
-
-Returns a tuple of the shifted version of self along with a boolean indicating whether the shift
-value was larger than or equal to the number of bits. If the shift value is too large, then value is
-masked (N-1) where N is the number of bits, and this value is then used to perform the shift.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(0x10", stringify!($SelfT), ".overflowing_shr(4), (0x1, false));
-assert_eq!(0x10i32.overflowing_shr(36), (0x1, true));",
-$EndFeature, "
-```"),
-            #[stable(feature = "wrapping", since = "1.7.0")]
-            #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn overflowing_shr(self, rhs: u32) -> (Self, bool) {
-                (self.wrapping_shr(rhs), (rhs > ($BITS - 1)))
-            }
-        }
-
-        doc_comment! {
-            concat!("Computes the absolute value of `self`.
-
-Returns a tuple of the absolute version of self along with a boolean indicating whether an overflow
-happened. If self is the minimum value (e.g., ", stringify!($SelfT), "::MIN for values of type
- ", stringify!($SelfT), "), then the minimum value will be returned again and true will be returned
-for an overflow happening.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(10", stringify!($SelfT), ".overflowing_abs(), (10, false));
-assert_eq!((-10", stringify!($SelfT), ").overflowing_abs(), (10, false));
-assert_eq!((", stringify!($SelfT), "::MIN).overflowing_abs(), (", stringify!($SelfT),
-"::MIN, true));",
-$EndFeature, "
-```"),
-            #[stable(feature = "no_panic_abs", since = "1.13.0")]
-            #[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)
-            }
-        }
-
-        doc_comment! {
-            concat!("Raises self to the power of `exp`, using exponentiation by squaring.
-
-Returns a tuple of the exponentiation along with a bool indicating
-whether an overflow happened.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(3", stringify!($SelfT), ".overflowing_pow(4), (81, false));
-assert_eq!(3i8.overflowing_pow(5), (-13, true));",
-$EndFeature, "
-```"),
-            #[stable(feature = "no_panic_pow", since = "1.34.0")]
-            #[rustc_const_stable(feature = "const_int_pow", since = "1.50.0")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn overflowing_pow(self, mut exp: u32) -> (Self, bool) {
-                if exp == 0 {
-                    return (1,false);
-                }
-                let mut base = self;
-                let mut acc: Self = 1;
-                let mut overflown = false;
-                // Scratch space for storing results of overflowing_mul.
-                let mut r;
-
-                while exp > 1 {
-                    if (exp & 1) == 1 {
-                        r = acc.overflowing_mul(base);
-                        acc = r.0;
-                        overflown |= r.1;
-                    }
-                    exp /= 2;
-                    r = base.overflowing_mul(base);
-                    base = r.0;
+                exp /= 2;
+                base = base.wrapping_mul(base);
+            }
+
+            // since exp!=0, finally the exp must be 1.
+            // Deal with the final bit of the exponent separately, since
+            // squaring the base afterwards is not necessary and may cause a
+            // needless overflow.
+            acc.wrapping_mul(base)
+        }
+
+        /// Calculates `self` + `rhs`
+        ///
+        /// Returns a tuple of the addition along with a boolean indicating whether an arithmetic overflow would
+        /// occur. If an overflow would have occurred then the wrapped value is returned.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        ///
+        #[doc = concat!("assert_eq!(5", stringify!($SelfT), ".overflowing_add(2), (7, false));")]
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MAX.overflowing_add(1), (", stringify!($SelfT), "::MIN, true));")]
+        /// ```
+        #[stable(feature = "wrapping", since = "1.7.0")]
+        #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn overflowing_add(self, rhs: Self) -> (Self, bool) {
+            let (a, b) = intrinsics::add_with_overflow(self as $ActualT, rhs as $ActualT);
+            (a as Self, b)
+        }
+
+        /// Calculates `self` - `rhs`
+        ///
+        /// Returns a tuple of the subtraction along with a boolean indicating whether an arithmetic overflow
+        /// would occur. If an overflow would have occurred then the wrapped value is returned.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        ///
+        #[doc = concat!("assert_eq!(5", stringify!($SelfT), ".overflowing_sub(2), (3, false));")]
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MIN.overflowing_sub(1), (", stringify!($SelfT), "::MAX, true));")]
+        /// ```
+        #[stable(feature = "wrapping", since = "1.7.0")]
+        #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn overflowing_sub(self, rhs: Self) -> (Self, bool) {
+            let (a, b) = intrinsics::sub_with_overflow(self as $ActualT, rhs as $ActualT);
+            (a as Self, b)
+        }
+
+        /// Calculates the multiplication of `self` and `rhs`.
+        ///
+        /// Returns a tuple of the multiplication along with a boolean indicating whether an arithmetic overflow
+        /// would occur. If an overflow would have occurred then the wrapped value is returned.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(5", stringify!($SelfT), ".overflowing_mul(2), (10, false));")]
+        /// assert_eq!(1_000_000_000i32.overflowing_mul(10), (1410065408, true));
+        /// ```
+        #[stable(feature = "wrapping", since = "1.7.0")]
+        #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn overflowing_mul(self, rhs: Self) -> (Self, bool) {
+            let (a, b) = intrinsics::mul_with_overflow(self as $ActualT, rhs as $ActualT);
+            (a as Self, b)
+        }
+
+        /// Calculates the divisor when `self` is divided by `rhs`.
+        ///
+        /// Returns a tuple of the divisor along with a boolean indicating whether an arithmetic overflow would
+        /// occur. If an overflow would occur then self is returned.
+        ///
+        /// # Panics
+        ///
+        /// This function will panic if `rhs` is 0.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        ///
+        #[doc = concat!("assert_eq!(5", stringify!($SelfT), ".overflowing_div(2), (2, false));")]
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MIN.overflowing_div(-1), (", stringify!($SelfT), "::MIN, true));")]
+        /// ```
+        #[inline]
+        #[stable(feature = "wrapping", since = "1.7.0")]
+        #[rustc_const_unstable(feature = "const_overflowing_int_methods", issue = "53718")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        pub const fn overflowing_div(self, rhs: Self) -> (Self, bool) {
+            if unlikely!(self == Self::MIN && rhs == -1) {
+                (self, true)
+            } else {
+                (self / rhs, false)
+            }
+        }
+
+        /// Calculates the quotient of Euclidean division `self.div_euclid(rhs)`.
+        ///
+        /// Returns a tuple of the divisor along with a boolean indicating whether an arithmetic overflow would
+        /// occur. If an overflow would occur then `self` is returned.
+        ///
+        /// # Panics
+        ///
+        /// This function will panic if `rhs` is 0.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(5", stringify!($SelfT), ".overflowing_div_euclid(2), (2, false));")]
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MIN.overflowing_div_euclid(-1), (", stringify!($SelfT), "::MIN, true));")]
+        /// ```
+        #[inline]
+        #[stable(feature = "euclidean_division", since = "1.38.0")]
+        #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")]
+        #[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 unlikely!(self == Self::MIN && rhs == -1) {
+                (self, true)
+            } else {
+                (self.div_euclid(rhs), false)
+            }
+        }
+
+        /// Calculates the remainder when `self` is divided by `rhs`.
+        ///
+        /// Returns a tuple of the remainder after dividing along with a boolean indicating whether an
+        /// arithmetic overflow would occur. If an overflow would occur then 0 is returned.
+        ///
+        /// # Panics
+        ///
+        /// This function will panic if `rhs` is 0.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        ///
+        #[doc = concat!("assert_eq!(5", stringify!($SelfT), ".overflowing_rem(2), (1, false));")]
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MIN.overflowing_rem(-1), (0, true));")]
+        /// ```
+        #[inline]
+        #[stable(feature = "wrapping", since = "1.7.0")]
+        #[rustc_const_unstable(feature = "const_overflowing_int_methods", issue = "53718")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        pub const fn overflowing_rem(self, rhs: Self) -> (Self, bool) {
+            if unlikely!(self == Self::MIN && rhs == -1) {
+                (0, true)
+            } else {
+                (self % rhs, false)
+            }
+        }
+
+
+        /// Overflowing Euclidean remainder. Calculates `self.rem_euclid(rhs)`.
+        ///
+        /// Returns a tuple of the remainder after dividing along with a boolean indicating whether an
+        /// arithmetic overflow would occur. If an overflow would occur then 0 is returned.
+        ///
+        /// # Panics
+        ///
+        /// This function will panic if `rhs` is 0.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(5", stringify!($SelfT), ".overflowing_rem_euclid(2), (1, false));")]
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MIN.overflowing_rem_euclid(-1), (0, true));")]
+        /// ```
+        #[stable(feature = "euclidean_division", since = "1.38.0")]
+        #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn overflowing_rem_euclid(self, rhs: Self) -> (Self, bool) {
+            if unlikely!(self == Self::MIN && rhs == -1) {
+                (0, true)
+            } else {
+                (self.rem_euclid(rhs), false)
+            }
+        }
+
+
+        /// Negates self, overflowing if this is equal to the minimum value.
+        ///
+        /// Returns a tuple of the negated version of self along with a boolean indicating whether an overflow
+        /// happened. If `self` is the minimum value (e.g., `i32::MIN` for values of type `i32`), then the
+        /// minimum value will be returned again and `true` will be returned for an overflow happening.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(2", stringify!($SelfT), ".overflowing_neg(), (-2, false));")]
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MIN.overflowing_neg(), (", stringify!($SelfT), "::MIN, true));")]
+        /// ```
+        #[inline]
+        #[stable(feature = "wrapping", since = "1.7.0")]
+        #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
+        #[allow(unused_attributes)]
+        pub const fn overflowing_neg(self) -> (Self, bool) {
+            if unlikely!(self == Self::MIN) {
+                (Self::MIN, true)
+            } else {
+                (-self, false)
+            }
+        }
+
+        /// Shifts self left by `rhs` bits.
+        ///
+        /// Returns a tuple of the shifted version of self along with a boolean indicating whether the shift
+        /// value was larger than or equal to the number of bits. If the shift value is too large, then value is
+        /// masked (N-1) where N is the number of bits, and this value is then used to perform the shift.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(0x1", stringify!($SelfT),".overflowing_shl(4), (0x10, false));")]
+        /// assert_eq!(0x1i32.overflowing_shl(36), (0x10, true));
+        /// ```
+        #[stable(feature = "wrapping", since = "1.7.0")]
+        #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn overflowing_shl(self, rhs: u32) -> (Self, bool) {
+            (self.wrapping_shl(rhs), (rhs > ($BITS - 1)))
+        }
+
+        /// Shifts self right by `rhs` bits.
+        ///
+        /// Returns a tuple of the shifted version of self along with a boolean indicating whether the shift
+        /// value was larger than or equal to the number of bits. If the shift value is too large, then value is
+        /// masked (N-1) where N is the number of bits, and this value is then used to perform the shift.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".overflowing_shr(4), (0x1, false));")]
+        /// assert_eq!(0x10i32.overflowing_shr(36), (0x1, true));
+        /// ```
+        #[stable(feature = "wrapping", since = "1.7.0")]
+        #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn overflowing_shr(self, rhs: u32) -> (Self, bool) {
+            (self.wrapping_shr(rhs), (rhs > ($BITS - 1)))
+        }
+
+        /// Computes the absolute value of `self`.
+        ///
+        /// Returns a tuple of the absolute version of self along with a boolean indicating whether an overflow
+        /// happened. If self is the minimum value
+        #[doc = concat!("(e.g., ", stringify!($SelfT), "::MIN for values of type ", stringify!($SelfT), "),")]
+        /// then the minimum value will be returned again and true will be returned
+        /// for an overflow happening.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(10", stringify!($SelfT), ".overflowing_abs(), (10, false));")]
+        #[doc = concat!("assert_eq!((-10", stringify!($SelfT), ").overflowing_abs(), (10, false));")]
+        #[doc = concat!("assert_eq!((", stringify!($SelfT), "::MIN).overflowing_abs(), (", stringify!($SelfT), "::MIN, true));")]
+        /// ```
+        #[stable(feature = "no_panic_abs", since = "1.13.0")]
+        #[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)
+        }
+
+        /// Raises self to the power of `exp`, using exponentiation by squaring.
+        ///
+        /// Returns a tuple of the exponentiation along with a bool indicating
+        /// whether an overflow happened.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(3", stringify!($SelfT), ".overflowing_pow(4), (81, false));")]
+        /// assert_eq!(3i8.overflowing_pow(5), (-13, true));
+        /// ```
+        #[stable(feature = "no_panic_pow", since = "1.34.0")]
+        #[rustc_const_stable(feature = "const_int_pow", since = "1.50.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn overflowing_pow(self, mut exp: u32) -> (Self, bool) {
+            if exp == 0 {
+                return (1,false);
+            }
+            let mut base = self;
+            let mut acc: Self = 1;
+            let mut overflown = false;
+            // Scratch space for storing results of overflowing_mul.
+            let mut r;
+
+            while exp > 1 {
+                if (exp & 1) == 1 {
+                    r = acc.overflowing_mul(base);
+                    acc = r.0;
                     overflown |= r.1;
                 }
-
-                // since exp!=0, finally the exp must be 1.
-                // Deal with the final bit of the exponent separately, since
-                // squaring the base afterwards is not necessary and may cause a
-                // needless overflow.
-                r = acc.overflowing_mul(base);
-                r.1 |= overflown;
-                r
-            }
-        }
-
-        doc_comment! {
-            concat!("Raises self to the power of `exp`, using exponentiation by squaring.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "let x: ", stringify!($SelfT), " = 2; // or any other integer type
-
-assert_eq!(x.pow(5), 32);",
-$EndFeature, "
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_int_pow", since = "1.50.0")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            #[rustc_inherit_overflow_checks]
-            pub const fn pow(self, mut exp: u32) -> Self {
-                if exp == 0 {
-                    return 1;
-                }
-                let mut base = self;
-                let mut acc = 1;
-
-                while exp > 1 {
-                    if (exp & 1) == 1 {
-                        acc = acc * base;
-                    }
-                    exp /= 2;
-                    base = base * base;
+                exp /= 2;
+                r = base.overflowing_mul(base);
+                base = r.0;
+                overflown |= r.1;
+            }
+
+            // since exp!=0, finally the exp must be 1.
+            // Deal with the final bit of the exponent separately, since
+            // squaring the base afterwards is not necessary and may cause a
+            // needless overflow.
+            r = acc.overflowing_mul(base);
+            r.1 |= overflown;
+            r
+        }
+
+        /// Raises self to the power of `exp`, using exponentiation by squaring.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("let x: ", stringify!($SelfT), " = 2; // or any other integer type")]
+        ///
+        /// assert_eq!(x.pow(5), 32);
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_int_pow", since = "1.50.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        #[rustc_inherit_overflow_checks]
+        pub const fn pow(self, mut exp: u32) -> Self {
+            if exp == 0 {
+                return 1;
+            }
+            let mut base = self;
+            let mut acc = 1;
+
+            while exp > 1 {
+                if (exp & 1) == 1 {
+                    acc = acc * base;
                 }
-
-                // since exp!=0, finally the exp must be 1.
-                // Deal with the final bit of the exponent separately, since
-                // squaring the base afterwards is not necessary and may cause a
-                // needless overflow.
-                acc * base
-            }
-        }
-
-        doc_comment! {
-            concat!("Calculates the quotient of Euclidean division of `self` by `rhs`.
-
-This computes the integer `n` such that `self = n * rhs + self.rem_euclid(rhs)`,
-with `0 <= self.rem_euclid(rhs) < rhs`.
-
-In other words, the result is `self / rhs` rounded to the integer `n`
-such that `self >= n * rhs`.
-If `self > 0`, this is equal to round towards zero (the default in Rust);
-if `self < 0`, this is equal to round towards +/- infinity.
-
-# Panics
-
-This function will panic if `rhs` is 0 or the division results in overflow.
-
-# Examples
-
-Basic usage:
-
-```
-let a: ", stringify!($SelfT), " = 7; // or any other integer type
-let b = 4;
-
-assert_eq!(a.div_euclid(b), 1); // 7 >= 4 * 1
-assert_eq!(a.div_euclid(-b), -1); // 7 >= -4 * -1
-assert_eq!((-a).div_euclid(b), -2); // -7 >= 4 * -2
-assert_eq!((-a).div_euclid(-b), 2); // -7 >= -4 * 2
-```"),
-            #[stable(feature = "euclidean_division", since = "1.38.0")]
-            #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            #[rustc_inherit_overflow_checks]
-            pub const fn div_euclid(self, rhs: Self) -> Self {
-                let q = self / rhs;
-                if self % rhs < 0 {
-                    return if rhs > 0 { q - 1 } else { q + 1 }
-                }
-                q
-            }
-        }
-
-
-        doc_comment! {
-            concat!("Calculates the least nonnegative remainder of `self (mod rhs)`.
-
-This is done as if by the Euclidean division algorithm -- given
-`r = self.rem_euclid(rhs)`, `self = rhs * self.div_euclid(rhs) + r`, and
-`0 <= r < abs(rhs)`.
-
-# Panics
-
-This function will panic if `rhs` is 0 or the division results in overflow.
-
-# Examples
-
-Basic usage:
-
-```
-let a: ", stringify!($SelfT), " = 7; // or any other integer type
-let b = 4;
-
-assert_eq!(a.rem_euclid(b), 3);
-assert_eq!((-a).rem_euclid(b), 1);
-assert_eq!(a.rem_euclid(-b), 3);
-assert_eq!((-a).rem_euclid(-b), 1);
-```"),
-            #[stable(feature = "euclidean_division", since = "1.38.0")]
-            #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            #[rustc_inherit_overflow_checks]
-            pub const fn rem_euclid(self, rhs: Self) -> Self {
-                let r = self % rhs;
-                if r < 0 {
-                    if rhs < 0 {
-                        r - rhs
-                    } else {
-                        r + rhs
-                    }
+                exp /= 2;
+                base = base * base;
+            }
+
+            // since exp!=0, finally the exp must be 1.
+            // Deal with the final bit of the exponent separately, since
+            // squaring the base afterwards is not necessary and may cause a
+            // needless overflow.
+            acc * base
+        }
+
+        /// Calculates the quotient of Euclidean division of `self` by `rhs`.
+        ///
+        /// This computes the integer `n` such that `self = n * rhs + self.rem_euclid(rhs)`,
+        /// with `0 <= self.rem_euclid(rhs) < rhs`.
+        ///
+        /// In other words, the result is `self / rhs` rounded to the integer `n`
+        /// such that `self >= n * rhs`.
+        /// If `self > 0`, this is equal to round towards zero (the default in Rust);
+        /// if `self < 0`, this is equal to round towards +/- infinity.
+        ///
+        /// # Panics
+        ///
+        /// This function will panic if `rhs` is 0 or the division results in overflow.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("let a: ", stringify!($SelfT), " = 7; // or any other integer type")]
+        /// let b = 4;
+        ///
+        /// assert_eq!(a.div_euclid(b), 1); // 7 >= 4 * 1
+        /// assert_eq!(a.div_euclid(-b), -1); // 7 >= -4 * -1
+        /// assert_eq!((-a).div_euclid(b), -2); // -7 >= 4 * -2
+        /// assert_eq!((-a).div_euclid(-b), 2); // -7 >= -4 * 2
+        /// ```
+        #[stable(feature = "euclidean_division", since = "1.38.0")]
+        #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        #[rustc_inherit_overflow_checks]
+        pub const fn div_euclid(self, rhs: Self) -> Self {
+            let q = self / rhs;
+            if self % rhs < 0 {
+                return if rhs > 0 { q - 1 } else { q + 1 }
+            }
+            q
+        }
+
+
+        /// Calculates the least nonnegative remainder of `self (mod rhs)`.
+        ///
+        /// This is done as if by the Euclidean division algorithm -- given
+        /// `r = self.rem_euclid(rhs)`, `self = rhs * self.div_euclid(rhs) + r`, and
+        /// `0 <= r < abs(rhs)`.
+        ///
+        /// # Panics
+        ///
+        /// This function will panic if `rhs` is 0 or the division results in overflow.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("let a: ", stringify!($SelfT), " = 7; // or any other integer type")]
+        /// let b = 4;
+        ///
+        /// assert_eq!(a.rem_euclid(b), 3);
+        /// assert_eq!((-a).rem_euclid(b), 1);
+        /// assert_eq!(a.rem_euclid(-b), 3);
+        /// assert_eq!((-a).rem_euclid(-b), 1);
+        /// ```
+        #[stable(feature = "euclidean_division", since = "1.38.0")]
+        #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        #[rustc_inherit_overflow_checks]
+        pub const fn rem_euclid(self, rhs: Self) -> Self {
+            let r = self % rhs;
+            if r < 0 {
+                if rhs < 0 {
+                    r - rhs
                 } else {
-                    r
+                    r + rhs
                 }
+            } else {
+                r
             }
         }
 
-        doc_comment! {
-            concat!("Computes the absolute value of `self`.
-
-# Overflow behavior
-
-The absolute value of `", stringify!($SelfT), "::MIN` cannot be represented as an
-`", stringify!($SelfT), "`, and attempting to calculate it will cause an overflow. This means that
-code in debug mode will trigger a panic on this case and optimized code will return `",
-stringify!($SelfT), "::MIN` without a panic.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(10", stringify!($SelfT), ".abs(), 10);
-assert_eq!((-10", stringify!($SelfT), ").abs(), 10);",
-$EndFeature, "
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
-            #[allow(unused_attributes)]
-            #[inline]
-            #[rustc_inherit_overflow_checks]
-            pub const fn abs(self) -> Self {
-                // Note that the #[inline] above means that the overflow
-                // semantics of the subtraction depend on the crate we're being
-                // inlined into.
-                if self.is_negative() {
-                    -self
-                } else {
-                    self
-                }
-            }
-        }
-
-        doc_comment! {
-            concat!("Returns a number representing sign of `self`.
-
- - `0` if the number is zero
- - `1` if the number is positive
- - `-1` if the number is negative
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(10", stringify!($SelfT), ".signum(), 1);
-assert_eq!(0", stringify!($SelfT), ".signum(), 0);
-assert_eq!((-10", stringify!($SelfT), ").signum(), -1);",
-$EndFeature, "
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_int_sign", since = "1.47.0")]
-            #[inline]
-            pub const fn signum(self) -> Self {
-                match self {
-                    n if n > 0 =>  1,
-                    0          =>  0,
-                    _          => -1,
-                }
-            }
-        }
-
-        doc_comment! {
-            concat!("Returns `true` if `self` is positive and `false` if the number is zero or
-negative.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert!(10", stringify!($SelfT), ".is_positive());
-assert!(!(-10", stringify!($SelfT), ").is_positive());",
-$EndFeature, "
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
-            #[inline]
-            pub const fn is_positive(self) -> bool { self > 0 }
-        }
-
-        doc_comment! {
-            concat!("Returns `true` if `self` is negative and `false` if the number is zero or
-positive.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert!((-10", stringify!($SelfT), ").is_negative());
-assert!(!10", stringify!($SelfT), ".is_negative());",
-$EndFeature, "
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
-            #[inline]
-            pub const fn is_negative(self) -> bool { self < 0 }
-        }
-
-        doc_comment! {
-            concat!("Return the memory representation of this integer as a byte array in
-big-endian (network) byte order.
-",
-$to_xe_bytes_doc,
-"
-# Examples
-
-```
-let bytes = ", $swap_op, stringify!($SelfT), ".to_be_bytes();
-assert_eq!(bytes, ", $be_bytes, ");
-```"),
-            #[stable(feature = "int_to_from_bytes", since = "1.32.0")]
-            #[rustc_const_stable(feature = "const_int_conversion", since = "1.44.0")]
-            #[inline]
-            pub const fn to_be_bytes(self) -> [u8; mem::size_of::<Self>()] {
-                self.to_be().to_ne_bytes()
-            }
-        }
-
-doc_comment! {
-            concat!("Return the memory representation of this integer as a byte array in
-little-endian byte order.
-",
-$to_xe_bytes_doc,
-"
-# Examples
-
-```
-let bytes = ", $swap_op, stringify!($SelfT), ".to_le_bytes();
-assert_eq!(bytes, ", $le_bytes, ");
-```"),
-            #[stable(feature = "int_to_from_bytes", since = "1.32.0")]
-            #[rustc_const_stable(feature = "const_int_conversion", since = "1.44.0")]
-            #[inline]
-            pub const fn to_le_bytes(self) -> [u8; mem::size_of::<Self>()] {
-                self.to_le().to_ne_bytes()
-            }
-        }
-
-        doc_comment! {
-            concat!("
-Return the memory representation of this integer as a byte array in
-native byte order.
-
-As the target platform's native endianness is used, portable code
-should use [`to_be_bytes`] or [`to_le_bytes`], as appropriate,
-instead.
-",
-$to_xe_bytes_doc,
-"
-[`to_be_bytes`]: #method.to_be_bytes
-[`to_le_bytes`]: #method.to_le_bytes
-
-# Examples
-
-```
-let bytes = ", $swap_op, stringify!($SelfT), ".to_ne_bytes();
-assert_eq!(
-    bytes,
-    if cfg!(target_endian = \"big\") {
-        ", $be_bytes, "
-    } else {
-        ", $le_bytes, "
-    }
-);
-```"),
-            #[stable(feature = "int_to_from_bytes", since = "1.32.0")]
-            #[rustc_const_stable(feature = "const_int_conversion", since = "1.44.0")]
-            // SAFETY: const sound because integers are plain old datatypes so we can always
-            // transmute them to arrays of bytes
-            #[rustc_allow_const_fn_unstable(const_fn_transmute)]
-            #[inline]
-            pub const fn to_ne_bytes(self) -> [u8; mem::size_of::<Self>()] {
-                // SAFETY: integers are plain old datatypes so we can always transmute them to
-                // arrays of bytes
-                unsafe { mem::transmute(self) }
-            }
-        }
-
-        doc_comment! {
-            concat!("
-Return the memory representation of this integer as a byte array in
-native byte order.
-
-[`to_ne_bytes`] should be preferred over this whenever possible.
-
-[`to_ne_bytes`]: #method.to_ne_bytes
-",
-
-"
-# Examples
-
-```
-#![feature(num_as_ne_bytes)]
-let num = ", $swap_op, stringify!($SelfT), ";
-let bytes = num.as_ne_bytes();
-assert_eq!(
-    bytes,
-    if cfg!(target_endian = \"big\") {
-        &", $be_bytes, "
-    } else {
-        &", $le_bytes, "
-    }
-);
-```"),
-            #[unstable(feature = "num_as_ne_bytes", issue = "76976")]
-            #[inline]
-            pub fn as_ne_bytes(&self) -> &[u8; mem::size_of::<Self>()] {
-                // SAFETY: integers are plain old datatypes so we can always transmute them to
-                // arrays of bytes
-                unsafe { &*(self as *const Self as *const _) }
-            }
-        }
-
-doc_comment! {
-            concat!("Create an integer value from its representation as a byte array in
-big endian.
-",
-$from_xe_bytes_doc,
-"
-# Examples
-
-```
-let value = ", stringify!($SelfT), "::from_be_bytes(", $be_bytes, ");
-assert_eq!(value, ", $swap_op, ");
-```
-
-When starting from a slice rather than an array, fallible conversion APIs can be used:
-
-```
-use std::convert::TryInto;
-
-fn read_be_", stringify!($SelfT), "(input: &mut &[u8]) -> ", stringify!($SelfT), " {
-    let (int_bytes, rest) = input.split_at(std::mem::size_of::<", stringify!($SelfT), ">());
-    *input = rest;
-    ", stringify!($SelfT), "::from_be_bytes(int_bytes.try_into().unwrap())
-}
-```"),
-            #[stable(feature = "int_to_from_bytes", since = "1.32.0")]
-            #[rustc_const_stable(feature = "const_int_conversion", since = "1.44.0")]
-            #[inline]
-            pub const fn from_be_bytes(bytes: [u8; mem::size_of::<Self>()]) -> Self {
-                Self::from_be(Self::from_ne_bytes(bytes))
-            }
-        }
-
-doc_comment! {
-            concat!("
-Create an integer value from its representation as a byte array in
-little endian.
-",
-$from_xe_bytes_doc,
-"
-# Examples
-
-```
-let value = ", stringify!($SelfT), "::from_le_bytes(", $le_bytes, ");
-assert_eq!(value, ", $swap_op, ");
-```
-
-When starting from a slice rather than an array, fallible conversion APIs can be used:
-
-```
-use std::convert::TryInto;
-
-fn read_le_", stringify!($SelfT), "(input: &mut &[u8]) -> ", stringify!($SelfT), " {
-    let (int_bytes, rest) = input.split_at(std::mem::size_of::<", stringify!($SelfT), ">());
-    *input = rest;
-    ", stringify!($SelfT), "::from_le_bytes(int_bytes.try_into().unwrap())
-}
-```"),
-            #[stable(feature = "int_to_from_bytes", since = "1.32.0")]
-            #[rustc_const_stable(feature = "const_int_conversion", since = "1.44.0")]
-            #[inline]
-            pub const fn from_le_bytes(bytes: [u8; mem::size_of::<Self>()]) -> Self {
-                Self::from_le(Self::from_ne_bytes(bytes))
-            }
-        }
-
-        doc_comment! {
-            concat!("Create an integer value from its memory representation as a byte
-array in native endianness.
-
-As the target platform's native endianness is used, portable code
-likely wants to use [`from_be_bytes`] or [`from_le_bytes`], as
-appropriate instead.
-
-[`from_be_bytes`]: #method.from_be_bytes
-[`from_le_bytes`]: #method.from_le_bytes
-",
-$from_xe_bytes_doc,
-"
-# Examples
-
-```
-let value = ", stringify!($SelfT), "::from_ne_bytes(if cfg!(target_endian = \"big\") {
-    ", $be_bytes, "
-} else {
-    ", $le_bytes, "
-});
-assert_eq!(value, ", $swap_op, ");
-```
-
-When starting from a slice rather than an array, fallible conversion APIs can be used:
-
-```
-use std::convert::TryInto;
-
-fn read_ne_", stringify!($SelfT), "(input: &mut &[u8]) -> ", stringify!($SelfT), " {
-    let (int_bytes, rest) = input.split_at(std::mem::size_of::<", stringify!($SelfT), ">());
-    *input = rest;
-    ", stringify!($SelfT), "::from_ne_bytes(int_bytes.try_into().unwrap())
-}
-```"),
-            #[stable(feature = "int_to_from_bytes", since = "1.32.0")]
-            #[rustc_const_stable(feature = "const_int_conversion", since = "1.44.0")]
-            // SAFETY: const sound because integers are plain old datatypes so we can always
-            // transmute to them
-            #[rustc_allow_const_fn_unstable(const_fn_transmute)]
-            #[inline]
-            pub const fn from_ne_bytes(bytes: [u8; mem::size_of::<Self>()]) -> Self {
-                // SAFETY: integers are plain old datatypes so we can always transmute to them
-                unsafe { mem::transmute(bytes) }
-            }
-        }
-
-        doc_comment! {
-            concat!("**This method is soft-deprecated.**
-
-Although using it won’t cause a compilation warning,
-new code should use [`", stringify!($SelfT), "::MIN", "`](#associatedconstant.MIN) instead.
-
-Returns the smallest value that can be represented by this integer type."),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[inline(always)]
-            #[rustc_promotable]
-            #[rustc_const_stable(feature = "const_min_value", since = "1.32.0")]
-            pub const fn min_value() -> Self {
-                Self::MIN
-            }
-        }
-
-        doc_comment! {
-            concat!("**This method is soft-deprecated.**
-
-Although using it won’t cause a compilation warning,
-new code should use [`", stringify!($SelfT), "::MAX", "`](#associatedconstant.MAX) instead.
-
-Returns the largest value that can be represented by this integer type."),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[inline(always)]
-            #[rustc_promotable]
-            #[rustc_const_stable(feature = "const_max_value", since = "1.32.0")]
-            pub const fn max_value() -> Self {
-                Self::MAX
-            }
+        /// Computes the absolute value of `self`.
+        ///
+        /// # Overflow behavior
+        ///
+        /// The absolute value of
+        #[doc = concat!("`", stringify!($SelfT), "::MIN`")]
+        /// cannot be represented as an
+        #[doc = concat!("`", stringify!($SelfT), "`,")]
+        /// and attempting to calculate it will cause an overflow. This means
+        /// that code in debug mode will trigger a panic on this case and
+        /// optimized code will return
+        #[doc = concat!("`", stringify!($SelfT), "::MIN`")]
+        /// without a panic.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(10", stringify!($SelfT), ".abs(), 10);")]
+        #[doc = concat!("assert_eq!((-10", stringify!($SelfT), ").abs(), 10);")]
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
+        #[allow(unused_attributes)]
+        #[inline]
+        #[rustc_inherit_overflow_checks]
+        pub const fn abs(self) -> Self {
+            // Note that the #[inline] above means that the overflow
+            // semantics of the subtraction depend on the crate we're being
+            // inlined into.
+            if self.is_negative() {
+                -self
+            } else {
+                self
+            }
+        }
+
+        /// Returns a number representing sign of `self`.
+        ///
+        ///  - `0` if the number is zero
+        ///  - `1` if the number is positive
+        ///  - `-1` if the number is negative
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(10", stringify!($SelfT), ".signum(), 1);")]
+        #[doc = concat!("assert_eq!(0", stringify!($SelfT), ".signum(), 0);")]
+        #[doc = concat!("assert_eq!((-10", stringify!($SelfT), ").signum(), -1);")]
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_int_sign", since = "1.47.0")]
+        #[inline]
+        pub const fn signum(self) -> Self {
+            match self {
+                n if n > 0 =>  1,
+                0          =>  0,
+                _          => -1,
+            }
+        }
+
+        /// Returns `true` if `self` is positive and `false` if the number is zero or
+        /// negative.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert!(10", stringify!($SelfT), ".is_positive());")]
+        #[doc = concat!("assert!(!(-10", stringify!($SelfT), ").is_positive());")]
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
+        #[inline]
+        pub const fn is_positive(self) -> bool { self > 0 }
+
+        /// Returns `true` if `self` is negative and `false` if the number is zero or
+        /// positive.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert!((-10", stringify!($SelfT), ").is_negative());")]
+        #[doc = concat!("assert!(!10", stringify!($SelfT), ".is_negative());")]
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
+        #[inline]
+        pub const fn is_negative(self) -> bool { self < 0 }
+
+        /// Return the memory representation of this integer as a byte array in
+        /// big-endian (network) byte order.
+        ///
+        #[doc = $to_xe_bytes_doc]
+        ///
+        /// # Examples
+        ///
+        /// ```
+        #[doc = concat!("let bytes = ", $swap_op, stringify!($SelfT), ".to_be_bytes();")]
+        #[doc = concat!("assert_eq!(bytes, ", $be_bytes, ");")]
+        /// ```
+        #[stable(feature = "int_to_from_bytes", since = "1.32.0")]
+        #[rustc_const_stable(feature = "const_int_conversion", since = "1.44.0")]
+        #[inline]
+        pub const fn to_be_bytes(self) -> [u8; mem::size_of::<Self>()] {
+            self.to_be().to_ne_bytes()
+        }
+
+        /// Return the memory representation of this integer as a byte array in
+        /// little-endian byte order.
+        ///
+        #[doc = $to_xe_bytes_doc]
+        ///
+        /// # Examples
+        ///
+        /// ```
+        #[doc = concat!("let bytes = ", $swap_op, stringify!($SelfT), ".to_le_bytes();")]
+        #[doc = concat!("assert_eq!(bytes, ", $le_bytes, ");")]
+        /// ```
+        #[stable(feature = "int_to_from_bytes", since = "1.32.0")]
+        #[rustc_const_stable(feature = "const_int_conversion", since = "1.44.0")]
+        #[inline]
+        pub const fn to_le_bytes(self) -> [u8; mem::size_of::<Self>()] {
+            self.to_le().to_ne_bytes()
+        }
+
+        /// Return the memory representation of this integer as a byte array in
+        /// native byte order.
+        ///
+        /// As the target platform's native endianness is used, portable code
+        /// should use [`to_be_bytes`] or [`to_le_bytes`], as appropriate,
+        /// instead.
+        ///
+        #[doc = $to_xe_bytes_doc]
+        ///
+        /// [`to_be_bytes`]: #method.to_be_bytes
+        /// [`to_le_bytes`]: #method.to_le_bytes
+        ///
+        /// # Examples
+        ///
+        /// ```
+        #[doc = concat!("let bytes = ", $swap_op, stringify!($SelfT), ".to_ne_bytes();")]
+        /// assert_eq!(
+        ///     bytes,
+        ///     if cfg!(target_endian = "big") {
+        #[doc = concat!("        ", $be_bytes)]
+        ///     } else {
+        #[doc = concat!("        ", $le_bytes)]
+        ///     }
+        /// );
+        /// ```
+        #[stable(feature = "int_to_from_bytes", since = "1.32.0")]
+        #[rustc_const_stable(feature = "const_int_conversion", since = "1.44.0")]
+        // SAFETY: const sound because integers are plain old datatypes so we can always
+        // transmute them to arrays of bytes
+        #[rustc_allow_const_fn_unstable(const_fn_transmute)]
+        #[inline]
+        pub const fn to_ne_bytes(self) -> [u8; mem::size_of::<Self>()] {
+            // SAFETY: integers are plain old datatypes so we can always transmute them to
+            // arrays of bytes
+            unsafe { mem::transmute(self) }
+        }
+
+        /// Return the memory representation of this integer as a byte array in
+        /// native byte order.
+        ///
+        /// [`to_ne_bytes`] should be preferred over this whenever possible.
+        ///
+        /// [`to_ne_bytes`]: #method.to_ne_bytes
+        ///
+        /// # Examples
+        ///
+        /// ```
+        /// #![feature(num_as_ne_bytes)]
+        #[doc = concat!("let num = ", $swap_op, stringify!($SelfT), ";")]
+        /// let bytes = num.as_ne_bytes();
+        /// assert_eq!(
+        ///     bytes,
+        ///     if cfg!(target_endian = "big") {
+        #[doc = concat!("        &", $be_bytes)]
+        ///     } else {
+        #[doc = concat!("        &", $le_bytes)]
+        ///     }
+        /// );
+        /// ```
+        #[unstable(feature = "num_as_ne_bytes", issue = "76976")]
+        #[inline]
+        pub fn as_ne_bytes(&self) -> &[u8; mem::size_of::<Self>()] {
+            // SAFETY: integers are plain old datatypes so we can always transmute them to
+            // arrays of bytes
+            unsafe { &*(self as *const Self as *const _) }
+        }
+
+        /// Create an integer value from its representation as a byte array in
+        /// big endian.
+        ///
+        #[doc = $to_xe_bytes_doc]
+        ///
+        /// # Examples
+        ///
+        /// ```
+        #[doc = concat!("let value = ", stringify!($SelfT), "::from_be_bytes(", $be_bytes, ");")]
+        #[doc = concat!("assert_eq!(value, ", $swap_op, ");")]
+        /// ```
+        ///
+        /// When starting from a slice rather than an array, fallible conversion APIs can be used:
+        ///
+        /// ```
+        /// use std::convert::TryInto;
+        ///
+        #[doc = concat!("fn read_be_", stringify!($SelfT), "(input: &mut &[u8]) -> ", stringify!($SelfT), " {")]
+        #[doc = concat!("    let (int_bytes, rest) = input.split_at(std::mem::size_of::<", stringify!($SelfT), ">());")]
+        ///     *input = rest;
+        #[doc = concat!("    ", stringify!($SelfT), "::from_be_bytes(int_bytes.try_into().unwrap())")]
+        /// }
+        /// ```
+        #[stable(feature = "int_to_from_bytes", since = "1.32.0")]
+        #[rustc_const_stable(feature = "const_int_conversion", since = "1.44.0")]
+        #[inline]
+        pub const fn from_be_bytes(bytes: [u8; mem::size_of::<Self>()]) -> Self {
+            Self::from_be(Self::from_ne_bytes(bytes))
+        }
+
+        /// Create an integer value from its representation as a byte array in
+        /// little endian.
+        ///
+        #[doc = $to_xe_bytes_doc]
+        ///
+        /// # Examples
+        ///
+        /// ```
+        #[doc = concat!("let value = ", stringify!($SelfT), "::from_le_bytes(", $le_bytes, ");")]
+        #[doc = concat!("assert_eq!(value, ", $swap_op, ");")]
+        /// ```
+        ///
+        /// When starting from a slice rather than an array, fallible conversion APIs can be used:
+        ///
+        /// ```
+        /// use std::convert::TryInto;
+        ///
+        #[doc = concat!("fn read_le_", stringify!($SelfT), "(input: &mut &[u8]) -> ", stringify!($SelfT), " {")]
+        #[doc = concat!("    let (int_bytes, rest) = input.split_at(std::mem::size_of::<", stringify!($SelfT), ">());")]
+        ///     *input = rest;
+        #[doc = concat!("    ", stringify!($SelfT), "::from_le_bytes(int_bytes.try_into().unwrap())")]
+        /// }
+        /// ```
+        #[stable(feature = "int_to_from_bytes", since = "1.32.0")]
+        #[rustc_const_stable(feature = "const_int_conversion", since = "1.44.0")]
+        #[inline]
+        pub const fn from_le_bytes(bytes: [u8; mem::size_of::<Self>()]) -> Self {
+            Self::from_le(Self::from_ne_bytes(bytes))
+        }
+
+        /// Create an integer value from its memory representation as a byte
+        /// array in native endianness.
+        ///
+        /// As the target platform's native endianness is used, portable code
+        /// likely wants to use [`from_be_bytes`] or [`from_le_bytes`], as
+        /// appropriate instead.
+        ///
+        /// [`from_be_bytes`]: #method.from_be_bytes
+        /// [`from_le_bytes`]: #method.from_le_bytes
+        ///
+        #[doc = $to_xe_bytes_doc]
+        ///
+        /// # Examples
+        ///
+        /// ```
+        #[doc = concat!("let value = ", stringify!($SelfT), "::from_ne_bytes(if cfg!(target_endian = \"big\") {")]
+        #[doc = concat!("    ", $be_bytes)]
+        /// } else {
+        #[doc = concat!("    ", $le_bytes)]
+        /// });
+        #[doc = concat!("assert_eq!(value, ", $swap_op, ");")]
+        /// ```
+        ///
+        /// When starting from a slice rather than an array, fallible conversion APIs can be used:
+        ///
+        /// ```
+        /// use std::convert::TryInto;
+        ///
+        #[doc = concat!("fn read_ne_", stringify!($SelfT), "(input: &mut &[u8]) -> ", stringify!($SelfT), " {")]
+        #[doc = concat!("    let (int_bytes, rest) = input.split_at(std::mem::size_of::<", stringify!($SelfT), ">());")]
+        ///     *input = rest;
+        #[doc = concat!("    ", stringify!($SelfT), "::from_ne_bytes(int_bytes.try_into().unwrap())")]
+        /// }
+        /// ```
+        #[stable(feature = "int_to_from_bytes", since = "1.32.0")]
+        #[rustc_const_stable(feature = "const_int_conversion", since = "1.44.0")]
+        // SAFETY: const sound because integers are plain old datatypes so we can always
+        // transmute to them
+        #[rustc_allow_const_fn_unstable(const_fn_transmute)]
+        #[inline]
+        pub const fn from_ne_bytes(bytes: [u8; mem::size_of::<Self>()]) -> Self {
+            // SAFETY: integers are plain old datatypes so we can always transmute to them
+            unsafe { mem::transmute(bytes) }
+        }
+
+        /// **This method is soft-deprecated.**
+        ///
+        /// Although using it won’t cause a compilation warning, new code should use
+        #[doc = concat!("[`", stringify!($SelfT), "::MIN", "`](#associatedconstant.MIN)")]
+        /// instead.
+        ///
+        /// Returns the smallest value that can be represented by this integer type.
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[inline(always)]
+        #[rustc_promotable]
+        #[rustc_const_stable(feature = "const_min_value", since = "1.32.0")]
+        pub const fn min_value() -> Self {
+            Self::MIN
+        }
+
+        /// **This method is soft-deprecated.**
+        ///
+        /// Although using it won’t cause a compilation warning, new code should use
+        #[doc = concat!("[`", stringify!($SelfT), "::MAX", "`](#associatedconstant.MAX)")]
+        /// instead.
+        ///
+        /// Returns the largest value that can be represented by this integer type.
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[inline(always)]
+        #[rustc_promotable]
+        #[rustc_const_stable(feature = "const_max_value", since = "1.32.0")]
+        pub const fn max_value() -> Self {
+            Self::MAX
         }
     }
 }
diff --git a/library/core/src/num/mod.rs b/library/core/src/num/mod.rs
index 9f5ae57b74a..6bdfa18fa43 100644
--- a/library/core/src/num/mod.rs
+++ b/library/core/src/num/mod.rs
@@ -23,13 +23,6 @@ macro_rules! unlikely {
     };
 }
 
-macro_rules! doc_comment {
-    ($x:expr, $($tt:tt)*) => {
-        #[doc = $x]
-        $($tt)*
-    };
-}
-
 // All these modules are technically private and only exposed for coretests:
 pub mod bignum;
 pub mod dec2flt;
@@ -95,26 +88,26 @@ depending on the target pointer size.
 
 #[lang = "i8"]
 impl i8 {
-    int_impl! { i8, i8, u8, 8, -128, 127, "", "", 2, "-0x7e", "0xa", "0x12", "0x12", "0x48",
+    int_impl! { i8, i8, u8, 8, -128, 127, 2, "-0x7e", "0xa", "0x12", "0x12", "0x48",
     "[0x12]", "[0x12]", "", "" }
 }
 
 #[lang = "i16"]
 impl i16 {
-    int_impl! { i16, i16, u16, 16, -32768, 32767, "", "", 4, "-0x5ffd", "0x3a", "0x1234", "0x3412",
+    int_impl! { i16, i16, u16, 16, -32768, 32767, 4, "-0x5ffd", "0x3a", "0x1234", "0x3412",
     "0x2c48", "[0x34, 0x12]", "[0x12, 0x34]", "", "" }
 }
 
 #[lang = "i32"]
 impl i32 {
-    int_impl! { i32, i32, u32, 32, -2147483648, 2147483647, "", "", 8, "0x10000b3", "0xb301",
+    int_impl! { i32, i32, u32, 32, -2147483648, 2147483647, 8, "0x10000b3", "0xb301",
     "0x12345678", "0x78563412", "0x1e6a2c48", "[0x78, 0x56, 0x34, 0x12]",
     "[0x12, 0x34, 0x56, 0x78]", "", "" }
 }
 
 #[lang = "i64"]
 impl i64 {
-    int_impl! { i64, i64, u64, 64, -9223372036854775808, 9223372036854775807, "", "", 12,
+    int_impl! { i64, i64, u64, 64, -9223372036854775808, 9223372036854775807, 12,
     "0xaa00000000006e1", "0x6e10aa", "0x1234567890123456", "0x5634129078563412",
     "0x6a2c48091e6a2c48", "[0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]",
     "[0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56]", "", "" }
@@ -123,7 +116,7 @@ impl i64 {
 #[lang = "i128"]
 impl i128 {
     int_impl! { i128, i128, u128, 128, -170141183460469231731687303715884105728,
-    170141183460469231731687303715884105727, "", "", 16,
+    170141183460469231731687303715884105727, 16,
     "0x13f40000000000000000000000004f76", "0x4f7613f4", "0x12345678901234567890123456789012",
     "0x12907856341290785634129078563412", "0x48091e6a2c48091e6a2c48091e6a2c48",
     "[0x12, 0x90, 0x78, 0x56, 0x34, 0x12, 0x90, 0x78, \
@@ -135,7 +128,7 @@ impl i128 {
 #[cfg(target_pointer_width = "16")]
 #[lang = "isize"]
 impl isize {
-    int_impl! { isize, i16, usize, 16, -32768, 32767, "", "", 4, "-0x5ffd", "0x3a", "0x1234",
+    int_impl! { isize, i16, usize, 16, -32768, 32767, 4, "-0x5ffd", "0x3a", "0x1234",
     "0x3412", "0x2c48", "[0x34, 0x12]", "[0x12, 0x34]",
     usize_isize_to_xe_bytes_doc!(), usize_isize_from_xe_bytes_doc!() }
 }
@@ -143,7 +136,7 @@ impl isize {
 #[cfg(target_pointer_width = "32")]
 #[lang = "isize"]
 impl isize {
-    int_impl! { isize, i32, usize, 32, -2147483648, 2147483647, "", "", 8, "0x10000b3", "0xb301",
+    int_impl! { isize, i32, usize, 32, -2147483648, 2147483647, 8, "0x10000b3", "0xb301",
     "0x12345678", "0x78563412", "0x1e6a2c48", "[0x78, 0x56, 0x34, 0x12]",
     "[0x12, 0x34, 0x56, 0x78]",
     usize_isize_to_xe_bytes_doc!(), usize_isize_from_xe_bytes_doc!() }
@@ -152,7 +145,7 @@ impl isize {
 #[cfg(target_pointer_width = "64")]
 #[lang = "isize"]
 impl isize {
-    int_impl! { isize, i64, usize, 64, -9223372036854775808, 9223372036854775807, "", "",
+    int_impl! { isize, i64, usize, 64, -9223372036854775808, 9223372036854775807,
     12, "0xaa00000000006e1", "0x6e10aa",  "0x1234567890123456", "0x5634129078563412",
      "0x6a2c48091e6a2c48", "[0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]",
      "[0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56]",
@@ -161,7 +154,7 @@ impl isize {
 
 #[lang = "u8"]
 impl u8 {
-    uint_impl! { u8, u8, 8, 255, "", "", 2, "0x82", "0xa", "0x12", "0x12", "0x48", "[0x12]",
+    uint_impl! { u8, u8, 8, 255, 2, "0x82", "0xa", "0x12", "0x12", "0x48", "[0x12]",
     "[0x12]", "", "" }
 
     /// Checks if the value is within the ASCII range.
@@ -660,19 +653,19 @@ impl u8 {
 
 #[lang = "u16"]
 impl u16 {
-    uint_impl! { u16, u16, 16, 65535, "", "", 4, "0xa003", "0x3a", "0x1234", "0x3412", "0x2c48",
+    uint_impl! { u16, u16, 16, 65535, 4, "0xa003", "0x3a", "0x1234", "0x3412", "0x2c48",
     "[0x34, 0x12]", "[0x12, 0x34]", "", "" }
 }
 
 #[lang = "u32"]
 impl u32 {
-    uint_impl! { u32, u32, 32, 4294967295, "", "", 8, "0x10000b3", "0xb301", "0x12345678",
+    uint_impl! { u32, u32, 32, 4294967295, 8, "0x10000b3", "0xb301", "0x12345678",
     "0x78563412", "0x1e6a2c48", "[0x78, 0x56, 0x34, 0x12]", "[0x12, 0x34, 0x56, 0x78]", "", "" }
 }
 
 #[lang = "u64"]
 impl u64 {
-    uint_impl! { u64, u64, 64, 18446744073709551615, "", "", 12, "0xaa00000000006e1", "0x6e10aa",
+    uint_impl! { u64, u64, 64, 18446744073709551615, 12, "0xaa00000000006e1", "0x6e10aa",
     "0x1234567890123456", "0x5634129078563412", "0x6a2c48091e6a2c48",
     "[0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]",
     "[0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56]",
@@ -681,7 +674,7 @@ impl u64 {
 
 #[lang = "u128"]
 impl u128 {
-    uint_impl! { u128, u128, 128, 340282366920938463463374607431768211455, "", "", 16,
+    uint_impl! { u128, u128, 128, 340282366920938463463374607431768211455, 16,
     "0x13f40000000000000000000000004f76", "0x4f7613f4", "0x12345678901234567890123456789012",
     "0x12907856341290785634129078563412", "0x48091e6a2c48091e6a2c48091e6a2c48",
     "[0x12, 0x90, 0x78, 0x56, 0x34, 0x12, 0x90, 0x78, \
@@ -694,14 +687,14 @@ impl u128 {
 #[cfg(target_pointer_width = "16")]
 #[lang = "usize"]
 impl usize {
-    uint_impl! { usize, u16, 16, 65535, "", "", 4, "0xa003", "0x3a", "0x1234", "0x3412", "0x2c48",
+    uint_impl! { usize, u16, 16, 65535, 4, "0xa003", "0x3a", "0x1234", "0x3412", "0x2c48",
     "[0x34, 0x12]", "[0x12, 0x34]",
     usize_isize_to_xe_bytes_doc!(), usize_isize_from_xe_bytes_doc!() }
 }
 #[cfg(target_pointer_width = "32")]
 #[lang = "usize"]
 impl usize {
-    uint_impl! { usize, u32, 32, 4294967295, "", "", 8, "0x10000b3", "0xb301", "0x12345678",
+    uint_impl! { usize, u32, 32, 4294967295, 8, "0x10000b3", "0xb301", "0x12345678",
     "0x78563412", "0x1e6a2c48", "[0x78, 0x56, 0x34, 0x12]", "[0x12, 0x34, 0x56, 0x78]",
     usize_isize_to_xe_bytes_doc!(), usize_isize_from_xe_bytes_doc!() }
 }
@@ -709,7 +702,7 @@ impl usize {
 #[cfg(target_pointer_width = "64")]
 #[lang = "usize"]
 impl usize {
-    uint_impl! { usize, u64, 64, 18446744073709551615, "", "", 12, "0xaa00000000006e1", "0x6e10aa",
+    uint_impl! { usize, u64, 64, 18446744073709551615, 12, "0xaa00000000006e1", "0x6e10aa",
     "0x1234567890123456", "0x5634129078563412", "0x6a2c48091e6a2c48",
     "[0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]",
      "[0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56]",
diff --git a/library/core/src/num/nonzero.rs b/library/core/src/num/nonzero.rs
index 5eb70026d7e..94728768829 100644
--- a/library/core/src/num/nonzero.rs
+++ b/library/core/src/num/nonzero.rs
@@ -8,13 +8,6 @@ use super::from_str_radix;
 use super::{IntErrorKind, ParseIntError};
 use crate::intrinsics;
 
-macro_rules! doc_comment {
-    ($x:expr, $($tt:tt)*) => {
-        #[doc = $x]
-        $($tt)*
-    };
-}
-
 macro_rules! impl_nonzero_fmt {
     ( #[$stability: meta] ( $( $Trait: ident ),+ ) for $Ty: ident ) => {
         $(
@@ -32,24 +25,21 @@ macro_rules! impl_nonzero_fmt {
 macro_rules! nonzero_integers {
     ( $( #[$stability: meta] $Ty: ident($Int: ty); )+ ) => {
         $(
-            doc_comment! {
-                concat!("An integer that is known not to equal zero.
-
-This enables some memory layout optimization.
-For example, `Option<", stringify!($Ty), ">` is the same size as `", stringify!($Int), "`:
-
-```rust
-use std::mem::size_of;
-assert_eq!(size_of::<Option<core::num::", stringify!($Ty), ">>(), size_of::<", stringify!($Int),
-">());
-```"),
-                #[$stability]
-                #[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
-                #[repr(transparent)]
-                #[rustc_layout_scalar_valid_range_start(1)]
-                #[rustc_nonnull_optimization_guaranteed]
-                pub struct $Ty($Int);
-            }
+            /// An integer that is known not to equal zero.
+            ///
+            /// This enables some memory layout optimization.
+            #[doc = concat!("For example, `Option<", stringify!($Ty), ">` is the same size as `", stringify!($Int), "`:")]
+            ///
+            /// ```rust
+            /// use std::mem::size_of;
+            #[doc = concat!("assert_eq!(size_of::<Option<core::num::", stringify!($Ty), ">>(), size_of::<", stringify!($Int), ">());")]
+            /// ```
+            #[$stability]
+            #[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
+            #[repr(transparent)]
+            #[rustc_layout_scalar_valid_range_start(1)]
+            #[rustc_nonnull_optimization_guaranteed]
+            pub struct $Ty($Int);
 
             impl $Ty {
                 /// Creates a non-zero without checking the value.
@@ -90,13 +80,10 @@ assert_eq!(size_of::<Option<core::num::", stringify!($Ty), ">>(), size_of::<", s
 
             #[stable(feature = "from_nonzero", since = "1.31.0")]
             impl From<$Ty> for $Int {
-                doc_comment! {
-                    concat!(
-"Converts a `", stringify!($Ty), "` into an `", stringify!($Int), "`"),
-                    #[inline]
-                    fn from(nonzero: $Ty) -> Self {
-                        nonzero.0
-                    }
+                #[doc = concat!("Converts a `", stringify!($Ty), "` into an `", stringify!($Int), "`")]
+                #[inline]
+                fn from(nonzero: $Ty) -> Self {
+                    nonzero.0
                 }
             }
 
diff --git a/library/core/src/num/shells/int_macros.rs b/library/core/src/num/shells/int_macros.rs
index ffd30b03f21..0c31bfc149d 100644
--- a/library/core/src/num/shells/int_macros.rs
+++ b/library/core/src/num/shells/int_macros.rs
@@ -1,49 +1,44 @@
 #![doc(hidden)]
 
-macro_rules! doc_comment {
-    ($x:expr, $($tt:tt)*) => {
-        #[doc = $x]
-        $($tt)*
-    };
-}
-
 macro_rules! int_module {
     ($T:ident) => (int_module!($T, #[stable(feature = "rust1", since = "1.0.0")]););
     ($T:ident, #[$attr:meta]) => (
-        doc_comment! {
-            concat!("The smallest value that can be represented by this integer type.
-Use [`", stringify!($T), "::MIN", "`](../../std/primitive.", stringify!($T), ".html#associatedconstant.MIN) instead.
-
-# Examples
-
-```rust
-// deprecated way
-let min = std::", stringify!($T), "::MIN;
-
-// intended way
-let min = ", stringify!($T), "::MIN;
-```
-"),
-            #[$attr]
-            pub const MIN: $T = $T::MIN;
-        }
-
-        doc_comment! {
-            concat!("The largest value that can be represented by this integer type.
-Use [`", stringify!($T), "::MAX", "`](../../std/primitive.", stringify!($T), ".html#associatedconstant.MAX) instead.
-
-# Examples
-
-```rust
-// deprecated way
-let max = std::", stringify!($T), "::MAX;
-
-// intended way
-let max = ", stringify!($T), "::MAX;
-```
-"),
-            #[$attr]
-            pub const MAX: $T = $T::MAX;
-        }
+        #[doc = concat!(
+            "The smallest value that can be represented by this integer type. Use ",
+            "[`", stringify!($T), "::MIN", "`](../../std/primitive.", stringify!($T), ".html#associatedconstant.MIN)",
+            "intead.",
+        )]
+        ///
+        /// # Examples
+        ///
+        /// ```rust
+        /// // deprecated way
+        #[doc = concat!("let min = std::", stringify!($T), "::MIN;")]
+        ///
+        /// // intended way
+        #[doc = concat!("let min = ", stringify!($T), "::MIN;")]
+        /// ```
+        ///
+        #[$attr]
+        pub const MIN: $T = $T::MIN;
+
+        #[doc = concat!(
+            "The largest value that can be represented by this integer type. Use ",
+            "[`", stringify!($T), "::MAX", "`](../../std/primitive.", stringify!($T), ".html#associatedconstant.MAX)",
+            "instead.",
+        )]
+        ///
+        /// # Examples
+        ///
+        /// ```rust
+        /// // deprecated way
+        #[doc = concat!("let max = std::", stringify!($T), "::MAX;")]
+        ///
+        /// // intended way
+        #[doc = concat!("let max = ", stringify!($T), "::MAX;")]
+        /// ```
+        ///
+        #[$attr]
+        pub const MAX: $T = $T::MAX;
     )
 }
diff --git a/library/core/src/num/uint_macros.rs b/library/core/src/num/uint_macros.rs
index ae8fc18a838..8f141a3ff9e 100644
--- a/library/core/src/num/uint_macros.rs
+++ b/library/core/src/num/uint_macros.rs
@@ -1,928 +1,842 @@
 macro_rules! uint_impl {
-    ($SelfT:ty, $ActualT:ty, $BITS:expr, $MaxV:expr, $Feature:expr, $EndFeature:expr,
+    ($SelfT:ty, $ActualT:ty, $BITS:expr, $MaxV:expr,
         $rot:expr, $rot_op:expr, $rot_result:expr, $swap_op:expr, $swapped:expr,
         $reversed:expr, $le_bytes:expr, $be_bytes:expr,
         $to_xe_bytes_doc:expr, $from_xe_bytes_doc:expr) => {
-        doc_comment! {
-            concat!("The smallest value that can be represented by this integer type.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(", stringify!($SelfT), "::MIN, 0);", $EndFeature, "
-```"),
-            #[stable(feature = "assoc_int_consts", since = "1.43.0")]
-            pub const MIN: Self = 0;
-        }
-
-        doc_comment! {
-            concat!("The largest value that can be represented by this integer type.
+        /// The smallest value that can be represented by this integer type.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MIN, 0);")]
+        /// ```
+        #[stable(feature = "assoc_int_consts", since = "1.43.0")]
+        pub const MIN: Self = 0;
 
-# Examples
+        /// The largest value that can be represented by this integer type.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MAX, ", stringify!($MaxV), ");")]
+        /// ```
+        #[stable(feature = "assoc_int_consts", since = "1.43.0")]
+        pub const MAX: Self = !0;
 
-Basic usage:
+        /// The size of this integer type in bits.
+        ///
+        /// # Examples
+        ///
+        /// ```
+        /// #![feature(int_bits_const)]
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::BITS, ", stringify!($BITS), ");")]
+        /// ```
+        #[unstable(feature = "int_bits_const", issue = "76904")]
+        pub const BITS: u32 = $BITS;
 
-```
-", $Feature, "assert_eq!(", stringify!($SelfT), "::MAX, ", stringify!($MaxV), ");",
-$EndFeature, "
-```"),
-            #[stable(feature = "assoc_int_consts", since = "1.43.0")]
-            pub const MAX: Self = !0;
+        /// Converts a string slice in a given base to an integer.
+        ///
+        /// The string is expected to be an optional `+` sign
+        /// followed by digits.
+        /// Leading and trailing whitespace represent an error.
+        /// Digits are a subset of these characters, depending on `radix`:
+        ///
+        /// * `0-9`
+        /// * `a-z`
+        /// * `A-Z`
+        ///
+        /// # Panics
+        ///
+        /// This function panics if `radix` is not in the range from 2 to 36.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::from_str_radix(\"A\", 16), Ok(10));")]
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        pub fn from_str_radix(src: &str, radix: u32) -> Result<Self, ParseIntError> {
+            from_str_radix(src, radix)
         }
 
-        doc_comment! {
-            concat!("The size of this integer type in bits.
-
-# Examples
-
-```
-", $Feature, "#![feature(int_bits_const)]
-assert_eq!(", stringify!($SelfT), "::BITS, ", stringify!($BITS), ");",
-$EndFeature, "
-```"),
-            #[unstable(feature = "int_bits_const", issue = "76904")]
-            pub const BITS: u32 = $BITS;
+        /// Returns the number of ones in the binary representation of `self`.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("let n = 0b01001100", stringify!($SelfT), ";")]
+        ///
+        /// assert_eq!(n.count_ones(), 3);
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_math", since = "1.32.0")]
+        #[doc(alias = "popcount")]
+        #[doc(alias = "popcnt")]
+        #[inline]
+        pub const fn count_ones(self) -> u32 {
+            intrinsics::ctpop(self as $ActualT) as u32
         }
 
-        doc_comment! {
-            concat!("Converts a string slice in a given base to an integer.
-
-The string is expected to be an optional `+` sign
-followed by digits.
-Leading and trailing whitespace represent an error.
-Digits are a subset of these characters, depending on `radix`:
-
-* `0-9`
-* `a-z`
-* `A-Z`
-
-# Panics
-
-This function panics if `radix` is not in the range from 2 to 36.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(", stringify!($SelfT), "::from_str_radix(\"A\", 16), Ok(10));",
-$EndFeature, "
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            pub fn from_str_radix(src: &str, radix: u32) -> Result<Self, ParseIntError> {
-                from_str_radix(src, radix)
-            }
+        /// Returns the number of zeros in the binary representation of `self`.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MAX.count_zeros(), 0);")]
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_math", since = "1.32.0")]
+        #[inline]
+        pub const fn count_zeros(self) -> u32 {
+            (!self).count_ones()
         }
 
-        doc_comment! {
-            concat!("Returns the number of ones in the binary representation of `self`.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "let n = 0b01001100", stringify!($SelfT), ";
-
-assert_eq!(n.count_ones(), 3);", $EndFeature, "
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_math", since = "1.32.0")]
-            #[doc(alias = "popcount")]
-            #[doc(alias = "popcnt")]
-            #[inline]
-            pub const fn count_ones(self) -> u32 {
-                intrinsics::ctpop(self as $ActualT) as u32
-            }
+        /// Returns the number of leading zeros in the binary representation of `self`.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("let n = ", stringify!($SelfT), "::MAX >> 2;")]
+        ///
+        /// assert_eq!(n.leading_zeros(), 2);
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_math", since = "1.32.0")]
+        #[inline]
+        pub const fn leading_zeros(self) -> u32 {
+            intrinsics::ctlz(self as $ActualT) as u32
         }
 
-        doc_comment! {
-            concat!("Returns the number of zeros in the binary representation of `self`.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(", stringify!($SelfT), "::MAX.count_zeros(), 0);", $EndFeature, "
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_math", since = "1.32.0")]
-            #[inline]
-            pub const fn count_zeros(self) -> u32 {
-                (!self).count_ones()
-            }
+        /// Returns the number of trailing zeros in the binary representation
+        /// of `self`.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("let n = 0b0101000", stringify!($SelfT), ";")]
+        ///
+        /// assert_eq!(n.trailing_zeros(), 3);
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_math", since = "1.32.0")]
+        #[inline]
+        pub const fn trailing_zeros(self) -> u32 {
+            intrinsics::cttz(self) as u32
         }
 
-        doc_comment! {
-            concat!("Returns the number of leading zeros in the binary representation of `self`.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "let n = ", stringify!($SelfT), "::MAX >> 2;
-
-assert_eq!(n.leading_zeros(), 2);", $EndFeature, "
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_math", since = "1.32.0")]
-            #[inline]
-            pub const fn leading_zeros(self) -> u32 {
-                intrinsics::ctlz(self as $ActualT) as u32
-            }
+        /// Returns the number of leading ones in the binary representation of `self`.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("let n = !(", stringify!($SelfT), "::MAX >> 2);")]
+        ///
+        /// assert_eq!(n.leading_ones(), 2);
+        /// ```
+        #[stable(feature = "leading_trailing_ones", since = "1.46.0")]
+        #[rustc_const_stable(feature = "leading_trailing_ones", since = "1.46.0")]
+        #[inline]
+        pub const fn leading_ones(self) -> u32 {
+            (!self).leading_zeros()
         }
 
-        doc_comment! {
-            concat!("Returns the number of trailing zeros in the binary representation
-of `self`.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "let n = 0b0101000", stringify!($SelfT), ";
-
-assert_eq!(n.trailing_zeros(), 3);", $EndFeature, "
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_math", since = "1.32.0")]
-            #[inline]
-            pub const fn trailing_zeros(self) -> u32 {
-                intrinsics::cttz(self) as u32
-            }
+        /// Returns the number of trailing ones in the binary representation
+        /// of `self`.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("let n = 0b1010111", stringify!($SelfT), ";")]
+        ///
+        /// assert_eq!(n.trailing_ones(), 3);
+        /// ```
+        #[stable(feature = "leading_trailing_ones", since = "1.46.0")]
+        #[rustc_const_stable(feature = "leading_trailing_ones", since = "1.46.0")]
+        #[inline]
+        pub const fn trailing_ones(self) -> u32 {
+            (!self).trailing_zeros()
         }
 
-        doc_comment! {
-            concat!("Returns the number of leading ones in the binary representation of `self`.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "let n = !(", stringify!($SelfT), "::MAX >> 2);
-
-assert_eq!(n.leading_ones(), 2);", $EndFeature, "
-```"),
-            #[stable(feature = "leading_trailing_ones", since = "1.46.0")]
-            #[rustc_const_stable(feature = "leading_trailing_ones", since = "1.46.0")]
-            #[inline]
-            pub const fn leading_ones(self) -> u32 {
-                (!self).leading_zeros()
-            }
+        /// Shifts the bits to the left by a specified amount, `n`,
+        /// wrapping the truncated bits to the end of the resulting integer.
+        ///
+        /// Please note this isn't the same operation as the `<<` shifting operator!
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("let n = ", $rot_op, stringify!($SelfT), ";")]
+        #[doc = concat!("let m = ", $rot_result, ";")]
+        ///
+        #[doc = concat!("assert_eq!(n.rotate_left(", $rot, "), m);")]
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_math", since = "1.32.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn rotate_left(self, n: u32) -> Self {
+            intrinsics::rotate_left(self, n as $SelfT)
         }
 
-        doc_comment! {
-            concat!("Returns the number of trailing ones in the binary representation
-of `self`.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "let n = 0b1010111", stringify!($SelfT), ";
-
-assert_eq!(n.trailing_ones(), 3);", $EndFeature, "
-```"),
-            #[stable(feature = "leading_trailing_ones", since = "1.46.0")]
-            #[rustc_const_stable(feature = "leading_trailing_ones", since = "1.46.0")]
-            #[inline]
-            pub const fn trailing_ones(self) -> u32 {
-                (!self).trailing_zeros()
-            }
+        /// Shifts the bits to the right by a specified amount, `n`,
+        /// wrapping the truncated bits to the beginning of the resulting
+        /// integer.
+        ///
+        /// Please note this isn't the same operation as the `>>` shifting operator!
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("let n = ", $rot_result, stringify!($SelfT), ";")]
+        #[doc = concat!("let m = ", $rot_op, ";")]
+        ///
+        #[doc = concat!("assert_eq!(n.rotate_right(", $rot, "), m);")]
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_math", since = "1.32.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn rotate_right(self, n: u32) -> Self {
+            intrinsics::rotate_right(self, n as $SelfT)
         }
 
-        doc_comment! {
-            concat!("Shifts the bits to the left by a specified amount, `n`,
-wrapping the truncated bits to the end of the resulting integer.
-
-Please note this isn't the same operation as the `<<` shifting operator!
-
-# Examples
-
-Basic usage:
-
-```
-let n = ", $rot_op, stringify!($SelfT), ";
-let m = ", $rot_result, ";
-
-assert_eq!(n.rotate_left(", $rot, "), m);
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_math", since = "1.32.0")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn rotate_left(self, n: u32) -> Self {
-                intrinsics::rotate_left(self, n as $SelfT)
-            }
+        /// Reverses the byte order of the integer.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("let n = ", $swap_op, stringify!($SelfT), ";")]
+        /// let m = n.swap_bytes();
+        ///
+        #[doc = concat!("assert_eq!(m, ", $swapped, ");")]
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_math", since = "1.32.0")]
+        #[inline]
+        pub const fn swap_bytes(self) -> Self {
+            intrinsics::bswap(self as $ActualT) as Self
         }
 
-        doc_comment! {
-            concat!("Shifts the bits to the right by a specified amount, `n`,
-wrapping the truncated bits to the beginning of the resulting
-integer.
-
-Please note this isn't the same operation as the `>>` shifting operator!
-
-# Examples
-
-Basic usage:
-
-```
-let n = ", $rot_result, stringify!($SelfT), ";
-let m = ", $rot_op, ";
-
-assert_eq!(n.rotate_right(", $rot, "), m);
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_math", since = "1.32.0")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn rotate_right(self, n: u32) -> Self {
-                intrinsics::rotate_right(self, n as $SelfT)
-            }
+        /// Reverses the order of bits in the integer. The least significant bit becomes the most significant bit,
+        ///                 second least-significant bit becomes second most-significant bit, etc.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("let n = ", $swap_op, stringify!($SelfT), ";")]
+        /// let m = n.reverse_bits();
+        ///
+        #[doc = concat!("assert_eq!(m, ", $reversed, ");")]
+        #[doc = concat!("assert_eq!(0, 0", stringify!($SelfT), ".reverse_bits());")]
+        /// ```
+        #[stable(feature = "reverse_bits", since = "1.37.0")]
+        #[rustc_const_stable(feature = "const_math", since = "1.32.0")]
+        #[inline]
+        #[must_use]
+        pub const fn reverse_bits(self) -> Self {
+            intrinsics::bitreverse(self as $ActualT) as Self
         }
 
-        doc_comment! {
-            concat!("
-Reverses the byte order of the integer.
-
-# Examples
-
-Basic usage:
-
-```
-let n = ", $swap_op, stringify!($SelfT), ";
-let m = n.swap_bytes();
-
-assert_eq!(m, ", $swapped, ");
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_math", since = "1.32.0")]
-            #[inline]
-            pub const fn swap_bytes(self) -> Self {
-                intrinsics::bswap(self as $ActualT) as Self
+        /// Converts an integer from big endian to the target's endianness.
+        ///
+        /// On big endian this is a no-op. On little endian the bytes are
+        /// swapped.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("let n = 0x1A", stringify!($SelfT), ";")]
+        ///
+        /// if cfg!(target_endian = "big") {
+        #[doc = concat!("    assert_eq!(", stringify!($SelfT), "::from_be(n), n)")]
+        /// } else {
+        #[doc = concat!("    assert_eq!(", stringify!($SelfT), "::from_be(n), n.swap_bytes())")]
+        /// }
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_math", since = "1.32.0")]
+        #[inline]
+        pub const fn from_be(x: Self) -> Self {
+            #[cfg(target_endian = "big")]
+            {
+                x
             }
-        }
-
-        doc_comment! {
-            concat!("Reverses the order of bits in the integer. The least significant bit becomes the most significant bit,
-                second least-significant bit becomes second most-significant bit, etc.
-
-# Examples
-
-Basic usage:
-
-```
-let n = ", $swap_op, stringify!($SelfT), ";
-let m = n.reverse_bits();
-
-assert_eq!(m, ", $reversed, ");
-assert_eq!(0, 0", stringify!($SelfT), ".reverse_bits());
-```"),
-            #[stable(feature = "reverse_bits", since = "1.37.0")]
-            #[rustc_const_stable(feature = "const_math", since = "1.32.0")]
-            #[inline]
-            #[must_use]
-            pub const fn reverse_bits(self) -> Self {
-                intrinsics::bitreverse(self as $ActualT) as Self
+            #[cfg(not(target_endian = "big"))]
+            {
+                x.swap_bytes()
             }
         }
 
-        doc_comment! {
-            concat!("Converts an integer from big endian to the target's endianness.
-
-On big endian this is a no-op. On little endian the bytes are
-swapped.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "let n = 0x1A", stringify!($SelfT), ";
-
-if cfg!(target_endian = \"big\") {
-    assert_eq!(", stringify!($SelfT), "::from_be(n), n)
-} else {
-    assert_eq!(", stringify!($SelfT), "::from_be(n), n.swap_bytes())
-}", $EndFeature, "
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_math", since = "1.32.0")]
-            #[inline]
-            pub const fn from_be(x: Self) -> Self {
-                #[cfg(target_endian = "big")]
-                {
-                    x
-                }
-                #[cfg(not(target_endian = "big"))]
-                {
-                    x.swap_bytes()
-                }
+        /// Converts an integer from little endian to the target's endianness.
+        ///
+        /// On little endian this is a no-op. On big endian the bytes are
+        /// swapped.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("let n = 0x1A", stringify!($SelfT), ";")]
+        ///
+        /// if cfg!(target_endian = "little") {
+        #[doc = concat!("    assert_eq!(", stringify!($SelfT), "::from_le(n), n)")]
+        /// } else {
+        #[doc = concat!("    assert_eq!(", stringify!($SelfT), "::from_le(n), n.swap_bytes())")]
+        /// }
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_math", since = "1.32.0")]
+        #[inline]
+        pub const fn from_le(x: Self) -> Self {
+            #[cfg(target_endian = "little")]
+            {
+                x
             }
-        }
-
-        doc_comment! {
-            concat!("Converts an integer from little endian to the target's endianness.
-
-On little endian this is a no-op. On big endian the bytes are
-swapped.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "let n = 0x1A", stringify!($SelfT), ";
-
-if cfg!(target_endian = \"little\") {
-    assert_eq!(", stringify!($SelfT), "::from_le(n), n)
-} else {
-    assert_eq!(", stringify!($SelfT), "::from_le(n), n.swap_bytes())
-}", $EndFeature, "
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_math", since = "1.32.0")]
-            #[inline]
-            pub const fn from_le(x: Self) -> Self {
-                #[cfg(target_endian = "little")]
-                {
-                    x
-                }
-                #[cfg(not(target_endian = "little"))]
-                {
-                    x.swap_bytes()
-                }
+            #[cfg(not(target_endian = "little"))]
+            {
+                x.swap_bytes()
             }
         }
 
-        doc_comment! {
-            concat!("Converts `self` to big endian from the target's endianness.
-
-On big endian this is a no-op. On little endian the bytes are
-swapped.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "let n = 0x1A", stringify!($SelfT), ";
-
-if cfg!(target_endian = \"big\") {
-    assert_eq!(n.to_be(), n)
-} else {
-    assert_eq!(n.to_be(), n.swap_bytes())
-}", $EndFeature, "
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_math", since = "1.32.0")]
-            #[inline]
-            pub const fn to_be(self) -> Self { // or not to be?
-                #[cfg(target_endian = "big")]
-                {
-                    self
-                }
-                #[cfg(not(target_endian = "big"))]
-                {
-                    self.swap_bytes()
-                }
+        /// Converts `self` to big endian from the target's endianness.
+        ///
+        /// On big endian this is a no-op. On little endian the bytes are
+        /// swapped.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("let n = 0x1A", stringify!($SelfT), ";")]
+        ///
+        /// if cfg!(target_endian = "big") {
+        ///     assert_eq!(n.to_be(), n)
+        /// } else {
+        ///     assert_eq!(n.to_be(), n.swap_bytes())
+        /// }
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_math", since = "1.32.0")]
+        #[inline]
+        pub const fn to_be(self) -> Self { // or not to be?
+            #[cfg(target_endian = "big")]
+            {
+                self
             }
-        }
-
-        doc_comment! {
-            concat!("Converts `self` to little endian from the target's endianness.
-
-On little endian this is a no-op. On big endian the bytes are
-swapped.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "let n = 0x1A", stringify!($SelfT), ";
-
-if cfg!(target_endian = \"little\") {
-    assert_eq!(n.to_le(), n)
-} else {
-    assert_eq!(n.to_le(), n.swap_bytes())
-}", $EndFeature, "
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_math", since = "1.32.0")]
-            #[inline]
-            pub const fn to_le(self) -> Self {
-                #[cfg(target_endian = "little")]
-                {
-                    self
-                }
-                #[cfg(not(target_endian = "little"))]
-                {
-                    self.swap_bytes()
-                }
+            #[cfg(not(target_endian = "big"))]
+            {
+                self.swap_bytes()
             }
         }
 
-        doc_comment! {
-            concat!("Checked integer addition. Computes `self + rhs`, returning `None`
-if overflow occurred.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!((", stringify!($SelfT), "::MAX - 2).checked_add(1), ",
-"Some(", stringify!($SelfT), "::MAX - 1));
-assert_eq!((", stringify!($SelfT), "::MAX - 2).checked_add(3), None);", $EndFeature, "
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_checked_int_methods", since = "1.47.0")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn checked_add(self, rhs: Self) -> Option<Self> {
-                let (a, b) = self.overflowing_add(rhs);
-                if unlikely!(b) {None} else {Some(a)}
+        /// Converts `self` to little endian from the target's endianness.
+        ///
+        /// On little endian this is a no-op. On big endian the bytes are
+        /// swapped.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("let n = 0x1A", stringify!($SelfT), ";")]
+        ///
+        /// if cfg!(target_endian = "little") {
+        ///     assert_eq!(n.to_le(), n)
+        /// } else {
+        ///     assert_eq!(n.to_le(), n.swap_bytes())
+        /// }
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_math", since = "1.32.0")]
+        #[inline]
+        pub const fn to_le(self) -> Self {
+            #[cfg(target_endian = "little")]
+            {
+                self
             }
-        }
-
-        doc_comment! {
-            concat!("Unchecked integer addition. Computes `self + rhs`, assuming overflow
-cannot occur. This results in undefined behavior when `self + rhs > ", stringify!($SelfT),
-"::MAX` or `self + rhs < ", stringify!($SelfT), "::MIN`."),
-            #[unstable(
-                feature = "unchecked_math",
-                reason = "niche optimization path",
-                issue = "none",
-            )]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub unsafe fn unchecked_add(self, rhs: Self) -> Self {
-                // SAFETY: the caller must uphold the safety contract for
-                // `unchecked_add`.
-                unsafe { intrinsics::unchecked_add(self, rhs) }
+            #[cfg(not(target_endian = "little"))]
+            {
+                self.swap_bytes()
             }
         }
 
-        doc_comment! {
-            concat!("Checked integer subtraction. Computes `self - rhs`, returning
-`None` if overflow occurred.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(1", stringify!($SelfT), ".checked_sub(1), Some(0));
-assert_eq!(0", stringify!($SelfT), ".checked_sub(1), None);", $EndFeature, "
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_checked_int_methods", since = "1.47.0")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn checked_sub(self, rhs: Self) -> Option<Self> {
-                let (a, b) = self.overflowing_sub(rhs);
-                if unlikely!(b) {None} else {Some(a)}
-            }
+        /// Checked integer addition. Computes `self + rhs`, returning `None`
+        /// if overflow occurred.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!(
+            "assert_eq!((", stringify!($SelfT), "::MAX - 2).checked_add(1), ",
+            "Some(", stringify!($SelfT), "::MAX - 1));"
+        )]
+        #[doc = concat!("assert_eq!((", stringify!($SelfT), "::MAX - 2).checked_add(3), None);")]
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_checked_int_methods", since = "1.47.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn checked_add(self, rhs: Self) -> Option<Self> {
+            let (a, b) = self.overflowing_add(rhs);
+            if unlikely!(b) {None} else {Some(a)}
+        }
+
+        /// Unchecked integer addition. Computes `self + rhs`, assuming overflow
+        /// cannot occur. This results in undefined behavior when
+        #[doc = concat!("`self + rhs > ", stringify!($SelfT), "::MAX` or `self + rhs < ", stringify!($SelfT), "::MIN`.")]
+        #[unstable(
+            feature = "unchecked_math",
+            reason = "niche optimization path",
+            issue = "none",
+        )]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub unsafe fn unchecked_add(self, rhs: Self) -> Self {
+            // SAFETY: the caller must uphold the safety contract for
+            // `unchecked_add`.
+            unsafe { intrinsics::unchecked_add(self, rhs) }
         }
 
-        doc_comment! {
-            concat!("Unchecked integer subtraction. Computes `self - rhs`, assuming overflow
-cannot occur. This results in undefined behavior when `self - rhs > ", stringify!($SelfT),
-"::MAX` or `self - rhs < ", stringify!($SelfT), "::MIN`."),
-            #[unstable(
-                feature = "unchecked_math",
-                reason = "niche optimization path",
-                issue = "none",
-            )]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub unsafe fn unchecked_sub(self, rhs: Self) -> Self {
-                // SAFETY: the caller must uphold the safety contract for
-                // `unchecked_sub`.
-                unsafe { intrinsics::unchecked_sub(self, rhs) }
-            }
+        /// Checked integer subtraction. Computes `self - rhs`, returning
+        /// `None` if overflow occurred.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(1", stringify!($SelfT), ".checked_sub(1), Some(0));")]
+        #[doc = concat!("assert_eq!(0", stringify!($SelfT), ".checked_sub(1), None);")]
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_checked_int_methods", since = "1.47.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn checked_sub(self, rhs: Self) -> Option<Self> {
+            let (a, b) = self.overflowing_sub(rhs);
+            if unlikely!(b) {None} else {Some(a)}
+        }
+
+        /// Unchecked integer subtraction. Computes `self - rhs`, assuming overflow
+        /// cannot occur. This results in undefined behavior when
+        #[doc = concat!("`self - rhs > ", stringify!($SelfT), "::MAX` or `self - rhs < ", stringify!($SelfT), "::MIN`.")]
+        #[unstable(
+            feature = "unchecked_math",
+            reason = "niche optimization path",
+            issue = "none",
+        )]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub unsafe fn unchecked_sub(self, rhs: Self) -> Self {
+            // SAFETY: the caller must uphold the safety contract for
+            // `unchecked_sub`.
+            unsafe { intrinsics::unchecked_sub(self, rhs) }
         }
 
-        doc_comment! {
-            concat!("Checked integer multiplication. Computes `self * rhs`, returning
-`None` if overflow occurred.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(5", stringify!($SelfT), ".checked_mul(1), Some(5));
-assert_eq!(", stringify!($SelfT), "::MAX.checked_mul(2), None);", $EndFeature, "
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_checked_int_methods", since = "1.47.0")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn checked_mul(self, rhs: Self) -> Option<Self> {
-                let (a, b) = self.overflowing_mul(rhs);
-                if unlikely!(b) {None} else {Some(a)}
-            }
+        /// Checked integer multiplication. Computes `self * rhs`, returning
+        /// `None` if overflow occurred.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(5", stringify!($SelfT), ".checked_mul(1), Some(5));")]
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MAX.checked_mul(2), None);")]
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_checked_int_methods", since = "1.47.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn checked_mul(self, rhs: Self) -> Option<Self> {
+            let (a, b) = self.overflowing_mul(rhs);
+            if unlikely!(b) {None} else {Some(a)}
+        }
+
+        /// Unchecked integer multiplication. Computes `self * rhs`, assuming overflow
+        /// cannot occur. This results in undefined behavior when
+        #[doc = concat!("`self * rhs > ", stringify!($SelfT), "::MAX` or `self * rhs < ", stringify!($SelfT), "::MIN`.")]
+        #[unstable(
+            feature = "unchecked_math",
+            reason = "niche optimization path",
+            issue = "none",
+        )]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub unsafe fn unchecked_mul(self, rhs: Self) -> Self {
+            // SAFETY: the caller must uphold the safety contract for
+            // `unchecked_mul`.
+            unsafe { intrinsics::unchecked_mul(self, rhs) }
         }
 
-        doc_comment! {
-            concat!("Unchecked integer multiplication. Computes `self * rhs`, assuming overflow
-cannot occur. This results in undefined behavior when `self * rhs > ", stringify!($SelfT),
-"::MAX` or `self * rhs < ", stringify!($SelfT), "::MIN`."),
-            #[unstable(
-                feature = "unchecked_math",
-                reason = "niche optimization path",
-                issue = "none",
-            )]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub unsafe fn unchecked_mul(self, rhs: Self) -> Self {
-                // SAFETY: the caller must uphold the safety contract for
-                // `unchecked_mul`.
-                unsafe { intrinsics::unchecked_mul(self, rhs) }
+        /// Checked integer division. Computes `self / rhs`, returning `None`
+        /// if `rhs == 0`.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(128", stringify!($SelfT), ".checked_div(2), Some(64));")]
+        #[doc = concat!("assert_eq!(1", stringify!($SelfT), ".checked_div(0), None);")]
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_unstable(feature = "const_checked_int_methods", issue = "53718")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn checked_div(self, rhs: Self) -> Option<Self> {
+            if unlikely!(rhs == 0) {
+                None
+            } else {
+                // SAFETY: div by zero has been checked above and unsigned types have no other
+                // failure modes for division
+                Some(unsafe { intrinsics::unchecked_div(self, rhs) })
             }
         }
 
-        doc_comment! {
-            concat!("Checked integer division. Computes `self / rhs`, returning `None`
-if `rhs == 0`.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(128", stringify!($SelfT), ".checked_div(2), Some(64));
-assert_eq!(1", stringify!($SelfT), ".checked_div(0), None);", $EndFeature, "
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_unstable(feature = "const_checked_int_methods", issue = "53718")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn checked_div(self, rhs: Self) -> Option<Self> {
-                if unlikely!(rhs == 0) {
-                    None
-                } else {
-                    // SAFETY: div by zero has been checked above and unsigned types have no other
-                    // failure modes for division
-                    Some(unsafe { intrinsics::unchecked_div(self, rhs) })
-                }
+        /// Checked Euclidean division. Computes `self.div_euclid(rhs)`, returning `None`
+        /// if `rhs == 0`.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(128", stringify!($SelfT), ".checked_div_euclid(2), Some(64));")]
+        #[doc = concat!("assert_eq!(1", stringify!($SelfT), ".checked_div_euclid(0), None);")]
+        /// ```
+        #[stable(feature = "euclidean_division", since = "1.38.0")]
+        #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn checked_div_euclid(self, rhs: Self) -> Option<Self> {
+            if unlikely!(rhs == 0) {
+                None
+            } else {
+                Some(self.div_euclid(rhs))
             }
         }
 
-        doc_comment! {
-            concat!("Checked Euclidean division. Computes `self.div_euclid(rhs)`, returning `None`
-if `rhs == 0`.
 
-# Examples
-
-Basic usage:
-
-```
-assert_eq!(128", stringify!($SelfT), ".checked_div_euclid(2), Some(64));
-assert_eq!(1", stringify!($SelfT), ".checked_div_euclid(0), None);
-```"),
-            #[stable(feature = "euclidean_division", since = "1.38.0")]
-            #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn checked_div_euclid(self, rhs: Self) -> Option<Self> {
-                if unlikely!(rhs == 0) {
-                    None
-                } else {
-                    Some(self.div_euclid(rhs))
-                }
+        /// Checked integer remainder. Computes `self % rhs`, returning `None`
+        /// if `rhs == 0`.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(5", stringify!($SelfT), ".checked_rem(2), Some(1));")]
+        #[doc = concat!("assert_eq!(5", stringify!($SelfT), ".checked_rem(0), None);")]
+        /// ```
+        #[stable(feature = "wrapping", since = "1.7.0")]
+        #[rustc_const_unstable(feature = "const_checked_int_methods", issue = "53718")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn checked_rem(self, rhs: Self) -> Option<Self> {
+            if unlikely!(rhs == 0) {
+                None
+            } else {
+                // SAFETY: div by zero has been checked above and unsigned types have no other
+                // failure modes for division
+                Some(unsafe { intrinsics::unchecked_rem(self, rhs) })
             }
         }
 
-
-        doc_comment! {
-            concat!("Checked integer remainder. Computes `self % rhs`, returning `None`
-if `rhs == 0`.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(5", stringify!($SelfT), ".checked_rem(2), Some(1));
-assert_eq!(5", stringify!($SelfT), ".checked_rem(0), None);", $EndFeature, "
-```"),
-            #[stable(feature = "wrapping", since = "1.7.0")]
-            #[rustc_const_unstable(feature = "const_checked_int_methods", issue = "53718")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn checked_rem(self, rhs: Self) -> Option<Self> {
-                if unlikely!(rhs == 0) {
-                    None
-                } else {
-                    // SAFETY: div by zero has been checked above and unsigned types have no other
-                    // failure modes for division
-                    Some(unsafe { intrinsics::unchecked_rem(self, rhs) })
-                }
+        /// Checked Euclidean modulo. Computes `self.rem_euclid(rhs)`, returning `None`
+        /// if `rhs == 0`.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(5", stringify!($SelfT), ".checked_rem_euclid(2), Some(1));")]
+        #[doc = concat!("assert_eq!(5", stringify!($SelfT), ".checked_rem_euclid(0), None);")]
+        /// ```
+        #[stable(feature = "euclidean_division", since = "1.38.0")]
+        #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn checked_rem_euclid(self, rhs: Self) -> Option<Self> {
+            if unlikely!(rhs == 0) {
+                None
+            } else {
+                Some(self.rem_euclid(rhs))
             }
         }
 
-        doc_comment! {
-            concat!("Checked Euclidean modulo. Computes `self.rem_euclid(rhs)`, returning `None`
-if `rhs == 0`.
-
-# Examples
-
-Basic usage:
-
-```
-assert_eq!(5", stringify!($SelfT), ".checked_rem_euclid(2), Some(1));
-assert_eq!(5", stringify!($SelfT), ".checked_rem_euclid(0), None);
-```"),
-            #[stable(feature = "euclidean_division", since = "1.38.0")]
-            #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn checked_rem_euclid(self, rhs: Self) -> Option<Self> {
-                if unlikely!(rhs == 0) {
-                    None
-                } else {
-                    Some(self.rem_euclid(rhs))
-                }
-            }
+        /// Checked negation. Computes `-self`, returning `None` unless `self ==
+        /// 0`.
+        ///
+        /// Note that negating any positive integer will overflow.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(0", stringify!($SelfT), ".checked_neg(), Some(0));")]
+        #[doc = concat!("assert_eq!(1", stringify!($SelfT), ".checked_neg(), None);")]
+        /// ```
+        #[stable(feature = "wrapping", since = "1.7.0")]
+        #[rustc_const_stable(feature = "const_checked_int_methods", since = "1.47.0")]
+        #[inline]
+        pub const fn checked_neg(self) -> Option<Self> {
+            let (a, b) = self.overflowing_neg();
+            if unlikely!(b) {None} else {Some(a)}
         }
 
-        doc_comment! {
-            concat!("Checked negation. Computes `-self`, returning `None` unless `self ==
-0`.
-
-Note that negating any positive integer will overflow.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(0", stringify!($SelfT), ".checked_neg(), Some(0));
-assert_eq!(1", stringify!($SelfT), ".checked_neg(), None);", $EndFeature, "
-```"),
-            #[stable(feature = "wrapping", since = "1.7.0")]
-            #[rustc_const_stable(feature = "const_checked_int_methods", since = "1.47.0")]
-            #[inline]
-            pub const fn checked_neg(self) -> Option<Self> {
-                let (a, b) = self.overflowing_neg();
-                if unlikely!(b) {None} else {Some(a)}
-            }
+        /// Checked shift left. Computes `self << rhs`, returning `None`
+        /// if `rhs` is larger than or equal to the number of bits in `self`.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(0x1", stringify!($SelfT), ".checked_shl(4), Some(0x10));")]
+        #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".checked_shl(129), None);")]
+        /// ```
+        #[stable(feature = "wrapping", since = "1.7.0")]
+        #[rustc_const_stable(feature = "const_checked_int_methods", since = "1.47.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn checked_shl(self, rhs: u32) -> Option<Self> {
+            let (a, b) = self.overflowing_shl(rhs);
+            if unlikely!(b) {None} else {Some(a)}
         }
 
-        doc_comment! {
-            concat!("Checked shift left. Computes `self << rhs`, returning `None`
-if `rhs` is larger than or equal to the number of bits in `self`.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(0x1", stringify!($SelfT), ".checked_shl(4), Some(0x10));
-assert_eq!(0x10", stringify!($SelfT), ".checked_shl(129), None);", $EndFeature, "
-```"),
-            #[stable(feature = "wrapping", since = "1.7.0")]
-            #[rustc_const_stable(feature = "const_checked_int_methods", since = "1.47.0")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn checked_shl(self, rhs: u32) -> Option<Self> {
-                let (a, b) = self.overflowing_shl(rhs);
-                if unlikely!(b) {None} else {Some(a)}
-            }
+        /// Checked shift right. Computes `self >> rhs`, returning `None`
+        /// if `rhs` is larger than or equal to the number of bits in `self`.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".checked_shr(4), Some(0x1));")]
+        #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".checked_shr(129), None);")]
+        /// ```
+        #[stable(feature = "wrapping", since = "1.7.0")]
+        #[rustc_const_stable(feature = "const_checked_int_methods", since = "1.47.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn checked_shr(self, rhs: u32) -> Option<Self> {
+            let (a, b) = self.overflowing_shr(rhs);
+            if unlikely!(b) {None} else {Some(a)}
         }
 
-        doc_comment! {
-            concat!("Checked shift right. Computes `self >> rhs`, returning `None`
-if `rhs` is larger than or equal to the number of bits in `self`.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(0x10", stringify!($SelfT), ".checked_shr(4), Some(0x1));
-assert_eq!(0x10", stringify!($SelfT), ".checked_shr(129), None);", $EndFeature, "
-```"),
-            #[stable(feature = "wrapping", since = "1.7.0")]
-            #[rustc_const_stable(feature = "const_checked_int_methods", since = "1.47.0")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn checked_shr(self, rhs: u32) -> Option<Self> {
-                let (a, b) = self.overflowing_shr(rhs);
-                if unlikely!(b) {None} else {Some(a)}
+        /// Checked exponentiation. Computes `self.pow(exp)`, returning `None` if
+        /// overflow occurred.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(2", stringify!($SelfT), ".checked_pow(5), Some(32));")]
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MAX.checked_pow(2), None);")]
+        /// ```
+        #[stable(feature = "no_panic_pow", since = "1.34.0")]
+        #[rustc_const_stable(feature = "const_int_pow", since = "1.50.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn checked_pow(self, mut exp: u32) -> Option<Self> {
+            if exp == 0 {
+                return Some(1);
             }
-        }
-
-        doc_comment! {
-            concat!("Checked exponentiation. Computes `self.pow(exp)`, returning `None` if
-overflow occurred.
-
-# Examples
-
-Basic usage:
+            let mut base = self;
+            let mut acc: Self = 1;
 
-```
-", $Feature, "assert_eq!(2", stringify!($SelfT), ".checked_pow(5), Some(32));
-assert_eq!(", stringify!($SelfT), "::MAX.checked_pow(2), None);", $EndFeature, "
-```"),
-            #[stable(feature = "no_panic_pow", since = "1.34.0")]
-            #[rustc_const_stable(feature = "const_int_pow", since = "1.50.0")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn checked_pow(self, mut exp: u32) -> Option<Self> {
-                if exp == 0 {
-                    return Some(1);
-                }
-                let mut base = self;
-                let mut acc: Self = 1;
-
-                while exp > 1 {
-                    if (exp & 1) == 1 {
-                        acc = try_opt!(acc.checked_mul(base));
-                    }
-                    exp /= 2;
-                    base = try_opt!(base.checked_mul(base));
+            while exp > 1 {
+                if (exp & 1) == 1 {
+                    acc = try_opt!(acc.checked_mul(base));
                 }
-
-                // since exp!=0, finally the exp must be 1.
-                // Deal with the final bit of the exponent separately, since
-                // squaring the base afterwards is not necessary and may cause a
-                // needless overflow.
-
-                Some(try_opt!(acc.checked_mul(base)))
+                exp /= 2;
+                base = try_opt!(base.checked_mul(base));
             }
-        }
-
-        doc_comment! {
-            concat!("Saturating integer addition. Computes `self + rhs`, saturating at
-the numeric bounds instead of overflowing.
-
-# Examples
-
-Basic usage:
 
-```
-", $Feature, "assert_eq!(100", stringify!($SelfT), ".saturating_add(1), 101);
-assert_eq!(", stringify!($SelfT), "::MAX.saturating_add(127), ", stringify!($SelfT), "::MAX);",
-$EndFeature, "
-```"),
+            // since exp!=0, finally the exp must be 1.
+            // Deal with the final bit of the exponent separately, since
+            // squaring the base afterwards is not necessary and may cause a
+            // needless overflow.
 
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[rustc_const_stable(feature = "const_saturating_int_methods", since = "1.47.0")]
-            #[inline]
-            pub const fn saturating_add(self, rhs: Self) -> Self {
-                intrinsics::saturating_add(self, rhs)
-            }
+            Some(try_opt!(acc.checked_mul(base)))
         }
 
-        doc_comment! {
-            concat!("Saturating integer subtraction. Computes `self - rhs`, saturating
-at the numeric bounds instead of overflowing.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(100", stringify!($SelfT), ".saturating_sub(27), 73);
-assert_eq!(13", stringify!($SelfT), ".saturating_sub(127), 0);", $EndFeature, "
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[rustc_const_stable(feature = "const_saturating_int_methods", since = "1.47.0")]
-            #[inline]
-            pub const fn saturating_sub(self, rhs: Self) -> Self {
-                intrinsics::saturating_sub(self, rhs)
-            }
+        /// Saturating integer addition. Computes `self + rhs`, saturating at
+        /// the numeric bounds instead of overflowing.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(100", stringify!($SelfT), ".saturating_add(1), 101);")]
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MAX.saturating_add(127), ", stringify!($SelfT), "::MAX);")]
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[rustc_const_stable(feature = "const_saturating_int_methods", since = "1.47.0")]
+        #[inline]
+        pub const fn saturating_add(self, rhs: Self) -> Self {
+            intrinsics::saturating_add(self, rhs)
         }
 
-        doc_comment! {
-            concat!("Saturating integer multiplication. Computes `self * rhs`,
-saturating at the numeric bounds instead of overflowing.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "
-assert_eq!(2", stringify!($SelfT), ".saturating_mul(10), 20);
-assert_eq!((", stringify!($SelfT), "::MAX).saturating_mul(10), ", stringify!($SelfT),
-"::MAX);", $EndFeature, "
-```"),
-            #[stable(feature = "wrapping", since = "1.7.0")]
-            #[rustc_const_stable(feature = "const_saturating_int_methods", since = "1.47.0")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn saturating_mul(self, rhs: Self) -> Self {
-                match self.checked_mul(rhs) {
-                    Some(x) => x,
-                    None => Self::MAX,
-                }
-            }
+        /// Saturating integer subtraction. Computes `self - rhs`, saturating
+        /// at the numeric bounds instead of overflowing.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(100", stringify!($SelfT), ".saturating_sub(27), 73);")]
+        #[doc = concat!("assert_eq!(13", stringify!($SelfT), ".saturating_sub(127), 0);")]
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[rustc_const_stable(feature = "const_saturating_int_methods", since = "1.47.0")]
+        #[inline]
+        pub const fn saturating_sub(self, rhs: Self) -> Self {
+            intrinsics::saturating_sub(self, rhs)
         }
 
-        doc_comment! {
-            concat!("Saturating integer exponentiation. Computes `self.pow(exp)`,
-saturating at the numeric bounds instead of overflowing.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "
-assert_eq!(4", stringify!($SelfT), ".saturating_pow(3), 64);
-assert_eq!(", stringify!($SelfT), "::MAX.saturating_pow(2), ", stringify!($SelfT), "::MAX);",
-$EndFeature, "
-```"),
-            #[stable(feature = "no_panic_pow", since = "1.34.0")]
-            #[rustc_const_stable(feature = "const_int_pow", since = "1.50.0")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn saturating_pow(self, exp: u32) -> Self {
-                match self.checked_pow(exp) {
-                    Some(x) => x,
-                    None => Self::MAX,
-                }
+        /// Saturating integer multiplication. Computes `self * rhs`,
+        /// saturating at the numeric bounds instead of overflowing.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(2", stringify!($SelfT), ".saturating_mul(10), 20);")]
+        #[doc = concat!("assert_eq!((", stringify!($SelfT), "::MAX).saturating_mul(10), ", stringify!($SelfT),"::MAX);")]
+        /// ```
+        #[stable(feature = "wrapping", since = "1.7.0")]
+        #[rustc_const_stable(feature = "const_saturating_int_methods", since = "1.47.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn saturating_mul(self, rhs: Self) -> Self {
+            match self.checked_mul(rhs) {
+                Some(x) => x,
+                None => Self::MAX,
             }
         }
 
-        doc_comment! {
-            concat!("Wrapping (modular) addition. Computes `self + rhs`,
-wrapping around at the boundary of the type.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(200", stringify!($SelfT), ".wrapping_add(55), 255);
-assert_eq!(200", stringify!($SelfT), ".wrapping_add(", stringify!($SelfT), "::MAX), 199);",
-$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"]
-            #[inline]
-            pub const fn wrapping_add(self, rhs: Self) -> Self {
-                intrinsics::wrapping_add(self, rhs)
+        /// Saturating integer exponentiation. Computes `self.pow(exp)`,
+        /// saturating at the numeric bounds instead of overflowing.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(4", stringify!($SelfT), ".saturating_pow(3), 64);")]
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MAX.saturating_pow(2), ", stringify!($SelfT), "::MAX);")]
+        /// ```
+        #[stable(feature = "no_panic_pow", since = "1.34.0")]
+        #[rustc_const_stable(feature = "const_int_pow", since = "1.50.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn saturating_pow(self, exp: u32) -> Self {
+            match self.checked_pow(exp) {
+                Some(x) => x,
+                None => Self::MAX,
             }
         }
 
-        doc_comment! {
-            concat!("Wrapping (modular) subtraction. Computes `self - rhs`,
-wrapping around at the boundary of the type.
-
-# Examples
-
-Basic usage:
+        /// Wrapping (modular) addition. Computes `self + rhs`,
+        /// wrapping around at the boundary of the type.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(200", stringify!($SelfT), ".wrapping_add(55), 255);")]
+        #[doc = concat!("assert_eq!(200", stringify!($SelfT), ".wrapping_add(", stringify!($SelfT), "::MAX), 199);")]
+        /// ```
+        #[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"]
+        #[inline]
+        pub const fn wrapping_add(self, rhs: Self) -> Self {
+            intrinsics::wrapping_add(self, rhs)
+        }
 
-```
-", $Feature, "assert_eq!(100", stringify!($SelfT), ".wrapping_sub(100), 0);
-assert_eq!(100", stringify!($SelfT), ".wrapping_sub(", stringify!($SelfT), "::MAX), 101);",
-$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"]
-            #[inline]
-            pub const fn wrapping_sub(self, rhs: Self) -> Self {
-                intrinsics::wrapping_sub(self, rhs)
-            }
+        /// Wrapping (modular) subtraction. Computes `self - rhs`,
+        /// wrapping around at the boundary of the type.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(100", stringify!($SelfT), ".wrapping_sub(100), 0);")]
+        #[doc = concat!("assert_eq!(100", stringify!($SelfT), ".wrapping_sub(", stringify!($SelfT), "::MAX), 101);")]
+        /// ```
+        #[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"]
+        #[inline]
+        pub const fn wrapping_sub(self, rhs: Self) -> Self {
+            intrinsics::wrapping_sub(self, rhs)
         }
 
         /// Wrapping (modular) multiplication. Computes `self *
@@ -948,108 +862,100 @@ $EndFeature, "
             intrinsics::wrapping_mul(self, rhs)
         }
 
-        doc_comment! {
-            concat!("Wrapping (modular) division. Computes `self / rhs`.
-Wrapped division on unsigned types is just normal division.
-There's no way wrapping could ever happen.
-This function exists, so that all operations
-are accounted for in the wrapping operations.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(100", stringify!($SelfT), ".wrapping_div(10), 10);", $EndFeature, "
-```"),
-            #[stable(feature = "num_wrapping", since = "1.2.0")]
-            #[rustc_const_unstable(feature = "const_wrapping_int_methods", issue = "53718")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const 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.
-There's no way wrapping could ever happen.
-This function exists, so that all operations
-are accounted for in the wrapping operations.
-Since, for the positive integers, all common
-definitions of division are equal, this
-is exactly equal to `self.wrapping_div(rhs)`.
-
-# Examples
-
-Basic usage:
-
-```
-assert_eq!(100", stringify!($SelfT), ".wrapping_div_euclid(10), 10);
-```"),
-            #[stable(feature = "euclidean_division", since = "1.38.0")]
-            #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn wrapping_div_euclid(self, rhs: Self) -> Self {
-                self / rhs
-            }
-        }
-
-        doc_comment! {
-            concat!("Wrapping (modular) remainder. Computes `self % rhs`.
-Wrapped remainder calculation on unsigned types is
-just the regular remainder calculation.
-There's no way wrapping could ever happen.
-This function exists, so that all operations
-are accounted for in the wrapping operations.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(100", stringify!($SelfT), ".wrapping_rem(10), 0);", $EndFeature, "
-```"),
-            #[stable(feature = "num_wrapping", since = "1.2.0")]
-            #[rustc_const_unstable(feature = "const_wrapping_int_methods", issue = "53718")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn wrapping_rem(self, rhs: Self) -> Self {
-                self % rhs
-            }
+        /// Wrapping (modular) division. Computes `self / rhs`.
+        /// Wrapped division on unsigned types is just normal division.
+        /// There's no way wrapping could ever happen.
+        /// This function exists, so that all operations
+        /// are accounted for in the wrapping operations.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(100", stringify!($SelfT), ".wrapping_div(10), 10);")]
+        /// ```
+        #[stable(feature = "num_wrapping", since = "1.2.0")]
+        #[rustc_const_unstable(feature = "const_wrapping_int_methods", issue = "53718")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn wrapping_div(self, rhs: Self) -> Self {
+            self / rhs
+        }
+
+        /// Wrapping Euclidean division. Computes `self.div_euclid(rhs)`.
+        /// Wrapped division on unsigned types is just normal division.
+        /// There's no way wrapping could ever happen.
+        /// This function exists, so that all operations
+        /// are accounted for in the wrapping operations.
+        /// Since, for the positive integers, all common
+        /// definitions of division are equal, this
+        /// is exactly equal to `self.wrapping_div(rhs)`.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(100", stringify!($SelfT), ".wrapping_div_euclid(10), 10);")]
+        /// ```
+        #[stable(feature = "euclidean_division", since = "1.38.0")]
+        #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn wrapping_div_euclid(self, rhs: Self) -> Self {
+            self / rhs
         }
 
-        doc_comment! {
-            concat!("Wrapping Euclidean modulo. Computes `self.rem_euclid(rhs)`.
-Wrapped modulo calculation on unsigned types is
-just the regular remainder calculation.
-There's no way wrapping could ever happen.
-This function exists, so that all operations
-are accounted for in the wrapping operations.
-Since, for the positive integers, all common
-definitions of division are equal, this
-is exactly equal to `self.wrapping_rem(rhs)`.
-
-# Examples
-
-Basic usage:
-
-```
-assert_eq!(100", stringify!($SelfT), ".wrapping_rem_euclid(10), 0);
-```"),
-            #[stable(feature = "euclidean_division", since = "1.38.0")]
-            #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn wrapping_rem_euclid(self, rhs: Self) -> Self {
-                self % rhs
-            }
+        /// Wrapping (modular) remainder. Computes `self % rhs`.
+        /// Wrapped remainder calculation on unsigned types is
+        /// just the regular remainder calculation.
+        /// There's no way wrapping could ever happen.
+        /// This function exists, so that all operations
+        /// are accounted for in the wrapping operations.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(100", stringify!($SelfT), ".wrapping_rem(10), 0);")]
+        /// ```
+        #[stable(feature = "num_wrapping", since = "1.2.0")]
+        #[rustc_const_unstable(feature = "const_wrapping_int_methods", issue = "53718")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn wrapping_rem(self, rhs: Self) -> Self {
+            self % rhs
+        }
+
+        /// Wrapping Euclidean modulo. Computes `self.rem_euclid(rhs)`.
+        /// Wrapped modulo calculation on unsigned types is
+        /// just the regular remainder calculation.
+        /// There's no way wrapping could ever happen.
+        /// This function exists, so that all operations
+        /// are accounted for in the wrapping operations.
+        /// Since, for the positive integers, all common
+        /// definitions of division are equal, this
+        /// is exactly equal to `self.wrapping_rem(rhs)`.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(100", stringify!($SelfT), ".wrapping_rem_euclid(10), 0);")]
+        /// ```
+        #[stable(feature = "euclidean_division", since = "1.38.0")]
+        #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn wrapping_rem_euclid(self, rhs: Self) -> Self {
+            self % rhs
         }
 
         /// Wrapping (modular) negation. Computes `-self`,
@@ -1080,167 +986,156 @@ assert_eq!(100", stringify!($SelfT), ".wrapping_rem_euclid(10), 0);
             self.overflowing_neg().0
         }
 
-        doc_comment! {
-            concat!("Panic-free bitwise shift-left; yields `self << mask(rhs)`,
-where `mask` removes any high-order bits of `rhs` that
-would cause the shift to exceed the bitwidth of the type.
-
-Note that this is *not* the same as a rotate-left; the
-RHS of a wrapping shift-left is restricted to the range
-of the type, rather than the bits shifted out of the LHS
-being returned to the other end. The primitive integer
-types all implement a [`rotate_left`](#method.rotate_left) function,
-which may be what you want instead.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(1", stringify!($SelfT), ".wrapping_shl(7), 128);
-assert_eq!(1", stringify!($SelfT), ".wrapping_shl(128), 1);", $EndFeature, "
-```"),
-            #[stable(feature = "num_wrapping", since = "1.2.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"]
-            #[inline]
-            pub const fn wrapping_shl(self, rhs: u32) -> Self {
-                // SAFETY: the masking by the bitsize of the type ensures that we do not shift
-                // out of bounds
-                unsafe {
-                    intrinsics::unchecked_shl(self, (rhs & ($BITS - 1)) as $SelfT)
-                }
+        /// Panic-free bitwise shift-left; yields `self << mask(rhs)`,
+        /// where `mask` removes any high-order bits of `rhs` that
+        /// would cause the shift to exceed the bitwidth of the type.
+        ///
+        /// Note that this is *not* the same as a rotate-left; the
+        /// RHS of a wrapping shift-left is restricted to the range
+        /// of the type, rather than the bits shifted out of the LHS
+        /// being returned to the other end. The primitive integer
+        /// types all implement a [`rotate_left`](#method.rotate_left) function,
+        /// which may be what you want instead.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(1", stringify!($SelfT), ".wrapping_shl(7), 128);")]
+        #[doc = concat!("assert_eq!(1", stringify!($SelfT), ".wrapping_shl(128), 1);")]
+        /// ```
+        #[stable(feature = "num_wrapping", since = "1.2.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"]
+        #[inline]
+        pub const fn wrapping_shl(self, rhs: u32) -> Self {
+            // SAFETY: the masking by the bitsize of the type ensures that we do not shift
+            // out of bounds
+            unsafe {
+                intrinsics::unchecked_shl(self, (rhs & ($BITS - 1)) as $SelfT)
             }
         }
 
-        doc_comment! {
-            concat!("Panic-free bitwise shift-right; yields `self >> mask(rhs)`,
-where `mask` removes any high-order bits of `rhs` that
-would cause the shift to exceed the bitwidth of the type.
-
-Note that this is *not* the same as a rotate-right; the
-RHS of a wrapping shift-right is restricted to the range
-of the type, rather than the bits shifted out of the LHS
-being returned to the other end. The primitive integer
-types all implement a [`rotate_right`](#method.rotate_right) function,
-which may be what you want instead.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(128", stringify!($SelfT), ".wrapping_shr(7), 1);
-assert_eq!(128", stringify!($SelfT), ".wrapping_shr(128), 128);", $EndFeature, "
-```"),
-            #[stable(feature = "num_wrapping", since = "1.2.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"]
-            #[inline]
-            pub const fn wrapping_shr(self, rhs: u32) -> Self {
-                // SAFETY: the masking by the bitsize of the type ensures that we do not shift
-                // out of bounds
-                unsafe {
-                    intrinsics::unchecked_shr(self, (rhs & ($BITS - 1)) as $SelfT)
-                }
+        /// Panic-free bitwise shift-right; yields `self >> mask(rhs)`,
+        /// where `mask` removes any high-order bits of `rhs` that
+        /// would cause the shift to exceed the bitwidth of the type.
+        ///
+        /// Note that this is *not* the same as a rotate-right; the
+        /// RHS of a wrapping shift-right is restricted to the range
+        /// of the type, rather than the bits shifted out of the LHS
+        /// being returned to the other end. The primitive integer
+        /// types all implement a [`rotate_right`](#method.rotate_right) function,
+        /// which may be what you want instead.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(128", stringify!($SelfT), ".wrapping_shr(7), 1);")]
+        #[doc = concat!("assert_eq!(128", stringify!($SelfT), ".wrapping_shr(128), 128);")]
+        /// ```
+        #[stable(feature = "num_wrapping", since = "1.2.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"]
+        #[inline]
+        pub const fn wrapping_shr(self, rhs: u32) -> Self {
+            // SAFETY: the masking by the bitsize of the type ensures that we do not shift
+            // out of bounds
+            unsafe {
+                intrinsics::unchecked_shr(self, (rhs & ($BITS - 1)) as $SelfT)
             }
         }
 
-        doc_comment! {
-            concat!("Wrapping (modular) exponentiation. Computes `self.pow(exp)`,
-wrapping around at the boundary of the type.
-
-# Examples
-
-Basic usage:
+        /// Wrapping (modular) exponentiation. Computes `self.pow(exp)`,
+        /// wrapping around at the boundary of the type.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(3", stringify!($SelfT), ".wrapping_pow(5), 243);")]
+        /// assert_eq!(3u8.wrapping_pow(6), 217);
+        /// ```
+        #[stable(feature = "no_panic_pow", since = "1.34.0")]
+        #[rustc_const_stable(feature = "const_int_pow", since = "1.50.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn wrapping_pow(self, mut exp: u32) -> Self {
+            if exp == 0 {
+                return 1;
+            }
+            let mut base = self;
+            let mut acc: Self = 1;
 
-```
-", $Feature, "assert_eq!(3", stringify!($SelfT), ".wrapping_pow(5), 243);
-assert_eq!(3u8.wrapping_pow(6), 217);", $EndFeature, "
-```"),
-            #[stable(feature = "no_panic_pow", since = "1.34.0")]
-            #[rustc_const_stable(feature = "const_int_pow", since = "1.50.0")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn wrapping_pow(self, mut exp: u32) -> Self {
-                if exp == 0 {
-                    return 1;
-                }
-                let mut base = self;
-                let mut acc: Self = 1;
-
-                while exp > 1 {
-                    if (exp & 1) == 1 {
-                        acc = acc.wrapping_mul(base);
-                    }
-                    exp /= 2;
-                    base = base.wrapping_mul(base);
+            while exp > 1 {
+                if (exp & 1) == 1 {
+                    acc = acc.wrapping_mul(base);
                 }
-
-                // since exp!=0, finally the exp must be 1.
-                // Deal with the final bit of the exponent separately, since
-                // squaring the base afterwards is not necessary and may cause a
-                // needless overflow.
-                acc.wrapping_mul(base)
+                exp /= 2;
+                base = base.wrapping_mul(base);
             }
-        }
-
-        doc_comment! {
-            concat!("Calculates `self` + `rhs`
 
-Returns a tuple of the addition along with a boolean indicating
-whether an arithmetic overflow would occur. If an overflow would
-have occurred then the wrapped value is returned.
-
-# Examples
-
-Basic usage
-
-```
-", $Feature, "
-assert_eq!(5", stringify!($SelfT), ".overflowing_add(2), (7, false));
-assert_eq!(", stringify!($SelfT), "::MAX.overflowing_add(1), (0, true));", $EndFeature, "
-```"),
-            #[stable(feature = "wrapping", since = "1.7.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"]
-            #[inline]
-            pub const fn overflowing_add(self, rhs: Self) -> (Self, bool) {
-                let (a, b) = intrinsics::add_with_overflow(self as $ActualT, rhs as $ActualT);
-                (a as Self, b)
-            }
+            // since exp!=0, finally the exp must be 1.
+            // Deal with the final bit of the exponent separately, since
+            // squaring the base afterwards is not necessary and may cause a
+            // needless overflow.
+            acc.wrapping_mul(base)
         }
 
-        doc_comment! {
-            concat!("Calculates `self` - `rhs`
-
-Returns a tuple of the subtraction along with a boolean indicating
-whether an arithmetic overflow would occur. If an overflow would
-have occurred then the wrapped value is returned.
-
-# Examples
-
-Basic usage
+        /// Calculates `self` + `rhs`
+        ///
+        /// Returns a tuple of the addition along with a boolean indicating
+        /// whether an arithmetic overflow would occur. If an overflow would
+        /// have occurred then the wrapped value is returned.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage
+        ///
+        /// ```
+        ///
+        #[doc = concat!("assert_eq!(5", stringify!($SelfT), ".overflowing_add(2), (7, false));")]
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MAX.overflowing_add(1), (0, true));")]
+        /// ```
+        #[stable(feature = "wrapping", since = "1.7.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"]
+        #[inline]
+        pub const fn overflowing_add(self, rhs: Self) -> (Self, bool) {
+            let (a, b) = intrinsics::add_with_overflow(self as $ActualT, rhs as $ActualT);
+            (a as Self, b)
+        }
 
-```
-", $Feature, "
-assert_eq!(5", stringify!($SelfT), ".overflowing_sub(2), (3, false));
-assert_eq!(0", stringify!($SelfT), ".overflowing_sub(1), (", stringify!($SelfT), "::MAX, true));",
-$EndFeature, "
-```"),
-            #[stable(feature = "wrapping", since = "1.7.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"]
-            #[inline]
-            pub const fn overflowing_sub(self, rhs: Self) -> (Self, bool) {
-                let (a, b) = intrinsics::sub_with_overflow(self as $ActualT, rhs as $ActualT);
-                (a as Self, b)
-            }
+        /// Calculates `self` - `rhs`
+        ///
+        /// Returns a tuple of the subtraction along with a boolean indicating
+        /// whether an arithmetic overflow would occur. If an overflow would
+        /// have occurred then the wrapped value is returned.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage
+        ///
+        /// ```
+        ///
+        #[doc = concat!("assert_eq!(5", stringify!($SelfT), ".overflowing_sub(2), (3, false));")]
+        #[doc = concat!("assert_eq!(0", stringify!($SelfT), ".overflowing_sub(1), (", stringify!($SelfT), "::MAX, true));")]
+        /// ```
+        #[stable(feature = "wrapping", since = "1.7.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"]
+        #[inline]
+        pub const fn overflowing_sub(self, rhs: Self) -> (Self, bool) {
+            let (a, b) = intrinsics::sub_with_overflow(self as $ActualT, rhs as $ActualT);
+            (a as Self, b)
         }
 
         /// Calculates the multiplication of `self` and `rhs`.
@@ -1270,269 +1165,251 @@ $EndFeature, "
             (a as Self, b)
         }
 
-        doc_comment! {
-            concat!("Calculates the divisor when `self` is divided by `rhs`.
-
-Returns a tuple of the divisor along with a boolean indicating
-whether an arithmetic overflow would occur. Note that for unsigned
-integers overflow never occurs, so the second value is always
-`false`.
-
-# Panics
-
-This function will panic if `rhs` is 0.
-
-# Examples
-
-Basic usage
-
-```
-", $Feature, "assert_eq!(5", stringify!($SelfT), ".overflowing_div(2), (2, false));", $EndFeature, "
-```"),
-            #[inline]
-            #[stable(feature = "wrapping", since = "1.7.0")]
-            #[rustc_const_unstable(feature = "const_overflowing_int_methods", issue = "53718")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            pub const fn overflowing_div(self, rhs: Self) -> (Self, bool) {
-                (self / rhs, false)
-            }
+        /// Calculates the divisor when `self` is divided by `rhs`.
+        ///
+        /// Returns a tuple of the divisor along with a boolean indicating
+        /// whether an arithmetic overflow would occur. Note that for unsigned
+        /// integers overflow never occurs, so the second value is always
+        /// `false`.
+        ///
+        /// # Panics
+        ///
+        /// This function will panic if `rhs` is 0.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(5", stringify!($SelfT), ".overflowing_div(2), (2, false));")]
+        /// ```
+        #[inline]
+        #[stable(feature = "wrapping", since = "1.7.0")]
+        #[rustc_const_unstable(feature = "const_overflowing_int_methods", issue = "53718")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        pub const fn overflowing_div(self, rhs: Self) -> (Self, bool) {
+            (self / rhs, false)
         }
 
-        doc_comment! {
-            concat!("Calculates the quotient of Euclidean division `self.div_euclid(rhs)`.
-
-Returns a tuple of the divisor along with a boolean indicating
-whether an arithmetic overflow would occur. Note that for unsigned
-integers overflow never occurs, so the second value is always
-`false`.
-Since, for the positive integers, all common
-definitions of division are equal, this
-is exactly equal to `self.overflowing_div(rhs)`.
-
-# Panics
-
-This function will panic if `rhs` is 0.
-
-# Examples
-
-Basic usage
-
-```
-assert_eq!(5", stringify!($SelfT), ".overflowing_div_euclid(2), (2, false));
-```"),
-            #[inline]
-            #[stable(feature = "euclidean_division", since = "1.38.0")]
-            #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            pub const fn overflowing_div_euclid(self, rhs: Self) -> (Self, bool) {
-                (self / rhs, false)
-            }
+        /// Calculates the quotient of Euclidean division `self.div_euclid(rhs)`.
+        ///
+        /// Returns a tuple of the divisor along with a boolean indicating
+        /// whether an arithmetic overflow would occur. Note that for unsigned
+        /// integers overflow never occurs, so the second value is always
+        /// `false`.
+        /// Since, for the positive integers, all common
+        /// definitions of division are equal, this
+        /// is exactly equal to `self.overflowing_div(rhs)`.
+        ///
+        /// # Panics
+        ///
+        /// This function will panic if `rhs` is 0.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(5", stringify!($SelfT), ".overflowing_div_euclid(2), (2, false));")]
+        /// ```
+        #[inline]
+        #[stable(feature = "euclidean_division", since = "1.38.0")]
+        #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        pub const fn overflowing_div_euclid(self, rhs: Self) -> (Self, bool) {
+            (self / rhs, false)
         }
 
-        doc_comment! {
-            concat!("Calculates the remainder when `self` is divided by `rhs`.
-
-Returns a tuple of the remainder after dividing along with a boolean
-indicating whether an arithmetic overflow would occur. Note that for
-unsigned integers overflow never occurs, so the second value is
-always `false`.
-
-# Panics
-
-This function will panic if `rhs` is 0.
-
-# Examples
-
-Basic usage
-
-```
-", $Feature, "assert_eq!(5", stringify!($SelfT), ".overflowing_rem(2), (1, false));", $EndFeature, "
-```"),
-            #[inline]
-            #[stable(feature = "wrapping", since = "1.7.0")]
-            #[rustc_const_unstable(feature = "const_overflowing_int_methods", issue = "53718")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            pub const fn overflowing_rem(self, rhs: Self) -> (Self, bool) {
-                (self % rhs, false)
-            }
+        /// Calculates the remainder when `self` is divided by `rhs`.
+        ///
+        /// Returns a tuple of the remainder after dividing along with a boolean
+        /// indicating whether an arithmetic overflow would occur. Note that for
+        /// unsigned integers overflow never occurs, so the second value is
+        /// always `false`.
+        ///
+        /// # Panics
+        ///
+        /// This function will panic if `rhs` is 0.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(5", stringify!($SelfT), ".overflowing_rem(2), (1, false));")]
+        /// ```
+        #[inline]
+        #[stable(feature = "wrapping", since = "1.7.0")]
+        #[rustc_const_unstable(feature = "const_overflowing_int_methods", issue = "53718")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        pub const fn overflowing_rem(self, rhs: Self) -> (Self, bool) {
+            (self % rhs, false)
         }
 
-        doc_comment! {
-            concat!("Calculates the remainder `self.rem_euclid(rhs)` as if by Euclidean division.
-
-Returns a tuple of the modulo after dividing along with a boolean
-indicating whether an arithmetic overflow would occur. Note that for
-unsigned integers overflow never occurs, so the second value is
-always `false`.
-Since, for the positive integers, all common
-definitions of division are equal, this operation
-is exactly equal to `self.overflowing_rem(rhs)`.
-
-# Panics
-
-This function will panic if `rhs` is 0.
-
-# Examples
-
-Basic usage
-
-```
-assert_eq!(5", stringify!($SelfT), ".overflowing_rem_euclid(2), (1, false));
-```"),
-            #[inline]
-            #[stable(feature = "euclidean_division", since = "1.38.0")]
-            #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            pub const fn overflowing_rem_euclid(self, rhs: Self) -> (Self, bool) {
-                (self % rhs, false)
-            }
+        /// Calculates the remainder `self.rem_euclid(rhs)` as if by Euclidean division.
+        ///
+        /// Returns a tuple of the modulo after dividing along with a boolean
+        /// indicating whether an arithmetic overflow would occur. Note that for
+        /// unsigned integers overflow never occurs, so the second value is
+        /// always `false`.
+        /// Since, for the positive integers, all common
+        /// definitions of division are equal, this operation
+        /// is exactly equal to `self.overflowing_rem(rhs)`.
+        ///
+        /// # Panics
+        ///
+        /// This function will panic if `rhs` is 0.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(5", stringify!($SelfT), ".overflowing_rem_euclid(2), (1, false));")]
+        /// ```
+        #[inline]
+        #[stable(feature = "euclidean_division", since = "1.38.0")]
+        #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        pub const fn overflowing_rem_euclid(self, rhs: Self) -> (Self, bool) {
+            (self % rhs, false)
         }
 
-        doc_comment! {
-            concat!("Negates self in an overflowing fashion.
-
-Returns `!self + 1` using wrapping operations to return the value
-that represents the negation of this unsigned value. Note that for
-positive unsigned values overflow always occurs, but negating 0 does
-not overflow.
-
-# Examples
-
-Basic usage
-
-```
-", $Feature, "assert_eq!(0", stringify!($SelfT), ".overflowing_neg(), (0, false));
-assert_eq!(2", stringify!($SelfT), ".overflowing_neg(), (-2i32 as ", stringify!($SelfT),
-", true));", $EndFeature, "
-```"),
-            #[inline]
-            #[stable(feature = "wrapping", since = "1.7.0")]
-            #[rustc_const_stable(feature = "const_wrapping_math", since = "1.32.0")]
-            pub const fn overflowing_neg(self) -> (Self, bool) {
-                ((!self).wrapping_add(1), self != 0)
-            }
+        /// Negates self in an overflowing fashion.
+        ///
+        /// Returns `!self + 1` using wrapping operations to return the value
+        /// that represents the negation of this unsigned value. Note that for
+        /// positive unsigned values overflow always occurs, but negating 0 does
+        /// not overflow.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(0", stringify!($SelfT), ".overflowing_neg(), (0, false));")]
+        #[doc = concat!("assert_eq!(2", stringify!($SelfT), ".overflowing_neg(), (-2i32 as ", stringify!($SelfT), ", true));")]
+        /// ```
+        #[inline]
+        #[stable(feature = "wrapping", since = "1.7.0")]
+        #[rustc_const_stable(feature = "const_wrapping_math", since = "1.32.0")]
+        pub const fn overflowing_neg(self) -> (Self, bool) {
+            ((!self).wrapping_add(1), self != 0)
         }
 
-        doc_comment! {
-            concat!("Shifts self left by `rhs` bits.
-
-Returns a tuple of the shifted version of self along with a boolean
-indicating whether the shift value was larger than or equal to the
-number of bits. If the shift value is too large, then value is
-masked (N-1) where N is the number of bits, and this value is then
-used to perform the shift.
-
-# Examples
-
-Basic usage
-
-```
-", $Feature, "assert_eq!(0x1", stringify!($SelfT), ".overflowing_shl(4), (0x10, false));
-assert_eq!(0x1", stringify!($SelfT), ".overflowing_shl(132), (0x10, true));", $EndFeature, "
-```"),
-            #[stable(feature = "wrapping", since = "1.7.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"]
-            #[inline]
-            pub const fn overflowing_shl(self, rhs: u32) -> (Self, bool) {
-                (self.wrapping_shl(rhs), (rhs > ($BITS - 1)))
-            }
+        /// Shifts self left by `rhs` bits.
+        ///
+        /// Returns a tuple of the shifted version of self along with a boolean
+        /// indicating whether the shift value was larger than or equal to the
+        /// number of bits. If the shift value is too large, then value is
+        /// masked (N-1) where N is the number of bits, and this value is then
+        /// used to perform the shift.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(0x1", stringify!($SelfT), ".overflowing_shl(4), (0x10, false));")]
+        #[doc = concat!("assert_eq!(0x1", stringify!($SelfT), ".overflowing_shl(132), (0x10, true));")]
+        /// ```
+        #[stable(feature = "wrapping", since = "1.7.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"]
+        #[inline]
+        pub const fn overflowing_shl(self, rhs: u32) -> (Self, bool) {
+            (self.wrapping_shl(rhs), (rhs > ($BITS - 1)))
         }
 
-        doc_comment! {
-            concat!("Shifts self right by `rhs` bits.
-
-Returns a tuple of the shifted version of self along with a boolean
-indicating whether the shift value was larger than or equal to the
-number of bits. If the shift value is too large, then value is
-masked (N-1) where N is the number of bits, and this value is then
-used to perform the shift.
-
-# Examples
-
-Basic usage
-
-```
-", $Feature, "assert_eq!(0x10", stringify!($SelfT), ".overflowing_shr(4), (0x1, false));
-assert_eq!(0x10", stringify!($SelfT), ".overflowing_shr(132), (0x1, true));", $EndFeature, "
-```"),
-            #[stable(feature = "wrapping", since = "1.7.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"]
-            #[inline]
-            pub const fn overflowing_shr(self, rhs: u32) -> (Self, bool) {
-                (self.wrapping_shr(rhs), (rhs > ($BITS - 1)))
-            }
+        /// Shifts self right by `rhs` bits.
+        ///
+        /// Returns a tuple of the shifted version of self along with a boolean
+        /// indicating whether the shift value was larger than or equal to the
+        /// number of bits. If the shift value is too large, then value is
+        /// masked (N-1) where N is the number of bits, and this value is then
+        /// used to perform the shift.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".overflowing_shr(4), (0x1, false));")]
+        #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".overflowing_shr(132), (0x1, true));")]
+        /// ```
+        #[stable(feature = "wrapping", since = "1.7.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"]
+        #[inline]
+        pub const fn overflowing_shr(self, rhs: u32) -> (Self, bool) {
+            (self.wrapping_shr(rhs), (rhs > ($BITS - 1)))
         }
 
-        doc_comment! {
-            concat!("Raises self to the power of `exp`, using exponentiation by squaring.
-
-Returns a tuple of the exponentiation along with a bool indicating
-whether an overflow happened.
-
-# Examples
-
-Basic usage:
+        /// Raises self to the power of `exp`, using exponentiation by squaring.
+        ///
+        /// Returns a tuple of the exponentiation along with a bool indicating
+        /// whether an overflow happened.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(3", stringify!($SelfT), ".overflowing_pow(5), (243, false));")]
+        /// assert_eq!(3u8.overflowing_pow(6), (217, true));
+        /// ```
+        #[stable(feature = "no_panic_pow", since = "1.34.0")]
+        #[rustc_const_stable(feature = "const_int_pow", since = "1.50.0")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn overflowing_pow(self, mut exp: u32) -> (Self, bool) {
+            if exp == 0{
+                return (1,false);
+            }
+            let mut base = self;
+            let mut acc: Self = 1;
+            let mut overflown = false;
+            // Scratch space for storing results of overflowing_mul.
+            let mut r;
 
-```
-", $Feature, "assert_eq!(3", stringify!($SelfT), ".overflowing_pow(5), (243, false));
-assert_eq!(3u8.overflowing_pow(6), (217, true));", $EndFeature, "
-```"),
-            #[stable(feature = "no_panic_pow", since = "1.34.0")]
-            #[rustc_const_stable(feature = "const_int_pow", since = "1.50.0")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            pub const fn overflowing_pow(self, mut exp: u32) -> (Self, bool) {
-                if exp == 0{
-                    return (1,false);
-                }
-                let mut base = self;
-                let mut acc: Self = 1;
-                let mut overflown = false;
-                // Scratch space for storing results of overflowing_mul.
-                let mut r;
-
-                while exp > 1 {
-                    if (exp & 1) == 1 {
-                        r = acc.overflowing_mul(base);
-                        acc = r.0;
-                        overflown |= r.1;
-                    }
-                    exp /= 2;
-                    r = base.overflowing_mul(base);
-                    base = r.0;
+            while exp > 1 {
+                if (exp & 1) == 1 {
+                    r = acc.overflowing_mul(base);
+                    acc = r.0;
                     overflown |= r.1;
                 }
-
-                // since exp!=0, finally the exp must be 1.
-                // Deal with the final bit of the exponent separately, since
-                // squaring the base afterwards is not necessary and may cause a
-                // needless overflow.
-                r = acc.overflowing_mul(base);
-                r.1 |= overflown;
-
-                r
+                exp /= 2;
+                r = base.overflowing_mul(base);
+                base = r.0;
+                overflown |= r.1;
             }
-        }
 
-        doc_comment! {
-            concat!("Raises self to the power of `exp`, using exponentiation by squaring.
-
-# Examples
+            // since exp!=0, finally the exp must be 1.
+            // Deal with the final bit of the exponent separately, since
+            // squaring the base afterwards is not necessary and may cause a
+            // needless overflow.
+            r = acc.overflowing_mul(base);
+            r.1 |= overflown;
 
-Basic usage:
+            r
+        }
 
-```
-", $Feature, "assert_eq!(2", stringify!($SelfT), ".pow(5), 32);", $EndFeature, "
-```"),
+        /// Raises self to the power of `exp`, using exponentiation by squaring.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(2", stringify!($SelfT), ".pow(5), 32);")]
+        /// ```
         #[stable(feature = "rust1", since = "1.0.0")]
         #[rustc_const_stable(feature = "const_int_pow", since = "1.50.0")]
         #[must_use = "this returns the result of the operation, \
@@ -1560,84 +1437,77 @@ Basic usage:
             // needless overflow.
             acc * base
         }
-    }
-
-        doc_comment! {
-            concat!("Performs Euclidean division.
-
-Since, for the positive integers, all common
-definitions of division are equal, this
-is exactly equal to `self / rhs`.
-
-# Panics
 
-This function will panic if `rhs` is 0.
-
-# Examples
-
-Basic usage:
-
-```
-assert_eq!(7", stringify!($SelfT), ".div_euclid(4), 1); // or any other integer type
-```"),
-            #[stable(feature = "euclidean_division", since = "1.38.0")]
-            #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            #[rustc_inherit_overflow_checks]
-            pub const fn div_euclid(self, rhs: Self) -> Self {
-                self / rhs
-            }
+        /// Performs Euclidean division.
+        ///
+        /// Since, for the positive integers, all common
+        /// definitions of division are equal, this
+        /// is exactly equal to `self / rhs`.
+        ///
+        /// # Panics
+        ///
+        /// This function will panic if `rhs` is 0.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(7", stringify!($SelfT), ".div_euclid(4), 1); // or any other integer type")]
+        /// ```
+        #[stable(feature = "euclidean_division", since = "1.38.0")]
+        #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        #[rustc_inherit_overflow_checks]
+        pub const fn div_euclid(self, rhs: Self) -> Self {
+            self / rhs
         }
 
 
-        doc_comment! {
-            concat!("Calculates the least remainder of `self (mod rhs)`.
-
-Since, for the positive integers, all common
-definitions of division are equal, this
-is exactly equal to `self % rhs`.
-
-# Panics
-
-This function will panic if `rhs` is 0.
-
-# Examples
-
-Basic usage:
-
-```
-assert_eq!(7", stringify!($SelfT), ".rem_euclid(4), 3); // or any other integer type
-```"),
-            #[stable(feature = "euclidean_division", since = "1.38.0")]
-            #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")]
-            #[must_use = "this returns the result of the operation, \
-                          without modifying the original"]
-            #[inline]
-            #[rustc_inherit_overflow_checks]
-            pub const fn rem_euclid(self, rhs: Self) -> Self {
-                self % rhs
-            }
+        /// Calculates the least remainder of `self (mod rhs)`.
+        ///
+        /// Since, for the positive integers, all common
+        /// definitions of division are equal, this
+        /// is exactly equal to `self % rhs`.
+        ///
+        /// # Panics
+        ///
+        /// This function will panic if `rhs` is 0.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(7", stringify!($SelfT), ".rem_euclid(4), 3); // or any other integer type")]
+        /// ```
+        #[stable(feature = "euclidean_division", since = "1.38.0")]
+        #[rustc_const_unstable(feature = "const_euclidean_int_methods", issue = "53718")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        #[rustc_inherit_overflow_checks]
+        pub const fn rem_euclid(self, rhs: Self) -> Self {
+            self % rhs
         }
 
-        doc_comment! {
-            concat!("Returns `true` if and only if `self == 2^k` for some `k`.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert!(16", stringify!($SelfT), ".is_power_of_two());
-assert!(!10", stringify!($SelfT), ".is_power_of_two());", $EndFeature, "
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_is_power_of_two", since = "1.32.0")]
-            #[inline]
-            pub const fn is_power_of_two(self) -> bool {
-                self.count_ones() == 1
-            }
+        /// Returns `true` if and only if `self == 2^k` for some `k`.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert!(16", stringify!($SelfT), ".is_power_of_two());")]
+        #[doc = concat!("assert!(!10", stringify!($SelfT), ".is_power_of_two());")]
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_is_power_of_two", since = "1.32.0")]
+        #[inline]
+        pub const fn is_power_of_two(self) -> bool {
+            self.count_ones() == 1
         }
 
         // Returns one less than next power of two.
@@ -1663,332 +1533,302 @@ assert!(!10", stringify!($SelfT), ".is_power_of_two());", $EndFeature, "
             <$SelfT>::MAX >> z
         }
 
-        doc_comment! {
-            concat!("Returns the smallest power of two greater than or equal to `self`.
-
-When return value overflows (i.e., `self > (1 << (N-1))` for type
-`uN`), it panics in debug mode and return value is wrapped to 0 in
-release mode (the only situation in which method can return 0).
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(2", stringify!($SelfT), ".next_power_of_two(), 2);
-assert_eq!(3", stringify!($SelfT), ".next_power_of_two(), 4);", $EndFeature, "
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_int_pow", since = "1.50.0")]
-            #[inline]
-            #[rustc_inherit_overflow_checks]
-            pub const fn next_power_of_two(self) -> Self {
-                self.one_less_than_next_power_of_two() + 1
-            }
-        }
-
-        doc_comment! {
-            concat!("Returns the smallest power of two greater than or equal to `n`. If
-the next power of two is greater than the type's maximum value,
-`None` is returned, otherwise the power of two is wrapped in `Some`.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(2", stringify!($SelfT),
-".checked_next_power_of_two(), Some(2));
-assert_eq!(3", stringify!($SelfT), ".checked_next_power_of_two(), Some(4));
-assert_eq!(", stringify!($SelfT), "::MAX.checked_next_power_of_two(), None);",
-$EndFeature, "
-```"),
-            #[inline]
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_stable(feature = "const_int_pow", since = "1.50.0")]
-            pub const fn checked_next_power_of_two(self) -> Option<Self> {
-                self.one_less_than_next_power_of_two().checked_add(1)
-            }
+        /// Returns the smallest power of two greater than or equal to `self`.
+        ///
+        /// When return value overflows (i.e., `self > (1 << (N-1))` for type
+        /// `uN`), it panics in debug mode and return value is wrapped to 0 in
+        /// release mode (the only situation in which method can return 0).
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(2", stringify!($SelfT), ".next_power_of_two(), 2);")]
+        #[doc = concat!("assert_eq!(3", stringify!($SelfT), ".next_power_of_two(), 4);")]
+        /// ```
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_int_pow", since = "1.50.0")]
+        #[inline]
+        #[rustc_inherit_overflow_checks]
+        pub const fn next_power_of_two(self) -> Self {
+            self.one_less_than_next_power_of_two() + 1
         }
 
-        doc_comment! {
-            concat!("Returns the smallest power of two greater than or equal to `n`. If
-the next power of two is greater than the type's maximum value,
-the return value is wrapped to `0`.
-
-# Examples
-
-Basic usage:
-
-```
-#![feature(wrapping_next_power_of_two)]
-", $Feature, "
-assert_eq!(2", stringify!($SelfT), ".wrapping_next_power_of_two(), 2);
-assert_eq!(3", stringify!($SelfT), ".wrapping_next_power_of_two(), 4);
-assert_eq!(", stringify!($SelfT), "::MAX.wrapping_next_power_of_two(), 0);",
-$EndFeature, "
-```"),
-            #[unstable(feature = "wrapping_next_power_of_two", issue = "32463",
-                       reason = "needs decision on wrapping behaviour")]
-            #[rustc_const_stable(feature = "const_int_pow", since = "1.50.0")]
-            pub const fn wrapping_next_power_of_two(self) -> Self {
-                self.one_less_than_next_power_of_two().wrapping_add(1)
-            }
+        /// Returns the smallest power of two greater than or equal to `n`. If
+        /// the next power of two is greater than the type's maximum value,
+        /// `None` is returned, otherwise the power of two is wrapped in `Some`.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        #[doc = concat!("assert_eq!(2", stringify!($SelfT), ".checked_next_power_of_two(), Some(2));")]
+        #[doc = concat!("assert_eq!(3", stringify!($SelfT), ".checked_next_power_of_two(), Some(4));")]
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MAX.checked_next_power_of_two(), None);")]
+        /// ```
+        #[inline]
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_stable(feature = "const_int_pow", since = "1.50.0")]
+        pub const fn checked_next_power_of_two(self) -> Option<Self> {
+            self.one_less_than_next_power_of_two().checked_add(1)
         }
 
-        doc_comment! {
-            concat!("Return the memory representation of this integer as a byte array in
-big-endian (network) byte order.
-",
-$to_xe_bytes_doc,
-"
-# Examples
-
-```
-let bytes = ", $swap_op, stringify!($SelfT), ".to_be_bytes();
-assert_eq!(bytes, ", $be_bytes, ");
-```"),
-            #[stable(feature = "int_to_from_bytes", since = "1.32.0")]
-            #[rustc_const_stable(feature = "const_int_conversion", since = "1.44.0")]
-            #[inline]
-            pub const fn to_be_bytes(self) -> [u8; mem::size_of::<Self>()] {
-                self.to_be().to_ne_bytes()
-            }
+        /// Returns the smallest power of two greater than or equal to `n`. If
+        /// the next power of two is greater than the type's maximum value,
+        /// the return value is wrapped to `0`.
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        /// #![feature(wrapping_next_power_of_two)]
+        ///
+        #[doc = concat!("assert_eq!(2", stringify!($SelfT), ".wrapping_next_power_of_two(), 2);")]
+        #[doc = concat!("assert_eq!(3", stringify!($SelfT), ".wrapping_next_power_of_two(), 4);")]
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MAX.wrapping_next_power_of_two(), 0);")]
+        /// ```
+        #[unstable(feature = "wrapping_next_power_of_two", issue = "32463",
+                   reason = "needs decision on wrapping behaviour")]
+        #[rustc_const_stable(feature = "const_int_pow", since = "1.50.0")]
+        pub const fn wrapping_next_power_of_two(self) -> Self {
+            self.one_less_than_next_power_of_two().wrapping_add(1)
         }
 
-        doc_comment! {
-            concat!("Return the memory representation of this integer as a byte array in
-little-endian byte order.
-",
-$to_xe_bytes_doc,
-"
-# Examples
-
-```
-let bytes = ", $swap_op, stringify!($SelfT), ".to_le_bytes();
-assert_eq!(bytes, ", $le_bytes, ");
-```"),
-            #[stable(feature = "int_to_from_bytes", since = "1.32.0")]
-            #[rustc_const_stable(feature = "const_int_conversion", since = "1.44.0")]
-            #[inline]
-            pub const fn to_le_bytes(self) -> [u8; mem::size_of::<Self>()] {
-                self.to_le().to_ne_bytes()
-            }
+        /// Return the memory representation of this integer as a byte array in
+        /// big-endian (network) byte order.
+        ///
+        #[doc = $to_xe_bytes_doc]
+        ///
+        /// # Examples
+        ///
+        /// ```
+        #[doc = concat!("let bytes = ", $swap_op, stringify!($SelfT), ".to_be_bytes();")]
+        #[doc = concat!("assert_eq!(bytes, ", $be_bytes, ");")]
+        /// ```
+        #[stable(feature = "int_to_from_bytes", since = "1.32.0")]
+        #[rustc_const_stable(feature = "const_int_conversion", since = "1.44.0")]
+        #[inline]
+        pub const fn to_be_bytes(self) -> [u8; mem::size_of::<Self>()] {
+            self.to_be().to_ne_bytes()
         }
 
-        doc_comment! {
-            concat!("
-Return the memory representation of this integer as a byte array in
-native byte order.
-
-As the target platform's native endianness is used, portable code
-should use [`to_be_bytes`] or [`to_le_bytes`], as appropriate,
-instead.
-",
-$to_xe_bytes_doc,
-"
-[`to_be_bytes`]: #method.to_be_bytes
-[`to_le_bytes`]: #method.to_le_bytes
-
-# Examples
-
-```
-let bytes = ", $swap_op, stringify!($SelfT), ".to_ne_bytes();
-assert_eq!(
-    bytes,
-    if cfg!(target_endian = \"big\") {
-        ", $be_bytes, "
-    } else {
-        ", $le_bytes, "
-    }
-);
-```"),
-            #[stable(feature = "int_to_from_bytes", since = "1.32.0")]
-            #[rustc_const_stable(feature = "const_int_conversion", since = "1.44.0")]
-            // SAFETY: const sound because integers are plain old datatypes so we can always
-            // transmute them to arrays of bytes
-            #[rustc_allow_const_fn_unstable(const_fn_transmute)]
-            #[inline]
-            pub const fn to_ne_bytes(self) -> [u8; mem::size_of::<Self>()] {
-                // SAFETY: integers are plain old datatypes so we can always transmute them to
-                // arrays of bytes
-                unsafe { mem::transmute(self) }
-            }
+        /// Return the memory representation of this integer as a byte array in
+        /// little-endian byte order.
+        ///
+        #[doc = $to_xe_bytes_doc]
+        ///
+        /// # Examples
+        ///
+        /// ```
+        #[doc = concat!("let bytes = ", $swap_op, stringify!($SelfT), ".to_le_bytes();")]
+        #[doc = concat!("assert_eq!(bytes, ", $le_bytes, ");")]
+        /// ```
+        #[stable(feature = "int_to_from_bytes", since = "1.32.0")]
+        #[rustc_const_stable(feature = "const_int_conversion", since = "1.44.0")]
+        #[inline]
+        pub const fn to_le_bytes(self) -> [u8; mem::size_of::<Self>()] {
+            self.to_le().to_ne_bytes()
         }
 
-        doc_comment! {
-            concat!("
-Return the memory representation of this integer as a byte array in
-native byte order.
-
-[`to_ne_bytes`] should be preferred over this whenever possible.
-
-[`to_ne_bytes`]: #method.to_ne_bytes
-",
-
-"
-# Examples
-
-```
-#![feature(num_as_ne_bytes)]
-let num = ", $swap_op, stringify!($SelfT), ";
-let bytes = num.as_ne_bytes();
-assert_eq!(
-    bytes,
-    if cfg!(target_endian = \"big\") {
-        &", $be_bytes, "
-    } else {
-        &", $le_bytes, "
-    }
-);
-```"),
-            #[unstable(feature = "num_as_ne_bytes", issue = "76976")]
-            #[inline]
-            pub fn as_ne_bytes(&self) -> &[u8; mem::size_of::<Self>()] {
-                // SAFETY: integers are plain old datatypes so we can always transmute them to
-                // arrays of bytes
-                unsafe { &*(self as *const Self as *const _) }
-            }
+        /// Return the memory representation of this integer as a byte array in
+        /// native byte order.
+        ///
+        /// As the target platform's native endianness is used, portable code
+        /// should use [`to_be_bytes`] or [`to_le_bytes`], as appropriate,
+        /// instead.
+        ///
+        #[doc = $to_xe_bytes_doc]
+        ///
+        /// [`to_be_bytes`]: #method.to_be_bytes
+        /// [`to_le_bytes`]: #method.to_le_bytes
+        ///
+        /// # Examples
+        ///
+        /// ```
+        #[doc = concat!("let bytes = ", $swap_op, stringify!($SelfT), ".to_ne_bytes();")]
+        /// assert_eq!(
+        ///     bytes,
+        ///     if cfg!(target_endian = "big") {
+        #[doc = concat!("        ", $be_bytes)]
+        ///     } else {
+        #[doc = concat!("        ", $le_bytes)]
+        ///     }
+        /// );
+        /// ```
+        #[stable(feature = "int_to_from_bytes", since = "1.32.0")]
+        #[rustc_const_stable(feature = "const_int_conversion", since = "1.44.0")]
+        // SAFETY: const sound because integers are plain old datatypes so we can always
+        // transmute them to arrays of bytes
+        #[rustc_allow_const_fn_unstable(const_fn_transmute)]
+        #[inline]
+        pub const fn to_ne_bytes(self) -> [u8; mem::size_of::<Self>()] {
+            // SAFETY: integers are plain old datatypes so we can always transmute them to
+            // arrays of bytes
+            unsafe { mem::transmute(self) }
         }
 
-        doc_comment! {
-            concat!("Create a native endian integer value from its representation
-as a byte array in big endian.
-",
-$from_xe_bytes_doc,
-"
-# Examples
-
-```
-let value = ", stringify!($SelfT), "::from_be_bytes(", $be_bytes, ");
-assert_eq!(value, ", $swap_op, ");
-```
-
-When starting from a slice rather than an array, fallible conversion APIs can be used:
-
-```
-use std::convert::TryInto;
-
-fn read_be_", stringify!($SelfT), "(input: &mut &[u8]) -> ", stringify!($SelfT), " {
-    let (int_bytes, rest) = input.split_at(std::mem::size_of::<", stringify!($SelfT), ">());
-    *input = rest;
-    ", stringify!($SelfT), "::from_be_bytes(int_bytes.try_into().unwrap())
-}
-```"),
-            #[stable(feature = "int_to_from_bytes", since = "1.32.0")]
-            #[rustc_const_stable(feature = "const_int_conversion", since = "1.44.0")]
-            #[inline]
-            pub const fn from_be_bytes(bytes: [u8; mem::size_of::<Self>()]) -> Self {
-                Self::from_be(Self::from_ne_bytes(bytes))
-            }
+        /// Return the memory representation of this integer as a byte array in
+        /// native byte order.
+        ///
+        /// [`to_ne_bytes`] should be preferred over this whenever possible.
+        ///
+        /// [`to_ne_bytes`]: #method.to_ne_bytes
+        ///
+        /// # Examples
+        ///
+        /// ```
+        /// #![feature(num_as_ne_bytes)]
+        #[doc = concat!("let num = ", $swap_op, stringify!($SelfT), ";")]
+        /// let bytes = num.as_ne_bytes();
+        /// assert_eq!(
+        ///     bytes,
+        ///     if cfg!(target_endian = "big") {
+        #[doc = concat!("        &", $be_bytes)]
+        ///     } else {
+        #[doc = concat!("        &", $le_bytes)]
+        ///     }
+        /// );
+        /// ```
+        #[unstable(feature = "num_as_ne_bytes", issue = "76976")]
+        #[inline]
+        pub fn as_ne_bytes(&self) -> &[u8; mem::size_of::<Self>()] {
+            // SAFETY: integers are plain old datatypes so we can always transmute them to
+            // arrays of bytes
+            unsafe { &*(self as *const Self as *const _) }
         }
 
-        doc_comment! {
-            concat!("
-Create a native endian integer value from its representation
-as a byte array in little endian.
-",
-$from_xe_bytes_doc,
-"
-# Examples
-
-```
-let value = ", stringify!($SelfT), "::from_le_bytes(", $le_bytes, ");
-assert_eq!(value, ", $swap_op, ");
-```
-
-When starting from a slice rather than an array, fallible conversion APIs can be used:
-
-```
-use std::convert::TryInto;
-
-fn read_le_", stringify!($SelfT), "(input: &mut &[u8]) -> ", stringify!($SelfT), " {
-    let (int_bytes, rest) = input.split_at(std::mem::size_of::<", stringify!($SelfT), ">());
-    *input = rest;
-    ", stringify!($SelfT), "::from_le_bytes(int_bytes.try_into().unwrap())
-}
-```"),
-            #[stable(feature = "int_to_from_bytes", since = "1.32.0")]
-            #[rustc_const_stable(feature = "const_int_conversion", since = "1.44.0")]
-            #[inline]
-            pub const fn from_le_bytes(bytes: [u8; mem::size_of::<Self>()]) -> Self {
-                Self::from_le(Self::from_ne_bytes(bytes))
-            }
+        /// Create a native endian integer value from its representation
+        /// as a byte array in big endian.
+        ///
+        #[doc = $from_xe_bytes_doc]
+        ///
+        /// # Examples
+        ///
+        /// ```
+        #[doc = concat!("let value = ", stringify!($SelfT), "::from_be_bytes(", $be_bytes, ");")]
+        #[doc = concat!("assert_eq!(value, ", $swap_op, ");")]
+        /// ```
+        ///
+        /// When starting from a slice rather than an array, fallible conversion APIs can be used:
+        ///
+        /// ```
+        /// use std::convert::TryInto;
+        ///
+        #[doc = concat!("fn read_be_", stringify!($SelfT), "(input: &mut &[u8]) -> ", stringify!($SelfT), " {")]
+        #[doc = concat!("    let (int_bytes, rest) = input.split_at(std::mem::size_of::<", stringify!($SelfT), ">());")]
+        ///     *input = rest;
+        #[doc = concat!("    ", stringify!($SelfT), "::from_be_bytes(int_bytes.try_into().unwrap())")]
+        /// }
+        /// ```
+        #[stable(feature = "int_to_from_bytes", since = "1.32.0")]
+        #[rustc_const_stable(feature = "const_int_conversion", since = "1.44.0")]
+        #[inline]
+        pub const fn from_be_bytes(bytes: [u8; mem::size_of::<Self>()]) -> Self {
+            Self::from_be(Self::from_ne_bytes(bytes))
         }
 
-        doc_comment! {
-            concat!("Create a native endian integer value from its memory representation
-as a byte array in native endianness.
-
-As the target platform's native endianness is used, portable code
-likely wants to use [`from_be_bytes`] or [`from_le_bytes`], as
-appropriate instead.
-
-[`from_be_bytes`]: #method.from_be_bytes
-[`from_le_bytes`]: #method.from_le_bytes
-",
-$from_xe_bytes_doc,
-"
-# Examples
-
-```
-let value = ", stringify!($SelfT), "::from_ne_bytes(if cfg!(target_endian = \"big\") {
-    ", $be_bytes, "
-} else {
-    ", $le_bytes, "
-});
-assert_eq!(value, ", $swap_op, ");
-```
-
-When starting from a slice rather than an array, fallible conversion APIs can be used:
-
-```
-use std::convert::TryInto;
-
-fn read_ne_", stringify!($SelfT), "(input: &mut &[u8]) -> ", stringify!($SelfT), " {
-    let (int_bytes, rest) = input.split_at(std::mem::size_of::<", stringify!($SelfT), ">());
-    *input = rest;
-    ", stringify!($SelfT), "::from_ne_bytes(int_bytes.try_into().unwrap())
-}
-```"),
-            #[stable(feature = "int_to_from_bytes", since = "1.32.0")]
-            #[rustc_const_stable(feature = "const_int_conversion", since = "1.44.0")]
-            // SAFETY: const sound because integers are plain old datatypes so we can always
-            // transmute to them
-            #[rustc_allow_const_fn_unstable(const_fn_transmute)]
-            #[inline]
-            pub const fn from_ne_bytes(bytes: [u8; mem::size_of::<Self>()]) -> Self {
-                // SAFETY: integers are plain old datatypes so we can always transmute to them
-                unsafe { mem::transmute(bytes) }
-            }
+        /// Create a native endian integer value from its representation
+        /// as a byte array in little endian.
+        ///
+        #[doc = $from_xe_bytes_doc]
+        ///
+        /// # Examples
+        ///
+        /// ```
+        #[doc = concat!("let value = ", stringify!($SelfT), "::from_le_bytes(", $le_bytes, ");")]
+        #[doc = concat!("assert_eq!(value, ", $swap_op, ");")]
+        /// ```
+        ///
+        /// When starting from a slice rather than an array, fallible conversion APIs can be used:
+        ///
+        /// ```
+        /// use std::convert::TryInto;
+        ///
+        #[doc = concat!("fn read_le_", stringify!($SelfT), "(input: &mut &[u8]) -> ", stringify!($SelfT), " {")]
+        #[doc = concat!("    let (int_bytes, rest) = input.split_at(std::mem::size_of::<", stringify!($SelfT), ">());")]
+        ///     *input = rest;
+        #[doc = concat!("    ", stringify!($SelfT), "::from_le_bytes(int_bytes.try_into().unwrap())")]
+        /// }
+        /// ```
+        #[stable(feature = "int_to_from_bytes", since = "1.32.0")]
+        #[rustc_const_stable(feature = "const_int_conversion", since = "1.44.0")]
+        #[inline]
+        pub const fn from_le_bytes(bytes: [u8; mem::size_of::<Self>()]) -> Self {
+            Self::from_le(Self::from_ne_bytes(bytes))
         }
 
-        doc_comment! {
-            concat!("**This method is soft-deprecated.**
-
-Although using it won’t cause compilation warning,
-new code should use [`", stringify!($SelfT), "::MIN", "`](#associatedconstant.MIN) instead.
-
-Returns the smallest value that can be represented by this integer type."),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_promotable]
-            #[inline(always)]
-            #[rustc_const_stable(feature = "const_max_value", since = "1.32.0")]
-            pub const fn min_value() -> Self { Self::MIN }
+        /// Create a native endian integer value from its memory representation
+        /// as a byte array in native endianness.
+        ///
+        /// As the target platform's native endianness is used, portable code
+        /// likely wants to use [`from_be_bytes`] or [`from_le_bytes`], as
+        /// appropriate instead.
+        ///
+        /// [`from_be_bytes`]: #method.from_be_bytes
+        /// [`from_le_bytes`]: #method.from_le_bytes
+        ///
+        #[doc = $from_xe_bytes_doc]
+        ///
+        /// # Examples
+        ///
+        /// ```
+        #[doc = concat!("let value = ", stringify!($SelfT), "::from_ne_bytes(if cfg!(target_endian = \"big\") {")]
+        #[doc = concat!("    ", $be_bytes, "")]
+        /// } else {
+        #[doc = concat!("    ", $le_bytes, "")]
+        /// });
+        #[doc = concat!("assert_eq!(value, ", $swap_op, ");")]
+        /// ```
+        ///
+        /// When starting from a slice rather than an array, fallible conversion APIs can be used:
+        ///
+        /// ```
+        /// use std::convert::TryInto;
+        ///
+        #[doc = concat!("fn read_ne_", stringify!($SelfT), "(input: &mut &[u8]) -> ", stringify!($SelfT), " {")]
+        #[doc = concat!("    let (int_bytes, rest) = input.split_at(std::mem::size_of::<", stringify!($SelfT), ">());")]
+        ///     *input = rest;
+        #[doc = concat!("    ", stringify!($SelfT), "::from_ne_bytes(int_bytes.try_into().unwrap())")]
+        /// }
+        /// ```
+        #[stable(feature = "int_to_from_bytes", since = "1.32.0")]
+        #[rustc_const_stable(feature = "const_int_conversion", since = "1.44.0")]
+        // SAFETY: const sound because integers are plain old datatypes so we can always
+        // transmute to them
+        #[rustc_allow_const_fn_unstable(const_fn_transmute)]
+        #[inline]
+        pub const fn from_ne_bytes(bytes: [u8; mem::size_of::<Self>()]) -> Self {
+            // SAFETY: integers are plain old datatypes so we can always transmute to them
+            unsafe { mem::transmute(bytes) }
         }
 
-        doc_comment! {
-            concat!("**This method is soft-deprecated.**
-
-Although using it won’t cause compilation warning,
-new code should use [`", stringify!($SelfT), "::MAX", "`](#associatedconstant.MAX) instead.
+        /// **This method is soft-deprecated.**
+        ///
+        /// Although using it won’t cause compilation warning, new code should use
+        #[doc = concat!("[`", stringify!($SelfT), "::MIN", "`](#associatedconstant.MIN)")]
+        /// instead.
+        ///
+        /// Returns the smallest value that can be represented by this integer type.
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_promotable]
+        #[inline(always)]
+        #[rustc_const_stable(feature = "const_max_value", since = "1.32.0")]
+        pub const fn min_value() -> Self { Self::MIN }
 
-Returns the largest value that can be represented by this integer type."),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_promotable]
-            #[inline(always)]
-            #[rustc_const_stable(feature = "const_max_value", since = "1.32.0")]
-            pub const fn max_value() -> Self { Self::MAX }
-        }
+        /// **This method is soft-deprecated.**
+        ///
+        /// Although using it won’t cause compilation warning, new code should use
+        #[doc = concat!("[`", stringify!($SelfT), "::MAX", "`](#associatedconstant.MAX)")]
+        /// instead.
+        ///
+        /// Returns the largest value that can be represented by this integer type.
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_promotable]
+        #[inline(always)]
+        #[rustc_const_stable(feature = "const_max_value", since = "1.32.0")]
+        pub const fn max_value() -> Self { Self::MAX }
     }
 }
diff --git a/library/core/src/num/wrapping.rs b/library/core/src/num/wrapping.rs
index 77c9a93008c..f1b9dabe7d6 100644
--- a/library/core/src/num/wrapping.rs
+++ b/library/core/src/num/wrapping.rs
@@ -403,105 +403,94 @@ wrapping_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 }
 macro_rules! wrapping_int_impl {
     ($($t:ty)*) => ($(
         impl Wrapping<$t> {
-            doc_comment! {
-                concat!("Returns the smallest value that can be represented by this integer type.
-
-# Examples
-
-Basic usage:
-
-```
-#![feature(wrapping_int_impl)]
-use std::num::Wrapping;
-
-assert_eq!(<Wrapping<", stringify!($t), ">>::MIN, Wrapping(", stringify!($t), "::MIN));
-```"),
-                #[unstable(feature = "wrapping_int_impl", issue = "32463")]
-                pub const MIN: Self = Self(<$t>::MIN);
-            }
-
-            doc_comment! {
-                concat!("Returns the largest value that can be represented by this integer type.
-
-# Examples
-
-Basic usage:
-
-```
-#![feature(wrapping_int_impl)]
-use std::num::Wrapping;
-
-assert_eq!(<Wrapping<", stringify!($t), ">>::MAX, Wrapping(", stringify!($t), "::MAX));
-```"),
-                #[unstable(feature = "wrapping_int_impl", issue = "32463")]
-                pub const MAX: Self = Self(<$t>::MAX);
-            }
-
-            doc_comment! {
-                concat!("Returns the number of ones in the binary representation of `self`.
-
-# Examples
-
-Basic usage:
-
-```
-#![feature(wrapping_int_impl)]
-use std::num::Wrapping;
+            /// Returns the smallest value that can be represented by this integer type.
+            ///
+            /// # Examples
+            ///
+            /// Basic usage:
+            ///
+            /// ```
+            /// #![feature(wrapping_int_impl)]
+            /// use std::num::Wrapping;
+            ///
+            #[doc = concat!("assert_eq!(<Wrapping<", stringify!($t), ">>::MIN, Wrapping(", stringify!($t), "::MIN));")]
+            /// ```
+            #[unstable(feature = "wrapping_int_impl", issue = "32463")]
+            pub const MIN: Self = Self(<$t>::MIN);
 
-let n = Wrapping(0b01001100", stringify!($t), ");
+            /// Returns the largest value that can be represented by this integer type.
+            ///
+            /// # Examples
+            ///
+            /// Basic usage:
+            ///
+            /// ```
+            /// #![feature(wrapping_int_impl)]
+            /// use std::num::Wrapping;
+            ///
+            #[doc = concat!("assert_eq!(<Wrapping<", stringify!($t), ">>::MAX, Wrapping(", stringify!($t), "::MAX));")]
+            /// ```
+            #[unstable(feature = "wrapping_int_impl", issue = "32463")]
+            pub const MAX: Self = Self(<$t>::MAX);
 
-assert_eq!(n.count_ones(), 3);
-```"),
-                #[inline]
-                #[doc(alias = "popcount")]
-                #[doc(alias = "popcnt")]
-                #[unstable(feature = "wrapping_int_impl", issue = "32463")]
-                pub const fn count_ones(self) -> u32 {
-                    self.0.count_ones()
-                }
+            /// Returns the number of ones in the binary representation of `self`.
+            ///
+            /// # Examples
+            ///
+            /// Basic usage:
+            ///
+            /// ```
+            /// #![feature(wrapping_int_impl)]
+            /// use std::num::Wrapping;
+            ///
+            #[doc = concat!("let n = Wrapping(0b01001100", stringify!($t), ");")]
+            ///
+            /// assert_eq!(n.count_ones(), 3);
+            /// ```
+            #[inline]
+            #[doc(alias = "popcount")]
+            #[doc(alias = "popcnt")]
+            #[unstable(feature = "wrapping_int_impl", issue = "32463")]
+            pub const fn count_ones(self) -> u32 {
+                self.0.count_ones()
             }
 
-            doc_comment! {
-                concat!("Returns the number of zeros in the binary representation of `self`.
-
-# Examples
-
-Basic usage:
-
-```
-#![feature(wrapping_int_impl)]
-use std::num::Wrapping;
-
-assert_eq!(Wrapping(!0", stringify!($t), ").count_zeros(), 0);
-```"),
-                #[inline]
-                #[unstable(feature = "wrapping_int_impl", issue = "32463")]
-                pub const fn count_zeros(self) -> u32 {
-                    self.0.count_zeros()
-                }
+            /// Returns the number of zeros in the binary representation of `self`.
+            ///
+            /// # Examples
+            ///
+            /// Basic usage:
+            ///
+            /// ```
+            /// #![feature(wrapping_int_impl)]
+            /// use std::num::Wrapping;
+            ///
+            #[doc = concat!("assert_eq!(Wrapping(!0", stringify!($t), ").count_zeros(), 0);")]
+            /// ```
+            #[inline]
+            #[unstable(feature = "wrapping_int_impl", issue = "32463")]
+            pub const fn count_zeros(self) -> u32 {
+                self.0.count_zeros()
             }
 
-            doc_comment! {
-                concat!("Returns the number of trailing zeros in the binary representation
-of `self`.
-
-# Examples
-
-Basic usage:
-
-```
-#![feature(wrapping_int_impl)]
-use std::num::Wrapping;
-
-let n = Wrapping(0b0101000", stringify!($t), ");
-
-assert_eq!(n.trailing_zeros(), 3);
-```"),
-                #[inline]
-                #[unstable(feature = "wrapping_int_impl", issue = "32463")]
-                pub const fn trailing_zeros(self) -> u32 {
-                    self.0.trailing_zeros()
-                }
+            /// Returns the number of trailing zeros in the binary representation of `self`.
+            ///
+            /// # Examples
+            ///
+            /// Basic usage:
+            ///
+            /// ```
+            /// #![feature(wrapping_int_impl)]
+            /// use std::num::Wrapping;
+            ///
+            #[doc = concat!("let n = Wrapping(0b0101000", stringify!($t), ");")]
+            ///
+            /// assert_eq!(n.trailing_zeros(), 3);
+            /// ```
+            #[inline]
+            #[unstable(feature = "wrapping_int_impl", issue = "32463")]
+            pub const fn trailing_zeros(self) -> u32 {
+                self.0.trailing_zeros()
             }
 
             /// Shifts the bits to the left by a specified amount, `n`,
@@ -608,150 +597,140 @@ assert_eq!(n.trailing_zeros(), 3);
                 Wrapping(self.0.reverse_bits())
             }
 
-            doc_comment! {
-                concat!("Converts an integer from big endian to the target's endianness.
-
-On big endian this is a no-op. On little endian the bytes are
-swapped.
-
-# Examples
-
-Basic usage:
-
-```
-#![feature(wrapping_int_impl)]
-use std::num::Wrapping;
-
-let n = Wrapping(0x1A", stringify!($t), ");
-
-if cfg!(target_endian = \"big\") {
-    assert_eq!(<Wrapping<", stringify!($t), ">>::from_be(n), n)
-} else {
-    assert_eq!(<Wrapping<", stringify!($t), ">>::from_be(n), n.swap_bytes())
-}
-```"),
-                #[inline]
-                #[unstable(feature = "wrapping_int_impl", issue = "32463")]
-                pub const fn from_be(x: Self) -> Self {
-                    Wrapping(<$t>::from_be(x.0))
-                }
+            /// Converts an integer from big endian to the target's endianness.
+            ///
+            /// On big endian this is a no-op. On little endian the bytes are
+            /// swapped.
+            ///
+            /// # Examples
+            ///
+            /// Basic usage:
+            ///
+            /// ```
+            /// #![feature(wrapping_int_impl)]
+            /// use std::num::Wrapping;
+            ///
+            #[doc = concat!("let n = Wrapping(0x1A", stringify!($t), ");")]
+            ///
+            /// if cfg!(target_endian = "big") {
+            #[doc = concat!("    assert_eq!(<Wrapping<", stringify!($t), ">>::from_be(n), n)")]
+            /// } else {
+            #[doc = concat!("    assert_eq!(<Wrapping<", stringify!($t), ">>::from_be(n), n.swap_bytes())")]
+            /// }
+            /// ```
+            #[inline]
+            #[unstable(feature = "wrapping_int_impl", issue = "32463")]
+            pub const fn from_be(x: Self) -> Self {
+                Wrapping(<$t>::from_be(x.0))
             }
 
-            doc_comment! {
-                concat!("Converts an integer from little endian to the target's endianness.
-
-On little endian this is a no-op. On big endian the bytes are
-swapped.
-
-# Examples
-
-Basic usage:
-
-```
-#![feature(wrapping_int_impl)]
-use std::num::Wrapping;
-
-let n = Wrapping(0x1A", stringify!($t), ");
-
-if cfg!(target_endian = \"little\") {
-    assert_eq!(<Wrapping<", stringify!($t), ">>::from_le(n), n)
-} else {
-    assert_eq!(<Wrapping<", stringify!($t), ">>::from_le(n), n.swap_bytes())
-}
-```"),
-                #[inline]
-                #[unstable(feature = "wrapping_int_impl", issue = "32463")]
-                pub const fn from_le(x: Self) -> Self {
-                    Wrapping(<$t>::from_le(x.0))
-                }
+            /// Converts an integer from little endian to the target's endianness.
+            ///
+            /// On little endian this is a no-op. On big endian the bytes are
+            /// swapped.
+            ///
+            /// # Examples
+            ///
+            /// Basic usage:
+            ///
+            /// ```
+            /// #![feature(wrapping_int_impl)]
+            /// use std::num::Wrapping;
+            ///
+            #[doc = concat!("let n = Wrapping(0x1A", stringify!($t), ");")]
+            ///
+            /// if cfg!(target_endian = "little") {
+            #[doc = concat!("    assert_eq!(<Wrapping<", stringify!($t), ">>::from_le(n), n)")]
+            /// } else {
+            #[doc = concat!("    assert_eq!(<Wrapping<", stringify!($t), ">>::from_le(n), n.swap_bytes())")]
+            /// }
+            /// ```
+            #[inline]
+            #[unstable(feature = "wrapping_int_impl", issue = "32463")]
+            pub const fn from_le(x: Self) -> Self {
+                Wrapping(<$t>::from_le(x.0))
             }
 
-            doc_comment! {
-                concat!("Converts `self` to big endian from the target's endianness.
-
-On big endian this is a no-op. On little endian the bytes are
-swapped.
-
-# Examples
-
-Basic usage:
-
-```
-#![feature(wrapping_int_impl)]
-use std::num::Wrapping;
-
-let n = Wrapping(0x1A", stringify!($t), ");
-
-if cfg!(target_endian = \"big\") {
-    assert_eq!(n.to_be(), n)
-} else {
-    assert_eq!(n.to_be(), n.swap_bytes())
-}
-```"),
-                #[inline]
-                #[unstable(feature = "wrapping_int_impl", issue = "32463")]
-                pub const fn to_be(self) -> Self {
-                    Wrapping(self.0.to_be())
-                }
+            /// Converts `self` to big endian from the target's endianness.
+            ///
+            /// On big endian this is a no-op. On little endian the bytes are
+            /// swapped.
+            ///
+            /// # Examples
+            ///
+            /// Basic usage:
+            ///
+            /// ```
+            /// #![feature(wrapping_int_impl)]
+            /// use std::num::Wrapping;
+            ///
+            #[doc = concat!("let n = Wrapping(0x1A", stringify!($t), ");")]
+            ///
+            /// if cfg!(target_endian = "big") {
+            ///     assert_eq!(n.to_be(), n)
+            /// } else {
+            ///     assert_eq!(n.to_be(), n.swap_bytes())
+            /// }
+            /// ```
+            #[inline]
+            #[unstable(feature = "wrapping_int_impl", issue = "32463")]
+            pub const fn to_be(self) -> Self {
+                Wrapping(self.0.to_be())
             }
 
-            doc_comment! {
-                concat!("Converts `self` to little endian from the target's endianness.
-
-On little endian this is a no-op. On big endian the bytes are
-swapped.
-
-# Examples
-
-Basic usage:
-
-```
-#![feature(wrapping_int_impl)]
-use std::num::Wrapping;
-
-let n = Wrapping(0x1A", stringify!($t), ");
-
-if cfg!(target_endian = \"little\") {
-    assert_eq!(n.to_le(), n)
-} else {
-    assert_eq!(n.to_le(), n.swap_bytes())
-}
-```"),
-                #[inline]
-                #[unstable(feature = "wrapping_int_impl", issue = "32463")]
-                pub const fn to_le(self) -> Self {
-                    Wrapping(self.0.to_le())
-                }
+            /// Converts `self` to little endian from the target's endianness.
+            ///
+            /// On little endian this is a no-op. On big endian the bytes are
+            /// swapped.
+            ///
+            /// # Examples
+            ///
+            /// Basic usage:
+            ///
+            /// ```
+            /// #![feature(wrapping_int_impl)]
+            /// use std::num::Wrapping;
+            ///
+            #[doc = concat!("let n = Wrapping(0x1A", stringify!($t), ");")]
+            ///
+            /// if cfg!(target_endian = "little") {
+            ///     assert_eq!(n.to_le(), n)
+            /// } else {
+            ///     assert_eq!(n.to_le(), n.swap_bytes())
+            /// }
+            /// ```
+            #[inline]
+            #[unstable(feature = "wrapping_int_impl", issue = "32463")]
+            pub const fn to_le(self) -> Self {
+                Wrapping(self.0.to_le())
             }
 
-        doc_comment! {
-            concat!("Raises self to the power of `exp`, using exponentiation by squaring.
-
-# Examples
-
-Basic usage:
-
-```
-#![feature(wrapping_int_impl)]
-use std::num::Wrapping;
-
-assert_eq!(Wrapping(3", stringify!($t), ").pow(4), Wrapping(81));
-```
-
-Results that are too large are wrapped:
-
-```
-#![feature(wrapping_int_impl)]
-use std::num::Wrapping;
-
-assert_eq!(Wrapping(3i8).pow(5), Wrapping(-13));
-assert_eq!(Wrapping(3i8).pow(6), Wrapping(-39));
-```"),
-                #[inline]
-                #[unstable(feature = "wrapping_int_impl", issue = "32463")]
-                pub fn pow(self, exp: u32) -> Self {
-                    Wrapping(self.0.wrapping_pow(exp))
-                }
+            /// Raises self to the power of `exp`, using exponentiation by squaring.
+            ///
+            /// # Examples
+            ///
+            /// Basic usage:
+            ///
+            /// ```
+            /// #![feature(wrapping_int_impl)]
+            /// use std::num::Wrapping;
+            ///
+            #[doc = concat!("assert_eq!(Wrapping(3", stringify!($t), ").pow(4), Wrapping(81));")]
+            /// ```
+            ///
+            /// Results that are too large are wrapped:
+            ///
+            /// ```
+            /// #![feature(wrapping_int_impl)]
+            /// use std::num::Wrapping;
+            ///
+            /// assert_eq!(Wrapping(3i8).pow(5), Wrapping(-13));
+            /// assert_eq!(Wrapping(3i8).pow(6), Wrapping(-39));
+            /// ```
+            #[inline]
+            #[unstable(feature = "wrapping_int_impl", issue = "32463")]
+            pub fn pow(self, exp: u32) -> Self {
+                Wrapping(self.0.wrapping_pow(exp))
             }
         }
     )*)
@@ -762,124 +741,114 @@ wrapping_int_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 }
 macro_rules! wrapping_int_impl_signed {
     ($($t:ty)*) => ($(
         impl Wrapping<$t> {
-            doc_comment! {
-                concat!("Returns the number of leading zeros in the binary representation of `self`.
-
-# Examples
-
-Basic usage:
-
-```
-#![feature(wrapping_int_impl)]
-use std::num::Wrapping;
-
-let n = Wrapping(", stringify!($t), "::MAX) >> 2;
-
-assert_eq!(n.leading_zeros(), 3);
-```"),
-                #[inline]
-                #[unstable(feature = "wrapping_int_impl", issue = "32463")]
-                pub const fn leading_zeros(self) -> u32 {
-                    self.0.leading_zeros()
-                }
+            /// Returns the number of leading zeros in the binary representation of `self`.
+            ///
+            /// # Examples
+            ///
+            /// Basic usage:
+            ///
+            /// ```
+            /// #![feature(wrapping_int_impl)]
+            /// use std::num::Wrapping;
+            ///
+            #[doc = concat!("let n = Wrapping(", stringify!($t), "::MAX) >> 2;")]
+            ///
+            /// assert_eq!(n.leading_zeros(), 3);
+            /// ```
+            #[inline]
+            #[unstable(feature = "wrapping_int_impl", issue = "32463")]
+            pub const fn leading_zeros(self) -> u32 {
+                self.0.leading_zeros()
             }
 
-            doc_comment! {
-                concat!("Computes the absolute value of `self`, wrapping around at
-the boundary of the type.
-
-The only case where such wrapping can occur is when one takes the absolute value of the negative
-minimal value for the type this is a positive value that is too large to represent in the type. In
-such a case, this function returns `MIN` itself.
-
-# Examples
-
-Basic usage:
-
-```
-#![feature(wrapping_int_impl)]
-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).abs(), Wrapping(", stringify!($t), "::MIN));
-assert_eq!(Wrapping(-128i8).abs().0 as u8, 128u8);
-```"),
-                #[inline]
-                #[unstable(feature = "wrapping_int_impl", issue = "32463")]
-                pub fn abs(self) -> Wrapping<$t> {
-                    Wrapping(self.0.wrapping_abs())
-                }
+            /// Computes the absolute value of `self`, wrapping around at
+            /// the boundary of the type.
+            ///
+            /// The only case where such wrapping can occur is when one takes the absolute value of the negative
+            /// minimal value for the type this is a positive value that is too large to represent in the type. In
+            /// such a case, this function returns `MIN` itself.
+            ///
+            /// # Examples
+            ///
+            /// Basic usage:
+            ///
+            /// ```
+            /// #![feature(wrapping_int_impl)]
+            /// use std::num::Wrapping;
+            ///
+            #[doc = concat!("assert_eq!(Wrapping(100", stringify!($t), ").abs(), Wrapping(100));")]
+            #[doc = concat!("assert_eq!(Wrapping(-100", stringify!($t), ").abs(), Wrapping(100));")]
+            #[doc = concat!("assert_eq!(Wrapping(", stringify!($t), "::MIN).abs(), Wrapping(", stringify!($t), "::MIN));")]
+            /// assert_eq!(Wrapping(-128i8).abs().0 as u8, 128u8);
+            /// ```
+            #[inline]
+            #[unstable(feature = "wrapping_int_impl", issue = "32463")]
+            pub fn abs(self) -> Wrapping<$t> {
+                Wrapping(self.0.wrapping_abs())
             }
 
-            doc_comment! {
-                concat!("Returns a number representing sign of `self`.
-
- - `0` if the number is zero
- - `1` if the number is positive
- - `-1` if the number is negative
-
-# Examples
-
-Basic usage:
-
-```
-#![feature(wrapping_int_impl)]
-use std::num::Wrapping;
-
-assert_eq!(Wrapping(10", stringify!($t), ").signum(), Wrapping(1));
-assert_eq!(Wrapping(0", stringify!($t), ").signum(), Wrapping(0));
-assert_eq!(Wrapping(-10", stringify!($t), ").signum(), Wrapping(-1));
-```"),
-                #[inline]
-                #[unstable(feature = "wrapping_int_impl", issue = "32463")]
-                pub fn signum(self) -> Wrapping<$t> {
-                    Wrapping(self.0.signum())
-                }
+            /// Returns a number representing sign of `self`.
+            ///
+            ///  - `0` if the number is zero
+            ///  - `1` if the number is positive
+            ///  - `-1` if the number is negative
+            ///
+            /// # Examples
+            ///
+            /// Basic usage:
+            ///
+            /// ```
+            /// #![feature(wrapping_int_impl)]
+            /// use std::num::Wrapping;
+            ///
+            #[doc = concat!("assert_eq!(Wrapping(10", stringify!($t), ").signum(), Wrapping(1));")]
+            #[doc = concat!("assert_eq!(Wrapping(0", stringify!($t), ").signum(), Wrapping(0));")]
+            #[doc = concat!("assert_eq!(Wrapping(-10", stringify!($t), ").signum(), Wrapping(-1));")]
+            /// ```
+            #[inline]
+            #[unstable(feature = "wrapping_int_impl", issue = "32463")]
+            pub fn signum(self) -> Wrapping<$t> {
+                Wrapping(self.0.signum())
             }
 
-            doc_comment! {
-                concat!("Returns `true` if `self` is positive and `false` if the number is zero or
-negative.
-
-# Examples
-
-Basic usage:
-
-```
-#![feature(wrapping_int_impl)]
-use std::num::Wrapping;
-
-assert!(Wrapping(10", stringify!($t), ").is_positive());
-assert!(!Wrapping(-10", stringify!($t), ").is_positive());
-```"),
-                #[inline]
-                #[unstable(feature = "wrapping_int_impl", issue = "32463")]
-                pub const fn is_positive(self) -> bool {
-                    self.0.is_positive()
-                }
+            /// Returns `true` if `self` is positive and `false` if the number is zero or
+            /// negative.
+            ///
+            /// # Examples
+            ///
+            /// Basic usage:
+            ///
+            /// ```
+            /// #![feature(wrapping_int_impl)]
+            /// use std::num::Wrapping;
+            ///
+            #[doc = concat!("assert!(Wrapping(10", stringify!($t), ").is_positive());")]
+            #[doc = concat!("assert!(!Wrapping(-10", stringify!($t), ").is_positive());")]
+            /// ```
+            #[inline]
+            #[unstable(feature = "wrapping_int_impl", issue = "32463")]
+            pub const fn is_positive(self) -> bool {
+                self.0.is_positive()
             }
 
-            doc_comment! {
-                concat!("Returns `true` if `self` is negative and `false` if the number is zero or
-positive.
-
-# Examples
-
-Basic usage:
-
-```
-#![feature(wrapping_int_impl)]
-use std::num::Wrapping;
-
-assert!(Wrapping(-10", stringify!($t), ").is_negative());
-assert!(!Wrapping(10", stringify!($t), ").is_negative());
-```"),
-                #[inline]
-                #[unstable(feature = "wrapping_int_impl", issue = "32463")]
-                pub const fn is_negative(self) -> bool {
-                    self.0.is_negative()
-                }
+            /// Returns `true` if `self` is negative and `false` if the number is zero or
+            /// positive.
+            ///
+            /// # Examples
+            ///
+            /// Basic usage:
+            ///
+            /// ```
+            /// #![feature(wrapping_int_impl)]
+            /// use std::num::Wrapping;
+            ///
+            #[doc = concat!("assert!(Wrapping(-10", stringify!($t), ").is_negative());")]
+            #[doc = concat!("assert!(!Wrapping(10", stringify!($t), ").is_negative());")]
+            /// ```
+            #[inline]
+            #[unstable(feature = "wrapping_int_impl", issue = "32463")]
+            pub const fn is_negative(self) -> bool {
+                self.0.is_negative()
             }
         }
     )*)
@@ -890,73 +859,67 @@ wrapping_int_impl_signed! { isize i8 i16 i32 i64 i128 }
 macro_rules! wrapping_int_impl_unsigned {
     ($($t:ty)*) => ($(
         impl Wrapping<$t> {
-            doc_comment! {
-                concat!("Returns the number of leading zeros in the binary representation of `self`.
-
-# Examples
-
-Basic usage:
-
-```
-#![feature(wrapping_int_impl)]
-use std::num::Wrapping;
-
-let n = Wrapping(", stringify!($t), "::MAX) >> 2;
-
-assert_eq!(n.leading_zeros(), 2);
-```"),
-                #[inline]
-                #[unstable(feature = "wrapping_int_impl", issue = "32463")]
-                pub const fn leading_zeros(self) -> u32 {
-                    self.0.leading_zeros()
-                }
+            /// Returns the number of leading zeros in the binary representation of `self`.
+            ///
+            /// # Examples
+            ///
+            /// Basic usage:
+            ///
+            /// ```
+            /// #![feature(wrapping_int_impl)]
+            /// use std::num::Wrapping;
+            ///
+            #[doc = concat!("let n = Wrapping(", stringify!($t), "::MAX) >> 2;")]
+            ///
+            /// assert_eq!(n.leading_zeros(), 2);
+            /// ```
+            #[inline]
+            #[unstable(feature = "wrapping_int_impl", issue = "32463")]
+            pub const fn leading_zeros(self) -> u32 {
+                self.0.leading_zeros()
             }
 
-            doc_comment! {
-                concat!("Returns `true` if and only if `self == 2^k` for some `k`.
-
-# Examples
-
-Basic usage:
-
-```
-#![feature(wrapping_int_impl)]
-use std::num::Wrapping;
-
-assert!(Wrapping(16", stringify!($t), ").is_power_of_two());
-assert!(!Wrapping(10", stringify!($t), ").is_power_of_two());
-```"),
-                #[inline]
-                #[unstable(feature = "wrapping_int_impl", issue = "32463")]
-                pub fn is_power_of_two(self) -> bool {
-                    self.0.is_power_of_two()
-                }
+            /// Returns `true` if and only if `self == 2^k` for some `k`.
+            ///
+            /// # Examples
+            ///
+            /// Basic usage:
+            ///
+            /// ```
+            /// #![feature(wrapping_int_impl)]
+            /// use std::num::Wrapping;
+            ///
+            #[doc = concat!("assert!(Wrapping(16", stringify!($t), ").is_power_of_two());")]
+            #[doc = concat!("assert!(!Wrapping(10", stringify!($t), ").is_power_of_two());")]
+            /// ```
+            #[inline]
+            #[unstable(feature = "wrapping_int_impl", issue = "32463")]
+            pub fn is_power_of_two(self) -> bool {
+                self.0.is_power_of_two()
             }
 
-            doc_comment! {
-                concat!("Returns the smallest power of two greater than or equal to `self`.
-
-When return value overflows (i.e., `self > (1 << (N-1))` for type
-`uN`), overflows to `2^N = 0`.
-
-# Examples
-
-Basic usage:
-
-```
-#![feature(wrapping_next_power_of_two)]
-use std::num::Wrapping;
-
-assert_eq!(Wrapping(2", stringify!($t), ").next_power_of_two(), Wrapping(2));
-assert_eq!(Wrapping(3", stringify!($t), ").next_power_of_two(), Wrapping(4));
-assert_eq!(Wrapping(200_u8).next_power_of_two(), Wrapping(0));
-```"),
-                #[inline]
-                #[unstable(feature = "wrapping_next_power_of_two", issue = "32463",
-                           reason = "needs decision on wrapping behaviour")]
-                pub fn next_power_of_two(self) -> Self {
-                    Wrapping(self.0.wrapping_next_power_of_two())
-                }
+            /// Returns the smallest power of two greater than or equal to `self`.
+            ///
+            /// When return value overflows (i.e., `self > (1 << (N-1))` for type
+            /// `uN`), overflows to `2^N = 0`.
+            ///
+            /// # Examples
+            ///
+            /// Basic usage:
+            ///
+            /// ```
+            /// #![feature(wrapping_next_power_of_two)]
+            /// use std::num::Wrapping;
+            ///
+            #[doc = concat!("assert_eq!(Wrapping(2", stringify!($t), ").next_power_of_two(), Wrapping(2));")]
+            #[doc = concat!("assert_eq!(Wrapping(3", stringify!($t), ").next_power_of_two(), Wrapping(4));")]
+            #[doc = concat!("assert_eq!(Wrapping(200_u8).next_power_of_two(), Wrapping(0));")]
+            /// ```
+            #[inline]
+            #[unstable(feature = "wrapping_next_power_of_two", issue = "32463",
+                       reason = "needs decision on wrapping behaviour")]
+            pub fn next_power_of_two(self) -> Self {
+                Wrapping(self.0.wrapping_next_power_of_two())
             }
         }
     )*)
diff --git a/library/core/src/sync/atomic.rs b/library/core/src/sync/atomic.rs
index e4b99e10354..d03c19e51f3 100644
--- a/library/core/src/sync/atomic.rs
+++ b/library/core/src/sync/atomic.rs
@@ -1372,12 +1372,9 @@ macro_rules! atomic_int {
 
         #[$stable_from]
         impl From<$int_type> for $atomic_type {
-            doc_comment! {
-                concat!(
-"Converts an `", stringify!($int_type), "` into an `", stringify!($atomic_type), "`."),
-                #[inline]
-                fn from(v: $int_type) -> Self { Self::new(v) }
-            }
+            #[doc = concat!("Converts an `", stringify!($int_type), "` into an `", stringify!($atomic_type), "`.")]
+            #[inline]
+            fn from(v: $int_type) -> Self { Self::new(v) }
         }
 
         #[$stable_debug]
@@ -1392,744 +1389,703 @@ macro_rules! atomic_int {
         unsafe impl Sync for $atomic_type {}
 
         impl $atomic_type {
-            doc_comment! {
-                concat!("Creates a new atomic integer.
-
-# Examples
-
-```
-", $extra_feature, "use std::sync::atomic::", stringify!($atomic_type), ";
-
-let atomic_forty_two = ", stringify!($atomic_type), "::new(42);
-```"),
-                #[inline]
-                #[$stable]
-                #[$const_stable]
-                pub const fn new(v: $int_type) -> Self {
-                    Self {v: UnsafeCell::new(v)}
-                }
+            /// Creates a new atomic integer.
+            ///
+            /// # Examples
+            ///
+            /// ```
+            #[doc = concat!($extra_feature, "use std::sync::atomic::", stringify!($atomic_type), ";")]
+            ///
+            #[doc = concat!("let atomic_forty_two = ", stringify!($atomic_type), "::new(42);")]
+            /// ```
+            #[inline]
+            #[$stable]
+            #[$const_stable]
+            pub const fn new(v: $int_type) -> Self {
+                Self {v: UnsafeCell::new(v)}
             }
 
-            doc_comment! {
-                concat!("Returns a mutable reference to the underlying integer.
-
-This is safe because the mutable reference guarantees that no other threads are
-concurrently accessing the atomic data.
-
-# Examples
-
-```
-", $extra_feature, "use std::sync::atomic::{", stringify!($atomic_type), ", Ordering};
-
-let mut some_var = ", stringify!($atomic_type), "::new(10);
-assert_eq!(*some_var.get_mut(), 10);
-*some_var.get_mut() = 5;
-assert_eq!(some_var.load(Ordering::SeqCst), 5);
-```"),
-                #[inline]
-                #[$stable_access]
-                pub fn get_mut(&mut self) -> &mut $int_type {
-                    self.v.get_mut()
-                }
+            /// Returns a mutable reference to the underlying integer.
+            ///
+            /// This is safe because the mutable reference guarantees that no other threads are
+            /// concurrently accessing the atomic data.
+            ///
+            /// # Examples
+            ///
+            /// ```
+            #[doc = concat!($extra_feature, "use std::sync::atomic::{", stringify!($atomic_type), ", Ordering};")]
+            ///
+            #[doc = concat!("let mut some_var = ", stringify!($atomic_type), "::new(10);")]
+            /// assert_eq!(*some_var.get_mut(), 10);
+            /// *some_var.get_mut() = 5;
+            /// assert_eq!(some_var.load(Ordering::SeqCst), 5);
+            /// ```
+            #[inline]
+            #[$stable_access]
+            pub fn get_mut(&mut self) -> &mut $int_type {
+                self.v.get_mut()
             }
 
-            doc_comment! {
-                concat!("Get atomic access to a `&mut ", stringify!($int_type), "`.
-
-",
-if_not_8_bit! {
-    $int_type,
-    concat!(
-        "**Note:** This function is only available on targets where `",
-        stringify!($int_type), "` has an alignment of ", $align, " bytes."
-    )
-},
-"
-
-# Examples
-
-```
-#![feature(atomic_from_mut)]
-", $extra_feature, "use std::sync::atomic::{", stringify!($atomic_type), ", Ordering};
-
-let mut some_int = 123;
-let a = ", stringify!($atomic_type), "::from_mut(&mut some_int);
-a.store(100, Ordering::Relaxed);
-assert_eq!(some_int, 100);
-```
-                "),
-                #[inline]
-                #[$cfg_align]
-                #[unstable(feature = "atomic_from_mut", issue = "76314")]
-                pub fn from_mut(v: &mut $int_type) -> &Self {
-                    use crate::mem::align_of;
-                    let [] = [(); align_of::<Self>() - align_of::<$int_type>()];
-                    // SAFETY:
-                    //  - the mutable reference guarantees unique ownership.
-                    //  - the alignment of `$int_type` and `Self` is the
-                    //    same, as promised by $cfg_align and verified above.
-                    unsafe { &*(v as *mut $int_type as *mut Self) }
-                }
+            #[doc = concat!("Get atomic access to a `&mut ", stringify!($int_type), "`.")]
+            ///
+            #[doc = if_not_8_bit! {
+                $int_type,
+                concat!(
+                    "**Note:** This function is only available on targets where `",
+                    stringify!($int_type), "` has an alignment of ", $align, " bytes."
+                )
+            }]
+            ///
+            /// # Examples
+            ///
+            /// ```
+            /// #![feature(atomic_from_mut)]
+            #[doc = concat!($extra_feature, "use std::sync::atomic::{", stringify!($atomic_type), ", Ordering};")]
+            ///
+            /// let mut some_int = 123;
+            #[doc = concat!("let a = ", stringify!($atomic_type), "::from_mut(&mut some_int);")]
+            /// a.store(100, Ordering::Relaxed);
+            /// assert_eq!(some_int, 100);
+            /// ```
+            ///
+            #[inline]
+            #[$cfg_align]
+            #[unstable(feature = "atomic_from_mut", issue = "76314")]
+            pub fn from_mut(v: &mut $int_type) -> &Self {
+                use crate::mem::align_of;
+                let [] = [(); align_of::<Self>() - align_of::<$int_type>()];
+                // SAFETY:
+                //  - the mutable reference guarantees unique ownership.
+                //  - the alignment of `$int_type` and `Self` is the
+                //    same, as promised by $cfg_align and verified above.
+                unsafe { &*(v as *mut $int_type as *mut Self) }
             }
 
-            doc_comment! {
-                concat!("Consumes the atomic and returns the contained value.
-
-This is safe because passing `self` by value guarantees that no other threads are
-concurrently accessing the atomic data.
-
-# Examples
-
-```
-", $extra_feature, "use std::sync::atomic::", stringify!($atomic_type), ";
-
-let some_var = ", stringify!($atomic_type), "::new(5);
-assert_eq!(some_var.into_inner(), 5);
-```"),
-                #[inline]
-                #[$stable_access]
-                #[rustc_const_unstable(feature = "const_cell_into_inner", issue = "78729")]
-                pub const fn into_inner(self) -> $int_type {
-                    self.v.into_inner()
-                }
+            /// Consumes the atomic and returns the contained value.
+            ///
+            /// This is safe because passing `self` by value guarantees that no other threads are
+            /// concurrently accessing the atomic data.
+            ///
+            /// # Examples
+            ///
+            /// ```
+            #[doc = concat!($extra_feature, "use std::sync::atomic::", stringify!($atomic_type), ";")]
+            ///
+            #[doc = concat!("let some_var = ", stringify!($atomic_type), "::new(5);")]
+            /// assert_eq!(some_var.into_inner(), 5);
+            /// ```
+            #[inline]
+            #[$stable_access]
+            #[rustc_const_unstable(feature = "const_cell_into_inner", issue = "78729")]
+            pub const fn into_inner(self) -> $int_type {
+                self.v.into_inner()
             }
 
-            doc_comment! {
-                concat!("Loads a value from the atomic integer.
-
-`load` takes an [`Ordering`] argument which describes the memory ordering of this operation.
-Possible values are [`SeqCst`], [`Acquire`] and [`Relaxed`].
-
-# Panics
-
-Panics if `order` is [`Release`] or [`AcqRel`].
-
-# Examples
-
-```
-", $extra_feature, "use std::sync::atomic::{", stringify!($atomic_type), ", Ordering};
-
-let some_var = ", stringify!($atomic_type), "::new(5);
-
-assert_eq!(some_var.load(Ordering::Relaxed), 5);
-```"),
-                #[inline]
-                #[$stable]
-                pub fn load(&self, order: Ordering) -> $int_type {
-                    // SAFETY: data races are prevented by atomic intrinsics.
-                    unsafe { atomic_load(self.v.get(), order) }
-                }
+            /// Loads a value from the atomic integer.
+            ///
+            /// `load` takes an [`Ordering`] argument which describes the memory ordering of this operation.
+            /// Possible values are [`SeqCst`], [`Acquire`] and [`Relaxed`].
+            ///
+            /// # Panics
+            ///
+            /// Panics if `order` is [`Release`] or [`AcqRel`].
+            ///
+            /// # Examples
+            ///
+            /// ```
+            #[doc = concat!($extra_feature, "use std::sync::atomic::{", stringify!($atomic_type), ", Ordering};")]
+            ///
+            #[doc = concat!("let some_var = ", stringify!($atomic_type), "::new(5);")]
+            ///
+            /// assert_eq!(some_var.load(Ordering::Relaxed), 5);
+            /// ```
+            #[inline]
+            #[$stable]
+            pub fn load(&self, order: Ordering) -> $int_type {
+                // SAFETY: data races are prevented by atomic intrinsics.
+                unsafe { atomic_load(self.v.get(), order) }
             }
 
-            doc_comment! {
-                concat!("Stores a value into the atomic integer.
-
-`store` takes an [`Ordering`] argument which describes the memory ordering of this operation.
- Possible values are [`SeqCst`], [`Release`] and [`Relaxed`].
-
-# Panics
-
-Panics if `order` is [`Acquire`] or [`AcqRel`].
-
-# Examples
-
-```
-", $extra_feature, "use std::sync::atomic::{", stringify!($atomic_type), ", Ordering};
-
-let some_var = ", stringify!($atomic_type), "::new(5);
-
-some_var.store(10, Ordering::Relaxed);
-assert_eq!(some_var.load(Ordering::Relaxed), 10);
-```"),
-                #[inline]
-                #[$stable]
-                pub fn store(&self, val: $int_type, order: Ordering) {
-                    // SAFETY: data races are prevented by atomic intrinsics.
-                    unsafe { atomic_store(self.v.get(), val, order); }
-                }
+            /// Stores a value into the atomic integer.
+            ///
+            /// `store` takes an [`Ordering`] argument which describes the memory ordering of this operation.
+            ///  Possible values are [`SeqCst`], [`Release`] and [`Relaxed`].
+            ///
+            /// # Panics
+            ///
+            /// Panics if `order` is [`Acquire`] or [`AcqRel`].
+            ///
+            /// # Examples
+            ///
+            /// ```
+            #[doc = concat!($extra_feature, "use std::sync::atomic::{", stringify!($atomic_type), ", Ordering};")]
+            ///
+            #[doc = concat!("let some_var = ", stringify!($atomic_type), "::new(5);")]
+            ///
+            /// some_var.store(10, Ordering::Relaxed);
+            /// assert_eq!(some_var.load(Ordering::Relaxed), 10);
+            /// ```
+            #[inline]
+            #[$stable]
+            pub fn store(&self, val: $int_type, order: Ordering) {
+                // SAFETY: data races are prevented by atomic intrinsics.
+                unsafe { atomic_store(self.v.get(), val, order); }
             }
 
-            doc_comment! {
-                concat!("Stores a value into the atomic integer, returning the previous value.
-
-`swap` takes an [`Ordering`] argument which describes the memory ordering
-of this operation. All ordering modes are possible. Note that using
-[`Acquire`] makes the store part of this operation [`Relaxed`], and
-using [`Release`] makes the load part [`Relaxed`].
-
-**Note**: This method is only available on platforms that support atomic
-operations on [`", $s_int_type, "`](", $int_ref, ").
-
-# Examples
-
-```
-", $extra_feature, "use std::sync::atomic::{", stringify!($atomic_type), ", Ordering};
-
-let some_var = ", stringify!($atomic_type), "::new(5);
-
-assert_eq!(some_var.swap(10, Ordering::Relaxed), 5);
-```"),
-                #[inline]
-                #[$stable]
-                #[$cfg_cas]
-                pub fn swap(&self, val: $int_type, order: Ordering) -> $int_type {
-                    // SAFETY: data races are prevented by atomic intrinsics.
-                    unsafe { atomic_swap(self.v.get(), val, order) }
-                }
+            /// Stores a value into the atomic integer, returning the previous value.
+            ///
+            /// `swap` takes an [`Ordering`] argument which describes the memory ordering
+            /// of this operation. All ordering modes are possible. Note that using
+            /// [`Acquire`] makes the store part of this operation [`Relaxed`], and
+            /// using [`Release`] makes the load part [`Relaxed`].
+            ///
+            /// **Note**: This method is only available on platforms that support atomic operations on
+            #[doc = concat!("[`", $s_int_type, "`](", $int_ref, ").")]
+            ///
+            /// # Examples
+            ///
+            /// ```
+            #[doc = concat!($extra_feature, "use std::sync::atomic::{", stringify!($atomic_type), ", Ordering};")]
+            ///
+            #[doc = concat!("let some_var = ", stringify!($atomic_type), "::new(5);")]
+            ///
+            /// assert_eq!(some_var.swap(10, Ordering::Relaxed), 5);
+            /// ```
+            #[inline]
+            #[$stable]
+            #[$cfg_cas]
+            pub fn swap(&self, val: $int_type, order: Ordering) -> $int_type {
+                // SAFETY: data races are prevented by atomic intrinsics.
+                unsafe { atomic_swap(self.v.get(), val, order) }
             }
 
-            doc_comment! {
-                concat!("Stores a value into the atomic integer if the current value is the same as
-the `current` value.
-
-The return value is always the previous value. If it is equal to `current`, then the
-value was updated.
-
-`compare_and_swap` also takes an [`Ordering`] argument which describes the memory
-ordering of this operation. Notice that even when using [`AcqRel`], the operation
-might fail and hence just perform an `Acquire` load, but not have `Release` semantics.
-Using [`Acquire`] makes the store part of this operation [`Relaxed`] if it
-happens, and using [`Release`] makes the load part [`Relaxed`].
-
-**Note**: This method is only available on platforms that support atomic
-operations on [`", $s_int_type, "`](", $int_ref, ").
-
-# Migrating to `compare_exchange` and `compare_exchange_weak`
-
-`compare_and_swap` is equivalent to `compare_exchange` with the following mapping for
-memory orderings:
-
-Original | Success | Failure
--------- | ------- | -------
-Relaxed  | Relaxed | Relaxed
-Acquire  | Acquire | Acquire
-Release  | Release | Relaxed
-AcqRel   | AcqRel  | Acquire
-SeqCst   | SeqCst  | SeqCst
-
-`compare_exchange_weak` is allowed to fail spuriously even when the comparison succeeds,
-which allows the compiler to generate better assembly code when the compare and swap
-is used in a loop.
-
-# Examples
-
-```
-", $extra_feature, "use std::sync::atomic::{", stringify!($atomic_type), ", Ordering};
-
-let some_var = ", stringify!($atomic_type), "::new(5);
-
-assert_eq!(some_var.compare_and_swap(5, 10, Ordering::Relaxed), 5);
-assert_eq!(some_var.load(Ordering::Relaxed), 10);
-
-assert_eq!(some_var.compare_and_swap(6, 12, Ordering::Relaxed), 10);
-assert_eq!(some_var.load(Ordering::Relaxed), 10);
-```"),
-                #[inline]
-                #[$stable]
-                #[rustc_deprecated(
-                    since = "1.50.0",
-                    reason = "Use `compare_exchange` or `compare_exchange_weak` instead")
-                ]
-                #[$cfg_cas]
-                pub fn compare_and_swap(&self,
-                                        current: $int_type,
-                                        new: $int_type,
-                                        order: Ordering) -> $int_type {
-                    match self.compare_exchange(current,
-                                                new,
-                                                order,
-                                                strongest_failure_ordering(order)) {
-                        Ok(x) => x,
-                        Err(x) => x,
-                    }
+            /// Stores a value into the atomic integer if the current value is the same as
+            /// the `current` value.
+            ///
+            /// The return value is always the previous value. If it is equal to `current`, then the
+            /// value was updated.
+            ///
+            /// `compare_and_swap` also takes an [`Ordering`] argument which describes the memory
+            /// ordering of this operation. Notice that even when using [`AcqRel`], the operation
+            /// might fail and hence just perform an `Acquire` load, but not have `Release` semantics.
+            /// Using [`Acquire`] makes the store part of this operation [`Relaxed`] if it
+            /// happens, and using [`Release`] makes the load part [`Relaxed`].
+            ///
+            /// **Note**: This method is only available on platforms that support atomic operations on
+            #[doc = concat!("[`", $s_int_type, "`](", $int_ref, ").")]
+            ///
+            /// # Migrating to `compare_exchange` and `compare_exchange_weak`
+            ///
+            /// `compare_and_swap` is equivalent to `compare_exchange` with the following mapping for
+            /// memory orderings:
+            ///
+            /// Original | Success | Failure
+            /// -------- | ------- | -------
+            /// Relaxed  | Relaxed | Relaxed
+            /// Acquire  | Acquire | Acquire
+            /// Release  | Release | Relaxed
+            /// AcqRel   | AcqRel  | Acquire
+            /// SeqCst   | SeqCst  | SeqCst
+            ///
+            /// `compare_exchange_weak` is allowed to fail spuriously even when the comparison succeeds,
+            /// which allows the compiler to generate better assembly code when the compare and swap
+            /// is used in a loop.
+            ///
+            /// # Examples
+            ///
+            /// ```
+            #[doc = concat!($extra_feature, "use std::sync::atomic::{", stringify!($atomic_type), ", Ordering};")]
+            ///
+            #[doc = concat!("let some_var = ", stringify!($atomic_type), "::new(5);")]
+            ///
+            /// assert_eq!(some_var.compare_and_swap(5, 10, Ordering::Relaxed), 5);
+            /// assert_eq!(some_var.load(Ordering::Relaxed), 10);
+            ///
+            /// assert_eq!(some_var.compare_and_swap(6, 12, Ordering::Relaxed), 10);
+            /// assert_eq!(some_var.load(Ordering::Relaxed), 10);
+            /// ```
+            #[inline]
+            #[$stable]
+            #[rustc_deprecated(
+                since = "1.50.0",
+                reason = "Use `compare_exchange` or `compare_exchange_weak` instead")
+            ]
+            #[$cfg_cas]
+            pub fn compare_and_swap(&self,
+                                    current: $int_type,
+                                    new: $int_type,
+                                    order: Ordering) -> $int_type {
+                match self.compare_exchange(current,
+                                            new,
+                                            order,
+                                            strongest_failure_ordering(order)) {
+                    Ok(x) => x,
+                    Err(x) => x,
                 }
             }
 
-            doc_comment! {
-                concat!("Stores a value into the atomic integer if the current value is the same as
-the `current` value.
-
-The return value is a result indicating whether the new value was written and
-containing the previous value. On success this value is guaranteed to be equal to
-`current`.
-
-`compare_exchange` takes two [`Ordering`] arguments to describe the memory
-ordering of this operation. `success` describes the required ordering for the
-read-modify-write operation that takes place if the comparison with `current` succeeds.
-`failure` describes the required ordering for the load operation that takes place when
-the comparison fails. Using [`Acquire`] as success ordering makes the store part
-of this operation [`Relaxed`], and using [`Release`] makes the successful load
-[`Relaxed`]. The failure ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`]
-and must be equivalent to or weaker than the success ordering.
-
-**Note**: This method is only available on platforms that support atomic
-operations on [`", $s_int_type, "`](", $int_ref, ").
-
-# Examples
-
-```
-", $extra_feature, "use std::sync::atomic::{", stringify!($atomic_type), ", Ordering};
-
-let some_var = ", stringify!($atomic_type), "::new(5);
-
-assert_eq!(some_var.compare_exchange(5, 10,
-                                     Ordering::Acquire,
-                                     Ordering::Relaxed),
-           Ok(5));
-assert_eq!(some_var.load(Ordering::Relaxed), 10);
-
-assert_eq!(some_var.compare_exchange(6, 12,
-                                     Ordering::SeqCst,
-                                     Ordering::Acquire),
-           Err(10));
-assert_eq!(some_var.load(Ordering::Relaxed), 10);
-```"),
-                #[inline]
-                #[$stable_cxchg]
-                #[$cfg_cas]
-                pub fn compare_exchange(&self,
-                                        current: $int_type,
-                                        new: $int_type,
-                                        success: Ordering,
-                                        failure: Ordering) -> Result<$int_type, $int_type> {
-                    // SAFETY: data races are prevented by atomic intrinsics.
-                    unsafe { atomic_compare_exchange(self.v.get(), current, new, success, failure) }
-                }
+            /// Stores a value into the atomic integer if the current value is the same as
+            /// the `current` value.
+            ///
+            /// The return value is a result indicating whether the new value was written and
+            /// containing the previous value. On success this value is guaranteed to be equal to
+            /// `current`.
+            ///
+            /// `compare_exchange` takes two [`Ordering`] arguments to describe the memory
+            /// ordering of this operation. `success` describes the required ordering for the
+            /// read-modify-write operation that takes place if the comparison with `current` succeeds.
+            /// `failure` describes the required ordering for the load operation that takes place when
+            /// the comparison fails. Using [`Acquire`] as success ordering makes the store part
+            /// of this operation [`Relaxed`], and using [`Release`] makes the successful load
+            /// [`Relaxed`]. The failure ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`]
+            /// and must be equivalent to or weaker than the success ordering.
+            ///
+            /// **Note**: This method is only available on platforms that support atomic operations on
+            #[doc = concat!("[`", $s_int_type, "`](", $int_ref, ").")]
+            ///
+            /// # Examples
+            ///
+            /// ```
+            #[doc = concat!($extra_feature, "use std::sync::atomic::{", stringify!($atomic_type), ", Ordering};")]
+            ///
+            #[doc = concat!("let some_var = ", stringify!($atomic_type), "::new(5);")]
+            ///
+            /// assert_eq!(some_var.compare_exchange(5, 10,
+            ///                                      Ordering::Acquire,
+            ///                                      Ordering::Relaxed),
+            ///            Ok(5));
+            /// assert_eq!(some_var.load(Ordering::Relaxed), 10);
+            ///
+            /// assert_eq!(some_var.compare_exchange(6, 12,
+            ///                                      Ordering::SeqCst,
+            ///                                      Ordering::Acquire),
+            ///            Err(10));
+            /// assert_eq!(some_var.load(Ordering::Relaxed), 10);
+            /// ```
+            #[inline]
+            #[$stable_cxchg]
+            #[$cfg_cas]
+            pub fn compare_exchange(&self,
+                                    current: $int_type,
+                                    new: $int_type,
+                                    success: Ordering,
+                                    failure: Ordering) -> Result<$int_type, $int_type> {
+                // SAFETY: data races are prevented by atomic intrinsics.
+                unsafe { atomic_compare_exchange(self.v.get(), current, new, success, failure) }
             }
 
-            doc_comment! {
-                concat!("Stores a value into the atomic integer if the current value is the same as
-the `current` value.
-
-Unlike [`", stringify!($atomic_type), "::compare_exchange`], this function is allowed to spuriously fail even
-when the comparison succeeds, which can result in more efficient code on some
-platforms. The return value is a result indicating whether the new value was
-written and containing the previous value.
-
-`compare_exchange_weak` takes two [`Ordering`] arguments to describe the memory
-ordering of this operation. `success` describes the required ordering for the
-read-modify-write operation that takes place if the comparison with `current` succeeds.
-`failure` describes the required ordering for the load operation that takes place when
-the comparison fails. Using [`Acquire`] as success ordering makes the store part
-of this operation [`Relaxed`], and using [`Release`] makes the successful load
-[`Relaxed`]. The failure ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`]
-and must be equivalent to or weaker than the success ordering.
-
-**Note**: This method is only available on platforms that support atomic
-operations on [`", $s_int_type, "`](", $int_ref, ").
-
-# Examples
-
-```
-", $extra_feature, "use std::sync::atomic::{", stringify!($atomic_type), ", Ordering};
-
-let val = ", stringify!($atomic_type), "::new(4);
-
-let mut old = val.load(Ordering::Relaxed);
-loop {
-    let new = old * 2;
-    match val.compare_exchange_weak(old, new, Ordering::SeqCst, Ordering::Relaxed) {
-        Ok(_) => break,
-        Err(x) => old = x,
-    }
-}
-```"),
-                #[inline]
-                #[$stable_cxchg]
-                #[$cfg_cas]
-                pub fn compare_exchange_weak(&self,
-                                             current: $int_type,
-                                             new: $int_type,
-                                             success: Ordering,
-                                             failure: Ordering) -> Result<$int_type, $int_type> {
-                    // SAFETY: data races are prevented by atomic intrinsics.
-                    unsafe {
-                        atomic_compare_exchange_weak(self.v.get(), current, new, success, failure)
-                    }
+            /// Stores a value into the atomic integer if the current value is the same as
+            /// the `current` value.
+            ///
+            #[doc = concat!("Unlike [`", stringify!($atomic_type), "::compare_exchange`],")]
+            /// this function is allowed to spuriously fail even
+            /// when the comparison succeeds, which can result in more efficient code on some
+            /// platforms. The return value is a result indicating whether the new value was
+            /// written and containing the previous value.
+            ///
+            /// `compare_exchange_weak` takes two [`Ordering`] arguments to describe the memory
+            /// ordering of this operation. `success` describes the required ordering for the
+            /// read-modify-write operation that takes place if the comparison with `current` succeeds.
+            /// `failure` describes the required ordering for the load operation that takes place when
+            /// the comparison fails. Using [`Acquire`] as success ordering makes the store part
+            /// of this operation [`Relaxed`], and using [`Release`] makes the successful load
+            /// [`Relaxed`]. The failure ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`]
+            /// and must be equivalent to or weaker than the success ordering.
+            ///
+            /// **Note**: This method is only available on platforms that support atomic operations on
+            #[doc = concat!("[`", $s_int_type, "`](", $int_ref, ").")]
+            ///
+            /// # Examples
+            ///
+            /// ```
+            #[doc = concat!($extra_feature, "use std::sync::atomic::{", stringify!($atomic_type), ", Ordering};")]
+            ///
+            #[doc = concat!("let val = ", stringify!($atomic_type), "::new(4);")]
+            ///
+            /// let mut old = val.load(Ordering::Relaxed);
+            /// loop {
+            ///     let new = old * 2;
+            ///     match val.compare_exchange_weak(old, new, Ordering::SeqCst, Ordering::Relaxed) {
+            ///         Ok(_) => break,
+            ///         Err(x) => old = x,
+            ///     }
+            /// }
+            /// ```
+            #[inline]
+            #[$stable_cxchg]
+            #[$cfg_cas]
+            pub fn compare_exchange_weak(&self,
+                                         current: $int_type,
+                                         new: $int_type,
+                                         success: Ordering,
+                                         failure: Ordering) -> Result<$int_type, $int_type> {
+                // SAFETY: data races are prevented by atomic intrinsics.
+                unsafe {
+                    atomic_compare_exchange_weak(self.v.get(), current, new, success, failure)
                 }
             }
 
-            doc_comment! {
-                concat!("Adds to the current value, returning the previous value.
-
-This operation wraps around on overflow.
-
-`fetch_add` takes an [`Ordering`] argument which describes the memory ordering
-of this operation. All ordering modes are possible. Note that using
-[`Acquire`] makes the store part of this operation [`Relaxed`], and
-using [`Release`] makes the load part [`Relaxed`].
-
-**Note**: This method is only available on platforms that support atomic
-operations on [`", $s_int_type, "`](", $int_ref, ").
-
-# Examples
-
-```
-", $extra_feature, "use std::sync::atomic::{", stringify!($atomic_type), ", Ordering};
-
-let foo = ", stringify!($atomic_type), "::new(0);
-assert_eq!(foo.fetch_add(10, Ordering::SeqCst), 0);
-assert_eq!(foo.load(Ordering::SeqCst), 10);
-```"),
-                #[inline]
-                #[$stable]
-                #[$cfg_cas]
-                pub fn fetch_add(&self, val: $int_type, order: Ordering) -> $int_type {
-                    // SAFETY: data races are prevented by atomic intrinsics.
-                    unsafe { atomic_add(self.v.get(), val, order) }
-                }
+            /// Adds to the current value, returning the previous value.
+            ///
+            /// This operation wraps around on overflow.
+            ///
+            /// `fetch_add` takes an [`Ordering`] argument which describes the memory ordering
+            /// of this operation. All ordering modes are possible. Note that using
+            /// [`Acquire`] makes the store part of this operation [`Relaxed`], and
+            /// using [`Release`] makes the load part [`Relaxed`].
+            ///
+            /// **Note**: This method is only available on platforms that support atomic operations on
+            #[doc = concat!("[`", $s_int_type, "`](", $int_ref, ").")]
+            ///
+            /// # Examples
+            ///
+            /// ```
+            #[doc = concat!($extra_feature, "use std::sync::atomic::{", stringify!($atomic_type), ", Ordering};")]
+            ///
+            #[doc = concat!("let foo = ", stringify!($atomic_type), "::new(0);")]
+            /// assert_eq!(foo.fetch_add(10, Ordering::SeqCst), 0);
+            /// assert_eq!(foo.load(Ordering::SeqCst), 10);
+            /// ```
+            #[inline]
+            #[$stable]
+            #[$cfg_cas]
+            pub fn fetch_add(&self, val: $int_type, order: Ordering) -> $int_type {
+                // SAFETY: data races are prevented by atomic intrinsics.
+                unsafe { atomic_add(self.v.get(), val, order) }
             }
 
-            doc_comment! {
-                concat!("Subtracts from the current value, returning the previous value.
-
-This operation wraps around on overflow.
-
-`fetch_sub` takes an [`Ordering`] argument which describes the memory ordering
-of this operation. All ordering modes are possible. Note that using
-[`Acquire`] makes the store part of this operation [`Relaxed`], and
-using [`Release`] makes the load part [`Relaxed`].
-
-**Note**: This method is only available on platforms that support atomic
-operations on [`", $s_int_type, "`](", $int_ref, ").
-
-# Examples
-
-```
-", $extra_feature, "use std::sync::atomic::{", stringify!($atomic_type), ", Ordering};
-
-let foo = ", stringify!($atomic_type), "::new(20);
-assert_eq!(foo.fetch_sub(10, Ordering::SeqCst), 20);
-assert_eq!(foo.load(Ordering::SeqCst), 10);
-```"),
-                #[inline]
-                #[$stable]
-                #[$cfg_cas]
-                pub fn fetch_sub(&self, val: $int_type, order: Ordering) -> $int_type {
-                    // SAFETY: data races are prevented by atomic intrinsics.
-                    unsafe { atomic_sub(self.v.get(), val, order) }
-                }
+            /// Subtracts from the current value, returning the previous value.
+            ///
+            /// This operation wraps around on overflow.
+            ///
+            /// `fetch_sub` takes an [`Ordering`] argument which describes the memory ordering
+            /// of this operation. All ordering modes are possible. Note that using
+            /// [`Acquire`] makes the store part of this operation [`Relaxed`], and
+            /// using [`Release`] makes the load part [`Relaxed`].
+            ///
+            /// **Note**: This method is only available on platforms that support atomic operations on
+            #[doc = concat!("[`", $s_int_type, "`](", $int_ref, ").")]
+            ///
+            /// # Examples
+            ///
+            /// ```
+            #[doc = concat!($extra_feature, "use std::sync::atomic::{", stringify!($atomic_type), ", Ordering};")]
+            ///
+            #[doc = concat!("let foo = ", stringify!($atomic_type), "::new(20);")]
+            /// assert_eq!(foo.fetch_sub(10, Ordering::SeqCst), 20);
+            /// assert_eq!(foo.load(Ordering::SeqCst), 10);
+            /// ```
+            #[inline]
+            #[$stable]
+            #[$cfg_cas]
+            pub fn fetch_sub(&self, val: $int_type, order: Ordering) -> $int_type {
+                // SAFETY: data races are prevented by atomic intrinsics.
+                unsafe { atomic_sub(self.v.get(), val, order) }
             }
 
-            doc_comment! {
-                concat!("Bitwise \"and\" with the current value.
-
-Performs a bitwise \"and\" operation on the current value and the argument `val`, and
-sets the new value to the result.
-
-Returns the previous value.
-
-`fetch_and` takes an [`Ordering`] argument which describes the memory ordering
-of this operation. All ordering modes are possible. Note that using
-[`Acquire`] makes the store part of this operation [`Relaxed`], and
-using [`Release`] makes the load part [`Relaxed`].
-
-**Note**: This method is only available on platforms that support atomic
-operations on [`", $s_int_type, "`](", $int_ref, ").
-
-# Examples
-
-```
-", $extra_feature, "use std::sync::atomic::{", stringify!($atomic_type), ", Ordering};
-
-let foo = ", stringify!($atomic_type), "::new(0b101101);
-assert_eq!(foo.fetch_and(0b110011, Ordering::SeqCst), 0b101101);
-assert_eq!(foo.load(Ordering::SeqCst), 0b100001);
-```"),
-                #[inline]
-                #[$stable]
-                #[$cfg_cas]
-                pub fn fetch_and(&self, val: $int_type, order: Ordering) -> $int_type {
-                    // SAFETY: data races are prevented by atomic intrinsics.
-                    unsafe { atomic_and(self.v.get(), val, order) }
-                }
+            /// Bitwise "and" with the current value.
+            ///
+            /// Performs a bitwise "and" operation on the current value and the argument `val`, and
+            /// sets the new value to the result.
+            ///
+            /// Returns the previous value.
+            ///
+            /// `fetch_and` takes an [`Ordering`] argument which describes the memory ordering
+            /// of this operation. All ordering modes are possible. Note that using
+            /// [`Acquire`] makes the store part of this operation [`Relaxed`], and
+            /// using [`Release`] makes the load part [`Relaxed`].
+            ///
+            /// **Note**: This method is only available on platforms that support atomic operations on
+            #[doc = concat!("[`", $s_int_type, "`](", $int_ref, ").")]
+            ///
+            /// # Examples
+            ///
+            /// ```
+            #[doc = concat!($extra_feature, "use std::sync::atomic::{", stringify!($atomic_type), ", Ordering};")]
+            ///
+            #[doc = concat!("let foo = ", stringify!($atomic_type), "::new(0b101101);")]
+            /// assert_eq!(foo.fetch_and(0b110011, Ordering::SeqCst), 0b101101);
+            /// assert_eq!(foo.load(Ordering::SeqCst), 0b100001);
+            /// ```
+            #[inline]
+            #[$stable]
+            #[$cfg_cas]
+            pub fn fetch_and(&self, val: $int_type, order: Ordering) -> $int_type {
+                // SAFETY: data races are prevented by atomic intrinsics.
+                unsafe { atomic_and(self.v.get(), val, order) }
             }
 
-            doc_comment! {
-                concat!("Bitwise \"nand\" with the current value.
-
-Performs a bitwise \"nand\" operation on the current value and the argument `val`, and
-sets the new value to the result.
-
-Returns the previous value.
-
-`fetch_nand` takes an [`Ordering`] argument which describes the memory ordering
-of this operation. All ordering modes are possible. Note that using
-[`Acquire`] makes the store part of this operation [`Relaxed`], and
-using [`Release`] makes the load part [`Relaxed`].
-
-**Note**: This method is only available on platforms that support atomic
-operations on [`", $s_int_type, "`](", $int_ref, ").
-
-# Examples
-
-```
-", $extra_feature, "
-use std::sync::atomic::{", stringify!($atomic_type), ", Ordering};
-
-let foo = ", stringify!($atomic_type), "::new(0x13);
-assert_eq!(foo.fetch_nand(0x31, Ordering::SeqCst), 0x13);
-assert_eq!(foo.load(Ordering::SeqCst), !(0x13 & 0x31));
-```"),
-                #[inline]
-                #[$stable_nand]
-                #[$cfg_cas]
-                pub fn fetch_nand(&self, val: $int_type, order: Ordering) -> $int_type {
-                    // SAFETY: data races are prevented by atomic intrinsics.
-                    unsafe { atomic_nand(self.v.get(), val, order) }
-                }
+            /// Bitwise "nand" with the current value.
+            ///
+            /// Performs a bitwise "nand" operation on the current value and the argument `val`, and
+            /// sets the new value to the result.
+            ///
+            /// Returns the previous value.
+            ///
+            /// `fetch_nand` takes an [`Ordering`] argument which describes the memory ordering
+            /// of this operation. All ordering modes are possible. Note that using
+            /// [`Acquire`] makes the store part of this operation [`Relaxed`], and
+            /// using [`Release`] makes the load part [`Relaxed`].
+            ///
+            /// **Note**: This method is only available on platforms that support atomic operations on
+            #[doc = concat!("[`", $s_int_type, "`](", $int_ref, ").")]
+            ///
+            /// # Examples
+            ///
+            /// ```
+            #[doc = concat!($extra_feature, "use std::sync::atomic::{", stringify!($atomic_type), ", Ordering};")]
+            ///
+            #[doc = concat!("let foo = ", stringify!($atomic_type), "::new(0x13);")]
+            /// assert_eq!(foo.fetch_nand(0x31, Ordering::SeqCst), 0x13);
+            /// assert_eq!(foo.load(Ordering::SeqCst), !(0x13 & 0x31));
+            /// ```
+            #[inline]
+            #[$stable_nand]
+            #[$cfg_cas]
+            pub fn fetch_nand(&self, val: $int_type, order: Ordering) -> $int_type {
+                // SAFETY: data races are prevented by atomic intrinsics.
+                unsafe { atomic_nand(self.v.get(), val, order) }
             }
 
-            doc_comment! {
-                concat!("Bitwise \"or\" with the current value.
-
-Performs a bitwise \"or\" operation on the current value and the argument `val`, and
-sets the new value to the result.
-
-Returns the previous value.
-
-`fetch_or` takes an [`Ordering`] argument which describes the memory ordering
-of this operation. All ordering modes are possible. Note that using
-[`Acquire`] makes the store part of this operation [`Relaxed`], and
-using [`Release`] makes the load part [`Relaxed`].
-
-**Note**: This method is only available on platforms that support atomic
-operations on [`", $s_int_type, "`](", $int_ref, ").
-
-# Examples
-
-```
-", $extra_feature, "use std::sync::atomic::{", stringify!($atomic_type), ", Ordering};
-
-let foo = ", stringify!($atomic_type), "::new(0b101101);
-assert_eq!(foo.fetch_or(0b110011, Ordering::SeqCst), 0b101101);
-assert_eq!(foo.load(Ordering::SeqCst), 0b111111);
-```"),
-                #[inline]
-                #[$stable]
-                #[$cfg_cas]
-                pub fn fetch_or(&self, val: $int_type, order: Ordering) -> $int_type {
-                    // SAFETY: data races are prevented by atomic intrinsics.
-                    unsafe { atomic_or(self.v.get(), val, order) }
-                }
+            /// Bitwise "or" with the current value.
+            ///
+            /// Performs a bitwise "or" operation on the current value and the argument `val`, and
+            /// sets the new value to the result.
+            ///
+            /// Returns the previous value.
+            ///
+            /// `fetch_or` takes an [`Ordering`] argument which describes the memory ordering
+            /// of this operation. All ordering modes are possible. Note that using
+            /// [`Acquire`] makes the store part of this operation [`Relaxed`], and
+            /// using [`Release`] makes the load part [`Relaxed`].
+            ///
+            /// **Note**: This method is only available on platforms that support atomic operations on
+            #[doc = concat!("[`", $s_int_type, "`](", $int_ref, ").")]
+            ///
+            /// # Examples
+            ///
+            /// ```
+            #[doc = concat!($extra_feature, "use std::sync::atomic::{", stringify!($atomic_type), ", Ordering};")]
+            ///
+            #[doc = concat!("let foo = ", stringify!($atomic_type), "::new(0b101101);")]
+            /// assert_eq!(foo.fetch_or(0b110011, Ordering::SeqCst), 0b101101);
+            /// assert_eq!(foo.load(Ordering::SeqCst), 0b111111);
+            /// ```
+            #[inline]
+            #[$stable]
+            #[$cfg_cas]
+            pub fn fetch_or(&self, val: $int_type, order: Ordering) -> $int_type {
+                // SAFETY: data races are prevented by atomic intrinsics.
+                unsafe { atomic_or(self.v.get(), val, order) }
             }
 
-            doc_comment! {
-                concat!("Bitwise \"xor\" with the current value.
-
-Performs a bitwise \"xor\" operation on the current value and the argument `val`, and
-sets the new value to the result.
-
-Returns the previous value.
-
-`fetch_xor` takes an [`Ordering`] argument which describes the memory ordering
-of this operation. All ordering modes are possible. Note that using
-[`Acquire`] makes the store part of this operation [`Relaxed`], and
-using [`Release`] makes the load part [`Relaxed`].
-
-**Note**: This method is only available on platforms that support atomic
-operations on [`", $s_int_type, "`](", $int_ref, ").
-
-# Examples
-
-```
-", $extra_feature, "use std::sync::atomic::{", stringify!($atomic_type), ", Ordering};
-
-let foo = ", stringify!($atomic_type), "::new(0b101101);
-assert_eq!(foo.fetch_xor(0b110011, Ordering::SeqCst), 0b101101);
-assert_eq!(foo.load(Ordering::SeqCst), 0b011110);
-```"),
-                #[inline]
-                #[$stable]
-                #[$cfg_cas]
-                pub fn fetch_xor(&self, val: $int_type, order: Ordering) -> $int_type {
-                    // SAFETY: data races are prevented by atomic intrinsics.
-                    unsafe { atomic_xor(self.v.get(), val, order) }
-                }
+            /// Bitwise "xor" with the current value.
+            ///
+            /// Performs a bitwise "xor" operation on the current value and the argument `val`, and
+            /// sets the new value to the result.
+            ///
+            /// Returns the previous value.
+            ///
+            /// `fetch_xor` takes an [`Ordering`] argument which describes the memory ordering
+            /// of this operation. All ordering modes are possible. Note that using
+            /// [`Acquire`] makes the store part of this operation [`Relaxed`], and
+            /// using [`Release`] makes the load part [`Relaxed`].
+            ///
+            /// **Note**: This method is only available on platforms that support atomic operations on
+            #[doc = concat!("[`", $s_int_type, "`](", $int_ref, ").")]
+            ///
+            /// # Examples
+            ///
+            /// ```
+            #[doc = concat!($extra_feature, "use std::sync::atomic::{", stringify!($atomic_type), ", Ordering};")]
+            ///
+            #[doc = concat!("let foo = ", stringify!($atomic_type), "::new(0b101101);")]
+            /// assert_eq!(foo.fetch_xor(0b110011, Ordering::SeqCst), 0b101101);
+            /// assert_eq!(foo.load(Ordering::SeqCst), 0b011110);
+            /// ```
+            #[inline]
+            #[$stable]
+            #[$cfg_cas]
+            pub fn fetch_xor(&self, val: $int_type, order: Ordering) -> $int_type {
+                // SAFETY: data races are prevented by atomic intrinsics.
+                unsafe { atomic_xor(self.v.get(), val, order) }
             }
 
-            doc_comment! {
-                concat!("Fetches the value, and applies a function to it that returns an optional
-new value. Returns a `Result` of `Ok(previous_value)` if the function returned `Some(_)`, else
-`Err(previous_value)`.
-
-Note: This may call the function multiple times if the value has been changed from other threads in
-the meantime, as long as the function returns `Some(_)`, but the function will have been applied
-only once to the stored value.
-
-`fetch_update` takes two [`Ordering`] arguments to describe the memory ordering of this operation.
-The first describes the required ordering for when the operation finally succeeds while the second
-describes the required ordering for loads. These correspond to the success and failure orderings of
-[`", stringify!($atomic_type), "::compare_exchange`] respectively.
-
-Using [`Acquire`] as success ordering makes the store part
-of this operation [`Relaxed`], and using [`Release`] makes the final successful load
-[`Relaxed`]. The (failed) load ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`]
-and must be equivalent to or weaker than the success ordering.
-
-**Note**: This method is only available on platforms that support atomic
-operations on [`", $s_int_type, "`](", $int_ref, ").
-
-# Examples
-
-```rust
-", $extra_feature, "use std::sync::atomic::{", stringify!($atomic_type), ", Ordering};
-
-let x = ", stringify!($atomic_type), "::new(7);
-assert_eq!(x.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |_| None), Err(7));
-assert_eq!(x.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |x| Some(x + 1)), Ok(7));
-assert_eq!(x.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |x| Some(x + 1)), Ok(8));
-assert_eq!(x.load(Ordering::SeqCst), 9);
-```"),
-                #[inline]
-                #[stable(feature = "no_more_cas", since = "1.45.0")]
-                #[$cfg_cas]
-                pub fn fetch_update<F>(&self,
-                                       set_order: Ordering,
-                                       fetch_order: Ordering,
-                                       mut f: F) -> Result<$int_type, $int_type>
-                where F: FnMut($int_type) -> Option<$int_type> {
-                    let mut prev = self.load(fetch_order);
-                    while let Some(next) = f(prev) {
-                        match self.compare_exchange_weak(prev, next, set_order, fetch_order) {
-                            x @ Ok(_) => return x,
-                            Err(next_prev) => prev = next_prev
-                        }
+            /// Fetches the value, and applies a function to it that returns an optional
+            /// new value. Returns a `Result` of `Ok(previous_value)` if the function returned `Some(_)`, else
+            /// `Err(previous_value)`.
+            ///
+            /// Note: This may call the function multiple times if the value has been changed from other threads in
+            /// the meantime, as long as the function returns `Some(_)`, but the function will have been applied
+            /// only once to the stored value.
+            ///
+            /// `fetch_update` takes two [`Ordering`] arguments to describe the memory ordering of this operation.
+            /// The first describes the required ordering for when the operation finally succeeds while the second
+            /// describes the required ordering for loads. These correspond to the success and failure orderings of
+            #[doc = concat!("[`", stringify!($atomic_type), "::compare_exchange`]")]
+            /// respectively.
+            ///
+            /// Using [`Acquire`] as success ordering makes the store part
+            /// of this operation [`Relaxed`], and using [`Release`] makes the final successful load
+            /// [`Relaxed`]. The (failed) load ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`]
+            /// and must be equivalent to or weaker than the success ordering.
+            ///
+            /// **Note**: This method is only available on platforms that support atomic operations on
+            #[doc = concat!("[`", $s_int_type, "`](", $int_ref, ").")]
+            ///
+            /// # Examples
+            ///
+            /// ```rust
+            #[doc = concat!($extra_feature, "use std::sync::atomic::{", stringify!($atomic_type), ", Ordering};")]
+            ///
+            #[doc = concat!("let x = ", stringify!($atomic_type), "::new(7);")]
+            /// assert_eq!(x.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |_| None), Err(7));
+            /// assert_eq!(x.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |x| Some(x + 1)), Ok(7));
+            /// assert_eq!(x.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |x| Some(x + 1)), Ok(8));
+            /// assert_eq!(x.load(Ordering::SeqCst), 9);
+            /// ```
+            #[inline]
+            #[stable(feature = "no_more_cas", since = "1.45.0")]
+            #[$cfg_cas]
+            pub fn fetch_update<F>(&self,
+                                   set_order: Ordering,
+                                   fetch_order: Ordering,
+                                   mut f: F) -> Result<$int_type, $int_type>
+            where F: FnMut($int_type) -> Option<$int_type> {
+                let mut prev = self.load(fetch_order);
+                while let Some(next) = f(prev) {
+                    match self.compare_exchange_weak(prev, next, set_order, fetch_order) {
+                        x @ Ok(_) => return x,
+                        Err(next_prev) => prev = next_prev
                     }
-                    Err(prev)
                 }
+                Err(prev)
             }
 
-            doc_comment! {
-                concat!("Maximum with the current value.
-
-Finds the maximum of the current value and the argument `val`, and
-sets the new value to the result.
-
-Returns the previous value.
-
-`fetch_max` takes an [`Ordering`] argument which describes the memory ordering
-of this operation. All ordering modes are possible. Note that using
-[`Acquire`] makes the store part of this operation [`Relaxed`], and
-using [`Release`] makes the load part [`Relaxed`].
-
-**Note**: This method is only available on platforms that support atomic
-operations on [`", $s_int_type, "`](", $int_ref, ").
-
-# Examples
-
-```
-", $extra_feature, "use std::sync::atomic::{", stringify!($atomic_type), ", Ordering};
-
-let foo = ", stringify!($atomic_type), "::new(23);
-assert_eq!(foo.fetch_max(42, Ordering::SeqCst), 23);
-assert_eq!(foo.load(Ordering::SeqCst), 42);
-```
-
-If you want to obtain the maximum value in one step, you can use the following:
-
-```
-", $extra_feature, "use std::sync::atomic::{", stringify!($atomic_type), ", Ordering};
-
-let foo = ", stringify!($atomic_type), "::new(23);
-let bar = 42;
-let max_foo = foo.fetch_max(bar, Ordering::SeqCst).max(bar);
-assert!(max_foo == 42);
-```"),
-                #[inline]
-                #[stable(feature = "atomic_min_max", since = "1.45.0")]
-                #[$cfg_cas]
-                pub fn fetch_max(&self, val: $int_type, order: Ordering) -> $int_type {
-                    // SAFETY: data races are prevented by atomic intrinsics.
-                    unsafe { $max_fn(self.v.get(), val, order) }
-                }
+            /// Maximum with the current value.
+            ///
+            /// Finds the maximum of the current value and the argument `val`, and
+            /// sets the new value to the result.
+            ///
+            /// Returns the previous value.
+            ///
+            /// `fetch_max` takes an [`Ordering`] argument which describes the memory ordering
+            /// of this operation. All ordering modes are possible. Note that using
+            /// [`Acquire`] makes the store part of this operation [`Relaxed`], and
+            /// using [`Release`] makes the load part [`Relaxed`].
+            ///
+            /// **Note**: This method is only available on platforms that support atomic operations on
+            #[doc = concat!("[`", $s_int_type, "`](", $int_ref, ").")]
+            ///
+            /// # Examples
+            ///
+            /// ```
+            #[doc = concat!($extra_feature, "use std::sync::atomic::{", stringify!($atomic_type), ", Ordering};")]
+            ///
+            #[doc = concat!("let foo = ", stringify!($atomic_type), "::new(23);")]
+            /// assert_eq!(foo.fetch_max(42, Ordering::SeqCst), 23);
+            /// assert_eq!(foo.load(Ordering::SeqCst), 42);
+            /// ```
+            ///
+            /// If you want to obtain the maximum value in one step, you can use the following:
+            ///
+            /// ```
+            #[doc = concat!($extra_feature, "use std::sync::atomic::{", stringify!($atomic_type), ", Ordering};")]
+            ///
+            #[doc = concat!("let foo = ", stringify!($atomic_type), "::new(23);")]
+            /// let bar = 42;
+            /// let max_foo = foo.fetch_max(bar, Ordering::SeqCst).max(bar);
+            /// assert!(max_foo == 42);
+            /// ```
+            #[inline]
+            #[stable(feature = "atomic_min_max", since = "1.45.0")]
+            #[$cfg_cas]
+            pub fn fetch_max(&self, val: $int_type, order: Ordering) -> $int_type {
+                // SAFETY: data races are prevented by atomic intrinsics.
+                unsafe { $max_fn(self.v.get(), val, order) }
             }
 
-            doc_comment! {
-                concat!("Minimum with the current value.
-
-Finds the minimum of the current value and the argument `val`, and
-sets the new value to the result.
-
-Returns the previous value.
-
-`fetch_min` takes an [`Ordering`] argument which describes the memory ordering
-of this operation. All ordering modes are possible. Note that using
-[`Acquire`] makes the store part of this operation [`Relaxed`], and
-using [`Release`] makes the load part [`Relaxed`].
-
-**Note**: This method is only available on platforms that support atomic
-operations on [`", $s_int_type, "`](", $int_ref, ").
-
-# Examples
-
-```
-", $extra_feature, "use std::sync::atomic::{", stringify!($atomic_type), ", Ordering};
-
-let foo = ", stringify!($atomic_type), "::new(23);
-assert_eq!(foo.fetch_min(42, Ordering::Relaxed), 23);
-assert_eq!(foo.load(Ordering::Relaxed), 23);
-assert_eq!(foo.fetch_min(22, Ordering::Relaxed), 23);
-assert_eq!(foo.load(Ordering::Relaxed), 22);
-```
-
-If you want to obtain the minimum value in one step, you can use the following:
-
-```
-", $extra_feature, "use std::sync::atomic::{", stringify!($atomic_type), ", Ordering};
-
-let foo = ", stringify!($atomic_type), "::new(23);
-let bar = 12;
-let min_foo = foo.fetch_min(bar, Ordering::SeqCst).min(bar);
-assert_eq!(min_foo, 12);
-```"),
-                #[inline]
-                #[stable(feature = "atomic_min_max", since = "1.45.0")]
-                #[$cfg_cas]
-                pub fn fetch_min(&self, val: $int_type, order: Ordering) -> $int_type {
-                    // SAFETY: data races are prevented by atomic intrinsics.
-                    unsafe { $min_fn(self.v.get(), val, order) }
-                }
+            /// Minimum with the current value.
+            ///
+            /// Finds the minimum of the current value and the argument `val`, and
+            /// sets the new value to the result.
+            ///
+            /// Returns the previous value.
+            ///
+            /// `fetch_min` takes an [`Ordering`] argument which describes the memory ordering
+            /// of this operation. All ordering modes are possible. Note that using
+            /// [`Acquire`] makes the store part of this operation [`Relaxed`], and
+            /// using [`Release`] makes the load part [`Relaxed`].
+            ///
+            /// **Note**: This method is only available on platforms that support atomic operations on
+            #[doc = concat!("[`", $s_int_type, "`](", $int_ref, ").")]
+            ///
+            /// # Examples
+            ///
+            /// ```
+            #[doc = concat!($extra_feature, "use std::sync::atomic::{", stringify!($atomic_type), ", Ordering};")]
+            ///
+            #[doc = concat!("let foo = ", stringify!($atomic_type), "::new(23);")]
+            /// assert_eq!(foo.fetch_min(42, Ordering::Relaxed), 23);
+            /// assert_eq!(foo.load(Ordering::Relaxed), 23);
+            /// assert_eq!(foo.fetch_min(22, Ordering::Relaxed), 23);
+            /// assert_eq!(foo.load(Ordering::Relaxed), 22);
+            /// ```
+            ///
+            /// If you want to obtain the minimum value in one step, you can use the following:
+            ///
+            /// ```
+            #[doc = concat!($extra_feature, "use std::sync::atomic::{", stringify!($atomic_type), ", Ordering};")]
+            ///
+            #[doc = concat!("let foo = ", stringify!($atomic_type), "::new(23);")]
+            /// let bar = 12;
+            /// let min_foo = foo.fetch_min(bar, Ordering::SeqCst).min(bar);
+            /// assert_eq!(min_foo, 12);
+            /// ```
+            #[inline]
+            #[stable(feature = "atomic_min_max", since = "1.45.0")]
+            #[$cfg_cas]
+            pub fn fetch_min(&self, val: $int_type, order: Ordering) -> $int_type {
+                // SAFETY: data races are prevented by atomic intrinsics.
+                unsafe { $min_fn(self.v.get(), val, order) }
             }
 
-            doc_comment! {
-                concat!("Returns a mutable pointer to the underlying integer.
-
-Doing non-atomic reads and writes on the resulting integer can be a data race.
-This method is mostly useful for FFI, where the function signature may use
-`*mut ", stringify!($int_type), "` instead of `&", stringify!($atomic_type), "`.
-
-Returning an `*mut` pointer from a shared reference to this atomic is safe because the
-atomic types work with interior mutability. All modifications of an atomic change the value
-through a shared reference, and can do so safely as long as they use atomic operations. Any
-use of the returned raw pointer requires an `unsafe` block and still has to uphold the same
-restriction: operations on it must be atomic.
-
-# Examples
-
-```ignore (extern-declaration)
-# fn main() {
-", $extra_feature, "use std::sync::atomic::", stringify!($atomic_type), ";
-
-extern {
-    fn my_atomic_op(arg: *mut ", stringify!($int_type), ");
-}
-
-let mut atomic = ", stringify!($atomic_type), "::new(1);
-",
-// SAFETY: Safe as long as `my_atomic_op` is atomic.
-"unsafe {
-    my_atomic_op(atomic.as_mut_ptr());
-}
-# }
-```"),
-                #[inline]
-                #[unstable(feature = "atomic_mut_ptr",
-                       reason = "recently added",
-                       issue = "66893")]
-                pub fn as_mut_ptr(&self) -> *mut $int_type {
-                    self.v.get()
-                }
+            /// Returns a mutable pointer to the underlying integer.
+            ///
+            /// Doing non-atomic reads and writes on the resulting integer can be a data race.
+            /// This method is mostly useful for FFI, where the function signature may use
+            #[doc = concat!("`*mut ", stringify!($int_type), "` instead of `&", stringify!($atomic_type), "`.")]
+            ///
+            /// Returning an `*mut` pointer from a shared reference to this atomic is safe because the
+            /// atomic types work with interior mutability. All modifications of an atomic change the value
+            /// through a shared reference, and can do so safely as long as they use atomic operations. Any
+            /// use of the returned raw pointer requires an `unsafe` block and still has to uphold the same
+            /// restriction: operations on it must be atomic.
+            ///
+            /// # Examples
+            ///
+            /// ```ignore (extern-declaration)
+            /// # fn main() {
+            #[doc = concat!($extra_feature, "use std::sync::atomic::", stringify!($atomic_type), ";")]
+            ///
+            /// extern {
+            #[doc = concat!("    fn my_atomic_op(arg: *mut ", stringify!($int_type), ");")]
+            /// }
+            ///
+            #[doc = concat!("let mut atomic = ", stringify!($atomic_type), "::new(1);")]
+            ///
+            // SAFETY: Safe as long as `my_atomic_op` is atomic.
+            /// unsafe {
+            ///     my_atomic_op(atomic.as_mut_ptr());
+            /// }
+            /// # }
+            /// ```
+            #[inline]
+            #[unstable(feature = "atomic_mut_ptr",
+                   reason = "recently added",
+                   issue = "66893")]
+            pub fn as_mut_ptr(&self) -> *mut $int_type {
+                self.v.get()
             }
         }
     }