Deprecate `Box::into_raw_non_null`
Per https://github.com/rust-lang/rust/issues/47336#issuecomment-586589016
This commit is contained in:
parent
df768c5c8f
commit
cdb6bef4fb
|
@ -428,7 +428,15 @@ 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_raw_non_null(b).as_ptr()
|
||||
let b = mem::ManuallyDrop::new(b);
|
||||
let mut unique = b.0;
|
||||
// Box is kind-of a library type, but recognized as a "unique pointer" by
|
||||
// Stacked Borrows. This function here corresponds to "reborrowing to
|
||||
// a raw pointer", but there is no actual reborrow here -- so
|
||||
// without some care, the pointer we are returning here still carries
|
||||
// the tag of `b`, with `Unique` permission.
|
||||
// We round-trip through a mutable reference to avoid that.
|
||||
unsafe { unique.as_mut() as *mut T }
|
||||
}
|
||||
|
||||
/// Consumes the `Box`, returning the wrapped pointer as `NonNull<T>`.
|
||||
|
@ -451,6 +459,7 @@ impl<T: ?Sized> Box<T> {
|
|||
///
|
||||
/// ```
|
||||
/// #![feature(box_into_raw_non_null)]
|
||||
/// #![allow(deprecated)]
|
||||
///
|
||||
/// let x = Box::new(5);
|
||||
/// let ptr = Box::into_raw_non_null(x);
|
||||
|
@ -460,24 +469,24 @@ impl<T: ?Sized> Box<T> {
|
|||
/// let x = unsafe { Box::from_raw(ptr.as_ptr()) };
|
||||
/// ```
|
||||
#[unstable(feature = "box_into_raw_non_null", issue = "47336")]
|
||||
#[rustc_deprecated(
|
||||
since = "1.44.0",
|
||||
reason = "use `Box::leak(b).into()` or `NonNull::from(Box::leak(b))` instead"
|
||||
)]
|
||||
#[inline]
|
||||
pub fn into_raw_non_null(b: Box<T>) -> NonNull<T> {
|
||||
Box::into_unique(b).into()
|
||||
Box::leak(b).into()
|
||||
}
|
||||
|
||||
#[unstable(feature = "ptr_internals", issue = "none", reason = "use into_raw_non_null instead")]
|
||||
#[unstable(
|
||||
feature = "ptr_internals",
|
||||
issue = "none",
|
||||
reason = "use `Box::leak(b).into()` or `NonNull::from(Box::leak(b))` instead"
|
||||
)]
|
||||
#[inline]
|
||||
#[doc(hidden)]
|
||||
pub fn into_unique(b: Box<T>) -> Unique<T> {
|
||||
let b = mem::ManuallyDrop::new(b);
|
||||
let mut unique = b.0;
|
||||
// Box is kind-of a library type, but recognized as a "unique pointer" by
|
||||
// Stacked Borrows. This function here corresponds to "reborrowing to
|
||||
// a raw pointer", but there is no actual reborrow here -- so
|
||||
// without some care, the pointer we are returning here still carries
|
||||
// the tag of `b`, with `Unique` permission.
|
||||
// We round-trip through a mutable reference to avoid that.
|
||||
unsafe { Unique::new_unchecked(unique.as_mut() as *mut T) }
|
||||
Box::leak(b).into()
|
||||
}
|
||||
|
||||
/// Consumes and leaks the `Box`, returning a mutable reference,
|
||||
|
|
|
@ -143,7 +143,7 @@ impl<T> LinkedList<T> {
|
|||
unsafe {
|
||||
node.next = self.head;
|
||||
node.prev = None;
|
||||
let node = Some(Box::into_raw_non_null(node));
|
||||
let node = Some(Box::leak(node).into());
|
||||
|
||||
match self.head {
|
||||
None => self.tail = node,
|
||||
|
@ -184,7 +184,7 @@ impl<T> LinkedList<T> {
|
|||
unsafe {
|
||||
node.next = None;
|
||||
node.prev = self.tail;
|
||||
let node = Some(Box::into_raw_non_null(node));
|
||||
let node = Some(Box::leak(node).into());
|
||||
|
||||
match self.tail {
|
||||
None => self.head = node,
|
||||
|
@ -1133,11 +1133,9 @@ impl<T> IterMut<'_, T> {
|
|||
Some(prev) => prev,
|
||||
};
|
||||
|
||||
let node = Some(Box::into_raw_non_null(box Node {
|
||||
next: Some(head),
|
||||
prev: Some(prev),
|
||||
element,
|
||||
}));
|
||||
let node = Some(
|
||||
Box::leak(box Node { next: Some(head), prev: Some(prev), element }).into(),
|
||||
);
|
||||
|
||||
// Not creating references to entire nodes to not invalidate the
|
||||
// reference to `element` we handed to the user.
|
||||
|
@ -1442,7 +1440,7 @@ impl<'a, T> CursorMut<'a, T> {
|
|||
#[unstable(feature = "linked_list_cursors", issue = "58533")]
|
||||
pub fn insert_after(&mut self, item: T) {
|
||||
unsafe {
|
||||
let spliced_node = Box::into_raw_non_null(Box::new(Node::new(item)));
|
||||
let spliced_node = Box::leak(Box::new(Node::new(item))).into();
|
||||
let node_next = match self.current {
|
||||
None => self.list.head,
|
||||
Some(node) => node.as_ref().next,
|
||||
|
@ -1462,7 +1460,7 @@ impl<'a, T> CursorMut<'a, T> {
|
|||
#[unstable(feature = "linked_list_cursors", issue = "58533")]
|
||||
pub fn insert_before(&mut self, item: T) {
|
||||
unsafe {
|
||||
let spliced_node = Box::into_raw_non_null(Box::new(Node::new(item)));
|
||||
let spliced_node = Box::leak(Box::new(Node::new(item))).into();
|
||||
let node_prev = match self.current {
|
||||
None => self.list.tail,
|
||||
Some(node) => node.as_ref().prev,
|
||||
|
|
|
@ -77,7 +77,6 @@
|
|||
#![feature(allocator_api)]
|
||||
#![feature(allow_internal_unstable)]
|
||||
#![feature(arbitrary_self_types)]
|
||||
#![feature(box_into_raw_non_null)]
|
||||
#![feature(box_patterns)]
|
||||
#![feature(box_syntax)]
|
||||
#![feature(cfg_sanitize)]
|
||||
|
|
|
@ -324,11 +324,9 @@ 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.
|
||||
Self::from_inner(Box::into_raw_non_null(box RcBox {
|
||||
strong: Cell::new(1),
|
||||
weak: Cell::new(1),
|
||||
value,
|
||||
}))
|
||||
Self::from_inner(
|
||||
Box::leak(box RcBox { strong: Cell::new(1), weak: Cell::new(1), value }).into(),
|
||||
)
|
||||
}
|
||||
|
||||
/// Constructs a new `Rc` with uninitialized contents.
|
||||
|
|
|
@ -325,7 +325,7 @@ impl<T> Arc<T> {
|
|||
weak: atomic::AtomicUsize::new(1),
|
||||
data,
|
||||
};
|
||||
Self::from_inner(Box::into_raw_non_null(x))
|
||||
Self::from_inner(Box::leak(x).into())
|
||||
}
|
||||
|
||||
/// Constructs a new `Arc` with uninitialized contents.
|
||||
|
|
Loading…
Reference in New Issue