stabilize const_ptr_is_null

Author: RalfJung

compiler/rustc_const_eval/src/const_eval/machine.rs

@@ -263,6 +263,12 @@ impl<'tcx> CompileTimeInterpCx<'tcx> {
 }
 
 /// See documentation on the `ptr_guaranteed_cmp` intrinsic.
+/// Returns `2` if the result is unknown.
+/// Returns `1` if the pointers are guaranteed equal.
+/// Returns `0` if the pointers are guaranteed inequal.
+///
+/// Note that this intrinsic is exposed on stable for comparison with null. In other words, any
+/// change to this function that affects comparison with null is insta-stable!
 fnguaranteed_cmp(&mutself,a:Scalar,b:Scalar) -> InterpResult<'tcx,u8>{
 interp_ok(match(a, b){
 // Comparisons between integers are always known.

library/core/src/intrinsics/mod.rs

@@ -3292,8 +3292,8 @@ pub const unsafe fn ptr_offset_from_unsigned<T>(_ptr: *const T, _base: *const T)
 
 /// See documentation of `<*const T>::guaranteed_eq` for details.
 /// Returns `2` if the result is unknown.
-/// Returns `1` if the pointers are guaranteed equal
-/// Returns `0` if the pointers are guaranteed inequal
+/// Returns `1` if the pointers are guaranteed equal.
+/// Returns `0` if the pointers are guaranteed inequal.
 #[cfg_attr(bootstrap, rustc_const_unstable(feature = "const_raw_ptr_comparison", issue = "53020"))]
 #[rustc_intrinsic]
 #[rustc_nounwind]

library/core/src/lib.rs

@@ -121,7 +121,6 @@
 #![feature(const_heap)]
 #![feature(const_nonnull_new)]
 #![feature(const_pin_2)]
-#![feature(const_ptr_is_null)]
 #![feature(const_ptr_sub_ptr)]
 #![feature(const_raw_ptr_comparison)]
 #![feature(const_size_of_val)]

library/core/src/ptr/const_ptr.rs

@@ -29,16 +29,18 @@ impl<T: ?Sized> *const T {
 /// assert!(!ptr.is_null());
 /// ```
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_ptr_is_null",issue = "74939")]
+#[rustc_const_stable(feature = "const_ptr_is_null",since = "CURRENT_RUSTC_VERSION")]
 #[rustc_diagnostic_item = "ptr_const_is_null"]
 #[inline]
+#[rustc_allow_const_fn_unstable(const_eval_select)]
 pubconstfnis_null(self) -> bool{
 // Compare via a cast to a thin pointer, so fat pointers are only
 // considering their "data" part for null-ness.
 let ptr = selfas*constu8;
 const_eval_select!(
  @capture { ptr:*constu8} -> bool:
-ifconst #[rustc_const_unstable(feature = "const_ptr_is_null", issue = "74939")]{
+// This use of `const_raw_ptr_comparison` has been explicitly blessed by t-lang.
+ifconst #[rustc_allow_const_fn_unstable(const_raw_ptr_comparison)]{
 match(ptr).guaranteed_eq(null_mut()){
 Some(res) => res,
 // To remain maximally convervative, we stop execution when we don't
@@ -280,7 +282,7 @@ impl<T: ?Sized> *const T {
 /// }
 /// ```
 #[stable(feature = "ptr_as_ref", since = "1.9.0")]
-#[rustc_const_unstable(feature = "const_ptr_is_null",issue = "74939")]
+#[rustc_const_stable(feature = "const_ptr_is_null",since = "CURRENT_RUSTC_VERSION")]
 #[inline]
 pubconstunsafefnas_ref<'a>(self) -> Option<&'aT>{
 // SAFETY: the caller must guarantee that `self` is valid

library/core/src/ptr/mut_ptr.rs

@@ -29,7 +29,7 @@ impl<T: ?Sized> *mut T {
 /// assert!(!ptr.is_null());
 /// ```
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_ptr_is_null",issue = "74939")]
+#[rustc_const_stable(feature = "const_ptr_is_null",since = "CURRENT_RUSTC_VERSION")]
 #[rustc_diagnostic_item = "ptr_is_null"]
 #[inline]
 pubconstfnis_null(self) -> bool{
@@ -271,7 +271,7 @@ impl<T: ?Sized> *mut T {
 /// }
 /// ```
 #[stable(feature = "ptr_as_ref", since = "1.9.0")]
-#[rustc_const_unstable(feature = "const_ptr_is_null",issue = "74939")]
+#[rustc_const_stable(feature = "const_ptr_is_null",since = "CURRENT_RUSTC_VERSION")]
 #[inline]
 pubconstunsafefnas_ref<'a>(self) -> Option<&'aT>{
 // SAFETY: the caller must guarantee that `self` is valid for a
@@ -619,7 +619,7 @@ impl<T: ?Sized> *mut T {
 /// println!("{s:?}"); // It'll print: "[4, 2, 3]".
 /// ```
 #[stable(feature = "ptr_as_ref", since = "1.9.0")]
-#[rustc_const_unstable(feature = "const_ptr_is_null",issue = "74939")]
+#[rustc_const_stable(feature = "const_ptr_is_null",since = "CURRENT_RUSTC_VERSION")]
 #[inline]
 pubconstunsafefnas_mut<'a>(self) -> Option<&'amutT>{
 // SAFETY: the caller must guarantee that `self` is be valid for

library/core/src/ub_checks.rs

@@ -65,7 +65,7 @@ macro_rules! assert_unsafe_precondition {
  #[inline]
  #[rustc_nounwind]
  #[cfg_attr(bootstrap, rustc_const_unstable(feature = "const_ub_checks", issue = "none"))]
- #[rustc_allow_const_fn_unstable(const_ptr_is_null,const_ub_checks)]// only for UB checks
+ #[rustc_allow_const_fn_unstable(const_ub_checks)]// only for UB checks
 constfn precondition_check($($name:$ty),*){
 if !$e {
 ::core::panicking::panic_nounwind(

tests/ui/consts/const-ptr-is-null.rs

@@ -1,4 +1,3 @@
-#![feature(const_ptr_is_null)]
 use std::ptr;
 
 constIS_NULL:() = {

tests/ui/consts/const-ptr-is-null.stderr

@@ -8,7 +8,7 @@ note: inside `std::ptr::const_ptr::<impl *const T>::is_null::compiletime`
 note: inside `std::ptr::const_ptr::<impl *const i32>::is_null`
  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
 note: inside `MAYBE_NULL`
- --> $DIR/const-ptr-is-null.rs:17:14
+ --> $DIR/const-ptr-is-null.rs:16:14
  |
 LL | assert!(!ptr.wrapping_sub(512).is_null());
  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

tests/ui/consts/ptr_is_null.rs

@@ -1,7 +1,6 @@
 //@ compile-flags: --crate-type=lib
 //@ check-pass
 
-#![feature(const_ptr_is_null)]
 #![allow(useless_ptr_null_checks)]
 
 constFOO:&usize = &42;