Replace Box::{from,into}_unique with {from,into}_nonnull_raw

Thew `_raw` prefix is included because the fact that `Box`’s ownership
semantics are "dissolved" or recreated seem more important than the exact
parameter type or return type.

Author: SimonSapin

src/liballoc/arc.rs

@@ -286,7 +286,7 @@ impl<T> Arc<T> {
             weak: atomic::AtomicUsize::new(1),
             data,
         };
-        Arc { ptr: NonNull::from(Box::into_unique(x)), phantom: PhantomData }
+        Arc { ptr: Box::into_nonnull_raw(x), phantom: PhantomData }
     }
 
     /// Returns the contained value, if the `Arc` has exactly one strong reference.
@@ -991,11 +991,11 @@ impl<T> Weak<T> {
     pub fn new() -> Weak<T> {
         unsafe {
             Weak {
-                ptr: NonNull::from(Box::into_unique(box ArcInner {
+                ptr: Box::into_nonnull_raw(box ArcInner {
                     strong: atomic::AtomicUsize::new(0),
                     weak: atomic::AtomicUsize::new(1),
                     data: uninitialized(),
-                })),
+                }),
             }
         }
     }

src/liballoc/boxed.rs

@@ -68,7 +68,7 @@ use core::marker::{self, Unsize};
 use core::mem;
 use core::ops::{CoerceUnsized, Deref, DerefMut, Generator, GeneratorState};
 use core::ops::{BoxPlace, Boxed, InPlace, Place, Placer};
-use core::ptr::{self, Unique};
+use core::ptr::{self, NonNull, Unique};
 use core::convert::From;
 use str::from_boxed_utf8_unchecked;
 
@@ -269,38 +269,38 @@ impl<T: ?Sized> Box<T> {
     #[stable(feature = "box_raw", since = "1.4.0")]
     #[inline]
     pub unsafe fn from_raw(raw: *mut T) -> Self {
-        Box::from_unique(Unique::new_unchecked(raw))
+        Box(Unique::new_unchecked(raw))
     }
 
-    /// Constructs a `Box` from a `Unique<T>` pointer.
+    /// Constructs a `Box` from a `NonNull<T>` pointer.
     ///
     /// After calling this function, the memory is owned by a `Box` and `T` can
     /// then be destroyed and released upon drop.
     ///
     /// # Safety
     ///
-    /// A `Unique<T>` can be safely created via [`Unique::new`] and thus doesn't
+    /// A `NonNull<T>` can be safely created via [`NonNull::new`] and thus doesn't
     /// necessarily own the data pointed to nor is the data guaranteed to live
     /// as long as the pointer.
     ///
-    /// [`Unique::new`]: ../../core/ptr/struct.Unique.html#method.new
+    /// [`NonNull::new`]: ../../core/ptr/struct.NonNull.html#method.new
     ///
     /// # Examples
     ///
     /// ```
-    /// #![feature(unique)]
+    /// #![feature(nonnull)]
     ///
     /// fn main() {
     ///     let x = Box::new(5);
-    ///     let ptr = Box::into_unique(x);
-    ///     let x = unsafe { Box::from_unique(ptr) };
+    ///     let ptr = Box::into_nonnull_raw(x);
+    ///     let x = unsafe { Box::from_nonnull_raw(ptr) };
     /// }
     /// ```
-    #[unstable(feature = "unique", reason = "needs an RFC to flesh out design",
+    #[unstable(feature = "nonnull", reason = "needs an RFC to flesh out design",
                issue = "27730")]
     #[inline]
-    pub unsafe fn from_unique(u: Unique<T>) -> Self {
-        Box(u)
+    pub unsafe fn from_nonnull_raw(u: NonNull<T>) -> Self {
+        Box(u.into())
     }
 
     /// Consumes the `Box`, returning the wrapped raw pointer.
@@ -326,41 +326,48 @@ impl<T: ?Sized> Box<T> {
     #[stable(feature = "box_raw", since = "1.4.0")]
     #[inline]
     pub fn into_raw(b: Box<T>) -> *mut T {
-        Box::into_unique(b).as_ptr()
+        Box::into_nonnull_raw(b).as_ptr()
     }
 
-    /// Consumes the `Box`, returning the wrapped pointer as `Unique<T>`.
+    /// Consumes the `Box`, returning the wrapped pointer as `NonNull<T>`.
     ///
     /// After calling this function, the caller is responsible for the
     /// memory previously managed by the `Box`. In particular, the
     /// caller should properly destroy `T` and release the memory. The
-    /// proper way to do so is to either convert the `Unique<T>` pointer:
+    /// proper way to do so is to either convert the `NonNull<T>` pointer:
     ///
-    /// - Into a `Box` with the [`Box::from_unique`] function.
+    /// - Into a `Box` with the [`Box::from_nonnull_raw`] function.
     ///
     /// - Into a raw pointer and back into a `Box` with the [`Box::from_raw`]
     ///   function.
     ///
     /// Note: this is an associated function, which means that you have
-    /// to call it as `Box::into_unique(b)` instead of `b.into_unique()`. This
+    /// to call it as `Box::into_nonnull_raw(b)`
+    /// instead of `b.into_nonnull_raw()`. This
     /// is so that there is no conflict with a method on the inner type.
     ///
-    /// [`Box::from_unique`]: struct.Box.html#method.from_unique
+    /// [`Box::from_nonnull_raw`]: struct.Box.html#method.from_nonnull_raw
     /// [`Box::from_raw`]: struct.Box.html#method.from_raw
     ///
     /// # Examples
     ///
     /// ```
-    /// #![feature(unique)]
+    /// #![feature(nonnull)]
     ///
     /// fn main() {
     ///     let x = Box::new(5);
-    ///     let ptr = Box::into_unique(x);
+    ///     let ptr = Box::into_nonnull_raw(x);
     /// }
     /// ```
-    #[unstable(feature = "unique", reason = "needs an RFC to flesh out design",
+    #[unstable(feature = "nonnull", reason = "needs an RFC to flesh out design",
                issue = "27730")]
     #[inline]
+    pub fn into_nonnull_raw(b: Box<T>) -> NonNull<T> {
+        Box::into_unique(b).into()
+    }
+
+    #[unstable(feature = "ptr_internals", issue = "0", reason = "use into_nonnull_raw instead")]
+    #[inline]
     pub fn into_unique(b: Box<T>) -> Unique<T> {
         let unique = b.0;
         mem::forget(b);

src/liballoc/linked_list.rs

@@ -157,7 +157,7 @@ impl<T> LinkedList<T> {
         unsafe {
             node.next = self.head;
             node.prev = None;
-            let node = Some(NonNull::from(Box::into_unique(node)));
+            let node = Some(Box::into_nonnull_raw(node));
 
             match self.head {
                 None => self.tail = node,
@@ -192,7 +192,7 @@ impl<T> LinkedList<T> {
         unsafe {
             node.next = None;
             node.prev = self.tail;
-            let node = Some(NonNull::from(Box::into_unique(node)));
+            let node = Some(Box::into_nonnull_raw(node));
 
             match self.tail {
                 None => self.head = node,
@@ -986,11 +986,11 @@ impl<'a, T> IterMut<'a, T> {
                     Some(prev) => prev,
                 };
 
-                let node = Some(NonNull::from(Box::into_unique(box Node {
+                let node = Some(Box::into_nonnull_raw(box Node {
                     next: Some(head),
                     prev: Some(prev),
                     element,
-                })));
+                }));
 
                 prev.as_mut().next = node;
                 head.as_mut().prev = node;

src/liballoc/rc.rs

@@ -311,11 +311,11 @@ impl<T> Rc<T> {
             // pointers, which ensures that the weak destructor never frees
             // the allocation while the strong destructor is running, even
             // if the weak pointer is stored inside the strong one.
-            ptr: NonNull::from(Box::into_unique(box RcBox {
+            ptr: Box::into_nonnull_raw(box RcBox {
                 strong: Cell::new(1),
                 weak: Cell::new(1),
                 value,
-            })),
+            }),
             phantom: PhantomData,
         }
     }
@@ -1190,11 +1190,11 @@ impl<T> Weak<T> {
     pub fn new() -> Weak<T> {
         unsafe {
             Weak {
-                ptr: NonNull::from(Box::into_unique(box RcBox {
+                ptr: Box::into_nonnull_raw(box RcBox {
                     strong: Cell::new(0),
                     weak: Cell::new(1),
                     value: uninitialized(),
-                })),
+                }),
             }
         }
     }

src/test/rustdoc-js/from_u.js

@@ -15,7 +15,6 @@ const EXPECTED = {
         { 'path': 'std::char', 'name': 'from_u32' },
         { 'path': 'std::str', 'name': 'from_utf8' },
         { 'path': 'std::string::String', 'name': 'from_utf8' },
-        { 'path': 'std::boxed::Box', 'name': 'from_unique' },
         { 'path': 'std::i32', 'name': 'from_unsigned' },
         { 'path': 'std::i128', 'name': 'from_unsigned' },
     ],