NonZero<u*>::isqrt now calls u*::isqrt; add comments about crashing tests

Author: ChaiTRex

library/core/src/num/int_macros.rs

@@ -1587,6 +1587,9 @@ macro_rules! int_impl {
                 };
 
                 // SAFETY: Inform the optimizer what the range of outputs is.
+                // If testing `core` crashes with no panic message and a
+                // `num::int_sqrt::i*` test failed, it's because your edits
+                // caused these assertions to become false.
                 //
                 // Integer square root is a monotonically nondecreasing
                 // function, which means that increasing the input will never

library/core/src/num/int_sqrt.rs

@@ -50,31 +50,6 @@ pub const fn u8(n: u8) -> u8 {
     U8_ISQRT_WITH_REMAINDER[n as usize].0
 }
 
-/// Returns the [integer square root][1] of any [`usize`](prim@usize) input.
-///
-/// [1]: <https://en.wikipedia.org/wiki/Integer_square_root>
-/// "Wikipedia contributors. Integer square root. Wikipedia, The Free
-/// Encyclopedia."
-#[must_use = "this returns the result of the operation, \
-              without modifying the original"]
-#[inline(always)]
-pub const fn usize(n: usize) -> usize {
-    #[cfg(target_pointer_width = "16")]
-    {
-        u16(n as u16) as usize
-    }
-
-    #[cfg(target_pointer_width = "32")]
-    {
-        u32(n as u32) as usize
-    }
-
-    #[cfg(target_pointer_width = "64")]
-    {
-        u64(n as u64) as usize
-    }
-}
-
 /// Generates an `i*` function that returns the [integer square root][1] of any
 /// **nonnegative** input of a specific signed integer type.
 ///

library/core/src/num/nonzero.rs

@@ -1544,27 +1544,26 @@ macro_rules! nonzero_integer_signedness_dependent_methods {
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         pub const fn isqrt(self) -> Self {
-            let result = super::int_sqrt::$Int(self.get());
+            let result = self.get().isqrt();
 
             // SAFETY: Inform the optimizer what the range of outputs is.
+            // If testing `core` crashes with no panic message and a
+            // `num::int_sqrt::u*` test failed, it's because your edits
+            // caused these assertions or the assertions in `fn isqrt` of
+            // `uint_macros.rs` to become false.
             //
             // Integer square root is a monotonically nondecreasing
             // function, which means that increasing the input will never
             // cause the output to decrease.
             //
-            // The minimum input is 1. The maximum input is `<$Int>::MAX`.
+            // The minimum input is 1. When n is 1, sqrt(n) is 1. If n
+            // increases above 1, sqrt(n) can't decrease below 1, so sqrt(n)
+            // can't decrease below 1 no matter what n is.
             //
-            // When n is 1, sqrt(n) is 1. If n increases above 1, sqrt(n)
-            // can't decrease below 1, so sqrt(n) can't decrease below 1 no
-            // matter what n is.
-            //
-            // When n is below `<$Int>::MAX`, sqrt(n) can't decrease at all
-            // when you increase n to `<$Int>::MAX`, so sqrt(n) can't be above
-            // sqrt(`<$Int>::MAX`) no matter what n is.
+            // The maximum possible output already has an assertion in
+            // `fn isqrt` of `uint_macros.rs`.
             unsafe {
                 hint::assert_unchecked(result > 0);
-                const MAX_RESULT: $Int = super::int_sqrt::$Int(<$Int>::MAX);
-                hint::assert_unchecked(result <= MAX_RESULT);
             }
 
             // SAFETY: As explained above, the minimum integer square root is

library/core/src/num/uint_macros.rs

@@ -2680,6 +2680,10 @@ macro_rules! uint_impl {
             let result = crate::num::int_sqrt::$ActualT(self as $ActualT) as $SelfT;
 
             // SAFETY: Inform the optimizer what the range of outputs is.
+            // If testing `core` crashes with no panic message and a
+            // `num::int_sqrt::u*` test failed, it's because your edits
+            // caused these assertions or the assertions in `fn isqrt` of
+            // `nonzero.rs` to become false.
             //
             // Integer square root is a monotonically nondecreasing
             // function, which means that increasing the input will never