Stabilize std::ptr::NonNull

diff --git a/src/liballoc/boxed.rs b/src/liballoc/boxed.rs
index 994466e2249cda4d2d783643204a43dca5202807..e7bc10dfaa93ce44af900aae9a84d839e5bec11e 100644 (file)
--- a/src/liballoc/boxed.rs
+++ b/src/liballoc/boxed.rs
@@ -288,16 +288,13 @@ pub unsafe fn from_raw(raw: *mut T) -> Self {
     /// # Examples
     ///
     /// ```
-    /// #![feature(nonnull)]
-    ///
     /// fn main() {
     ///     let x = Box::new(5);
     ///     let ptr = Box::into_nonnull_raw(x);
     ///     let x = unsafe { Box::from_nonnull_raw(ptr) };
     /// }
     /// ```
-    #[unstable(feature = "nonnull", reason = "needs an RFC to flesh out design",
-               issue = "27730")]
+    #[stable(feature = "nonnull", since = "1.24.0")]
     #[inline]
     pub unsafe fn from_nonnull_raw(u: NonNull<T>) -> Self {
         Box(u.into())
@@ -352,15 +349,12 @@ pub fn into_raw(b: Box<T>) -> *mut T {
     /// # Examples
     ///
     /// ```
-    /// #![feature(nonnull)]
-    ///
     /// fn main() {
     ///     let x = Box::new(5);
     ///     let ptr = Box::into_nonnull_raw(x);
     /// }
     /// ```
-    #[unstable(feature = "nonnull", reason = "needs an RFC to flesh out design",
-               issue = "27730")]
+    #[stable(feature = "nonnull", since = "1.24.0")]
     #[inline]
     pub fn into_nonnull_raw(b: Box<T>) -> NonNull<T> {
         Box::into_unique(b).into()

diff --git a/src/liballoc/lib.rs b/src/liballoc/lib.rs
index 07e4ccc45a9b3ced4826de35398d3120c1fd2a9b..f25b455f9154fe2b40c045b87ad0662e91a43f6f 100644 (file)
--- a/src/liballoc/lib.rs
+++ b/src/liballoc/lib.rs
@@ -103,7 +103,6 @@
 #![feature(iter_rfold)]
 #![feature(lang_items)]
 #![feature(needs_allocator)]
-#![feature(nonnull)]
 #![feature(nonzero)]
 #![feature(offset_to)]
 #![feature(optin_builtin_traits)]

diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs
index 6cb84615d095349d5d41a783fde1fbfeb77bd768..2e5f36ed71f207ef7ec2056ef69d315539f48aac 100644 (file)
--- a/src/libcore/ptr.rs
+++ b/src/libcore/ptr.rs
@@ -2481,13 +2481,12 @@ fn from(p: NonNull<T>) -> Self {
 /// Usually this won't be necessary; covariance is correct for most safe abstractions,
 /// such as Box, Rc, Arc, Vec, and LinkedList. This is the case because they
 /// provide a public API that follows the normal shared XOR mutable rules of Rust.
-#[unstable(feature = "shared", reason = "needs an RFC to flesh out design",
-           issue = "27730")]
+#[stable(feature = "nonnull", since = "1.24.0")]
 pub struct NonNull<T: ?Sized> {
     pointer: NonZero<*const T>,
 }
 
-#[unstable(feature = "shared", issue = "27730")]
+#[stable(feature = "nonnull", since = "1.24.0")]
 impl<T: ?Sized> fmt::Debug for NonNull<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{:p}", self.as_ptr())
@@ -2496,20 +2495,20 @@ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 
 /// `NonNull` pointers are not `Send` because the data they reference may be aliased.
 // NB: This impl is unnecessary, but should provide better error messages.
-#[unstable(feature = "nonnull", issue = "27730")]
+#[stable(feature = "nonnull", since = "1.24.0")]
 impl<T: ?Sized> !Send for NonNull<T> { }
 
 /// `NonNull` pointers are not `Sync` because the data they reference may be aliased.
 // NB: This impl is unnecessary, but should provide better error messages.
-#[unstable(feature = "nonnull", issue = "27730")]
+#[stable(feature = "nonnull", since = "1.24.0")]
 impl<T: ?Sized> !Sync for NonNull<T> { }
 
-#[unstable(feature = "nonnull", issue = "27730")]
 impl<T: Sized> NonNull<T> {
     /// Creates a new `NonNull` that is dangling, but well-aligned.
     ///
     /// This is useful for initializing types which lazily allocate, like
     /// `Vec::new` does.
+    #[stable(feature = "nonnull", since = "1.24.0")]
     pub fn empty() -> Self {
         unsafe {
             let ptr = mem::align_of::<T>() as *mut T;
@@ -2518,24 +2517,25 @@ pub fn empty() -> Self {
     }
 }
 
-#[unstable(feature = "nonnull", issue = "27730")]
 impl<T: ?Sized> NonNull<T> {
     /// Creates a new `NonNull`.
     ///
     /// # Safety
     ///
     /// `ptr` must be non-null.
-    #[unstable(feature = "nonnull", issue = "27730")]
+    #[stable(feature = "nonnull", since = "1.24.0")]
     pub const unsafe fn new_unchecked(ptr: *mut T) -> Self {
         NonNull { pointer: NonZero::new_unchecked(ptr) }
     }
 
     /// Creates a new `NonNull` if `ptr` is non-null.
+    #[stable(feature = "nonnull", since = "1.24.0")]
     pub fn new(ptr: *mut T) -> Option<Self> {
         NonZero::new(ptr as *const T).map(|nz| NonNull { pointer: nz })
     }
 
     /// Acquires the underlying `*mut` pointer.
+    #[stable(feature = "nonnull", since = "1.24.0")]
     pub fn as_ptr(self) -> *mut T {
         self.pointer.get() as *mut T
     }
@@ -2545,6 +2545,7 @@ pub fn as_ptr(self) -> *mut T {
     /// The resulting lifetime is bound to self so this behaves "as if"
     /// it were actually an instance of T that is getting borrowed. If a longer
     /// (unbound) lifetime is needed, use `&*my_ptr.ptr()`.
+    #[stable(feature = "nonnull", since = "1.24.0")]
     pub unsafe fn as_ref(&self) -> &T {
         &*self.as_ptr()
     }
@@ -2554,46 +2555,47 @@ pub unsafe fn as_ref(&self) -> &T {
     /// The resulting lifetime is bound to self so this behaves "as if"
     /// it were actually an instance of T that is getting borrowed. If a longer
     /// (unbound) lifetime is needed, use `&mut *my_ptr.ptr_mut()`.
+    #[stable(feature = "nonnull", since = "1.24.0")]
     pub unsafe fn as_mut(&mut self) -> &mut T {
         &mut *self.as_ptr()
     }
 }
 
-#[unstable(feature = "nonnull", issue = "27730")]
+#[stable(feature = "nonnull", since = "1.24.0")]
 impl<T: ?Sized> Clone for NonNull<T> {
     fn clone(&self) -> Self {
         *self
     }
 }
 
-#[unstable(feature = "nonnull", issue = "27730")]
+#[stable(feature = "nonnull", since = "1.24.0")]
 impl<T: ?Sized> Copy for NonNull<T> { }
 
-#[unstable(feature = "nonnull", issue = "27730")]
+#[stable(feature = "nonnull", since = "1.24.0")]
 impl<T: ?Sized, U: ?Sized> CoerceUnsized<NonNull<U>> for NonNull<T> where T: Unsize<U> { }
 
-#[unstable(feature = "nonnull", issue = "27730")]
+#[stable(feature = "nonnull", since = "1.24.0")]
 impl<T: ?Sized> fmt::Pointer for NonNull<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::Pointer::fmt(&self.as_ptr(), f)
     }
 }
 
-#[unstable(feature = "nonnull", issue = "27730")]
+#[stable(feature = "nonnull", since = "1.24.0")]
 impl<T: ?Sized> From<Unique<T>> for NonNull<T> {
     fn from(unique: Unique<T>) -> Self {
         NonNull { pointer: unique.pointer }
     }
 }
 
-#[unstable(feature = "nonnull", issue = "27730")]
+#[stable(feature = "nonnull", since = "1.24.0")]
 impl<'a, T: ?Sized> From<&'a mut T> for NonNull<T> {
     fn from(reference: &'a mut T) -> Self {
         NonNull { pointer: NonZero::from(reference) }
     }
 }
 
-#[unstable(feature = "nonnull", issue = "27730")]
+#[stable(feature = "nonnull", since = "1.24.0")]
 impl<'a, T: ?Sized> From<&'a T> for NonNull<T> {
     fn from(reference: &'a T) -> Self {
         NonNull { pointer: NonZero::from(reference) }

diff --git a/src/libcore/tests/lib.rs b/src/libcore/tests/lib.rs
index bc7052d676d0c6b6c0e210d076cb1992c237036a..1c32452f84635e6b6554b510b8a49199f7aac6d7 100644 (file)
--- a/src/libcore/tests/lib.rs
+++ b/src/libcore/tests/lib.rs
@@ -27,7 +27,6 @@
 #![feature(iterator_try_fold)]
 #![feature(iter_rfind)]
 #![feature(iter_rfold)]
-#![feature(nonnull)]
 #![feature(nonzero)]
 #![feature(pattern)]
 #![feature(raw)]

diff --git a/src/librustc_data_structures/lib.rs b/src/librustc_data_structures/lib.rs
index 1d53825ac37f9155e5567dc4a302864a7c13b3ea..a35ef2f7ce7baefec130cbd7a9823d3897010390 100644 (file)
--- a/src/librustc_data_structures/lib.rs
+++ b/src/librustc_data_structures/lib.rs
@@ -22,7 +22,6 @@
 #![deny(warnings)]
 
 #![feature(collections_range)]
-#![feature(nonnull)]
 #![feature(nonzero)]
 #![feature(unboxed_closures)]
 #![feature(fn_traits)]

diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs
index 9f65d61658cea4378a155fd534d63049191bc6d3..91cc6d25cce01016601c16b1fc0c1a31f024747a 100644 (file)
--- a/src/libstd/lib.rs
+++ b/src/libstd/lib.rs
@@ -283,7 +283,6 @@
 #![feature(macro_vis_matcher)]
 #![feature(needs_panic_runtime)]
 #![feature(never_type)]
-#![feature(nonnull)]
 #![feature(num_bits_bytes)]
 #![feature(old_wrapping)]
 #![feature(on_unimplemented)]

diff --git a/src/libstd/panic.rs b/src/libstd/panic.rs
index 6f7d8ddb7706e7f45df3516a784e208ca0d19a6b..560876006d3f348999cb6568a1381306d7bbc39c 100644 (file)
--- a/src/libstd/panic.rs
+++ b/src/libstd/panic.rs
@@ -198,7 +198,7 @@ impl<T: RefUnwindSafe + ?Sized> UnwindSafe for *const T {}
 impl<T: RefUnwindSafe + ?Sized> UnwindSafe for *mut T {}
 #[unstable(feature = "ptr_internals", issue = "0")]
 impl<T: UnwindSafe + ?Sized> UnwindSafe for Unique<T> {}
-#[unstable(feature = "nonnull", issue = "27730")]
+#[stable(feature = "nonnull", since = "1.24.0")]
 impl<T: RefUnwindSafe + ?Sized> UnwindSafe for NonNull<T> {}
 #[stable(feature = "catch_unwind", since = "1.9.0")]
 impl<T: ?Sized> UnwindSafe for Mutex<T> {}

diff --git a/src/test/run-pass/issue-23433.rs b/src/test/run-pass/issue-23433.rs
index 37cc1b134c3b912b10dc6bcda3f9328c9497a05f..7af732f561deb5d68cbdb6fb7d3eb2e5b4b1ef9e 100644 (file)
--- a/src/test/run-pass/issue-23433.rs
+++ b/src/test/run-pass/issue-23433.rs
@@ -10,8 +10,6 @@
 
 // Don't fail if we encounter a NonZero<*T> where T is an unsized type
 
-#![feature(nonnull)]
-
 use std::ptr::NonNull;
 
 fn main() {