Stabilize hint_assert_unchecked

Make both `hint_assert_unchecked` and `const_hint_assert_unchecked`
stable as `hint_assert_unchecked`.

Author: tgross35

Diff for: library/alloc/src/lib.rs

@@ -126,7 +126,6 @@
 #![feature(fn_traits)]
 #![feature(generic_nonzero)]
 #![feature(hasher_prefixfree_extras)]
-#![feature(hint_assert_unchecked)]
 #![feature(inline_const)]
 #![feature(inplace_iteration)]
 #![feature(iter_advance_by)]

Diff for: library/core/src/hint.rs

@@ -137,8 +137,9 @@ pub const unsafe fn unreachable_unchecked() -> ! {
 ///
 /// In release mode, the argument will most likely not actually be evaluated.
 ///
-/// If ever you are tempted to write `assert_unchecked(false)`, then you are actually looking for
-/// [`unreachable_unchecked()`].
+/// `assert_unchecked` is logically equivalent to `if !cond { unreachable_unchecked(); }`. If`
+/// ever you are tempted to write `assert_unchecked(false)`, you should instead use
+/// [`unreachable_unchecked()`] directly.
 ///
 /// # Safety
 ///
@@ -147,8 +148,6 @@ pub const unsafe fn unreachable_unchecked() -> ! {
 /// # Example
 ///
 /// ```
-/// #![feature(hint_assert_unchecked)]
-///
 /// use core::hint;
 ///
 /// /// # Safety
@@ -196,11 +195,11 @@ pub const unsafe fn unreachable_unchecked() -> ! {
 /// pointer already has the builtin assumption that it is nonnull. However, the optimizer can
 /// make use of this information even when it isn't as obvious, such as when checks happen in
 /// called functions.
+#[track_caller]
 #[inline(always)]
 #[doc(alias = "assume")]
-#[track_caller]
-#[unstable(feature = "hint_assert_unchecked", issue = "119131")]
-#[rustc_const_unstable(feature = "const_hint_assert_unchecked", issue = "119131")]
+#[stable(feature = "hint_assert_unchecked", since = "CURRENT_RUSTC_VERSION")]
+#[rustc_const_stable(feature = "hint_assert_unchecked", since = "CURRENT_RUSTC_VERSION")]
 pub const unsafe fn assert_unchecked(cond: bool) {
     // SAFETY: The caller promised `cond` is true.
     unsafe {

Diff for: library/core/src/intrinsics.rs

@@ -960,7 +960,7 @@ extern "rust-intrinsic" {
 /// not be used if the invariant can be discovered by the optimizer on its
 /// own, or if it does not enable any significant optimizations.
 ///
-/// This intrinsic does not have a stable counterpart.
+/// The stabilized version of this intrinsic is [`core::hint::assert_unchecked`].
 #[rustc_const_stable(feature = "const_assume", since = "1.77.0")]
 #[rustc_nounwind]
 #[unstable(feature = "core_intrinsics", issue = "none")]

Diff for: library/core/src/lib.rs

@@ -130,7 +130,6 @@
 #![feature(const_fmt_arguments_new)]
 #![feature(const_hash)]
 #![feature(const_heap)]
-#![feature(const_hint_assert_unchecked)]
 #![feature(const_index_range_slice_index)]
 #![feature(const_int_from_str)]
 #![feature(const_intrinsic_copy)]

Diff for: library/std/src/lib.rs

@@ -327,7 +327,6 @@
 #![feature(generic_nonzero)]
 #![feature(hasher_prefixfree_extras)]
 #![feature(hashmap_internals)]
-#![feature(hint_assert_unchecked)]
 #![feature(ip)]
 #![feature(maybe_uninit_slice)]
 #![feature(maybe_uninit_uninit_array)]

Diff for: tests/ui/consts/const-assert-unchecked-ub.rs

@@ -1,10 +1,6 @@
-#![feature(hint_assert_unchecked)]
-#![feature(const_hint_assert_unchecked)]
-
 const _: () = unsafe {
     let n = u32::MAX.count_ones();
     std::hint::assert_unchecked(n < 32); //~ ERROR evaluation of constant value failed
 };
 
-fn main() {
-}
+fn main() {}

Diff for: tests/ui/consts/const-assert-unchecked-ub.stderr

@@ -1,5 +1,5 @@
 error[E0080]: evaluation of constant value failed
-  --> $DIR/const-assert-unchecked-ub.rs:6:5
+  --> $DIR/const-assert-unchecked-ub.rs:3:5
    |
 LL |     std::hint::assert_unchecked(n < 32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `assume` called with `false`