mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rename std::ptr::Shared to NonNull

Browse Source 
`Shared` is now a deprecated `type` alias.

CC https://github.com/rust-lang/rust/issues/27730#issuecomment-352800629
This commit is contained in:
Simon Sapin 2017-12-22 18:58:39 +01:00
parent ba5d7a66e8
commit f19baf0977
13 changed files with 100 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
src/liballoc/arc.rs
View File

@ -25,7 +25,7 @@ use core::intrinsics::abort;
use core::mem::{self, align_of_val, size_of_val, uninitialized};
use core::ops::Deref;
use core::ops::CoerceUnsized;
use core::ptr::{self, Shared};
use core::ptr::{self, NonNull};
use core::marker::{Unsize, PhantomData};
use core::hash::{Hash, Hasher};
use core::{isize, usize};
@ -197,7 +197,7 @@ const MAX_REFCOUNT: usize = (isize::MAX) as usize;
/// [rc_examples]: ../../std/rc/index.html#examples
#[stable(feature = "rust1", since = "1.0.0")]
pub struct Arc<T: ?Sized> {
ptr: Shared<ArcInner<T>>,
ptr: NonNull<ArcInner<T>>,
phantom: PhantomData<T>,
}
@ -234,7 +234,7 @@ impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<Arc<U>> for Arc<T> {}
/// [`None`]: ../../std/option/enum.Option.html#variant.None
#[stable(feature = "arc_weak", since = "1.4.0")]
pub struct Weak<T: ?Sized> {
ptr: Shared<ArcInner<T>>,
ptr: NonNull<ArcInner<T>>,
}
#[stable(feature = "arc_weak", since = "1.4.0")]
@ -286,7 +286,7 @@ impl<T> Arc<T> {
weak: atomic::AtomicUsize::new(1),
data,
};
Arc { ptr: Shared::from(Box::into_unique(x)), phantom: PhantomData }
Arc { ptr: NonNull::from(Box::into_unique(x)), phantom: PhantomData }
}
/// Returns the contained value, if the `Arc` has exactly one strong reference.
@ -397,7 +397,7 @@ impl<T: ?Sized> Arc<T> {
let arc_ptr = set_data_ptr(fake_ptr, (ptr as *mut u8).offset(-offset));
Arc {
ptr: Shared::new_unchecked(arc_ptr),
ptr: NonNull::new_unchecked(arc_ptr),
phantom: PhantomData,
}
}
@ -582,7 +582,7 @@ impl<T: ?Sized> Arc<T> {
// Free the allocation without dropping its contents
box_free(bptr);
Arc { ptr: Shared::new_unchecked(ptr), phantom: PhantomData }
Arc { ptr: NonNull::new_unchecked(ptr), phantom: PhantomData }
}
}
}
@ -609,7 +609,7 @@ impl<T> Arc<[T]> {
&mut (*ptr).data as *mut [T] as *mut T,
v.len());
Arc { ptr: Shared::new_unchecked(ptr), phantom: PhantomData }
Arc { ptr: NonNull::new_unchecked(ptr), phantom: PhantomData }
}
}
@ -669,7 +669,7 @@ impl<T: Clone> ArcFromSlice<T> for Arc<[T]> {
// All clear. Forget the guard so it doesn't free the new ArcInner.
mem::forget(guard);
Arc { ptr: Shared::new_unchecked(ptr), phantom: PhantomData }
Arc { ptr: NonNull::new_unchecked(ptr), phantom: PhantomData }
}
}
}
@ -991,7 +991,7 @@ impl<T> Weak<T> {
pub fn new() -> Weak<T> {
unsafe {
Weak {
ptr: Shared::from(Box::into_unique(box ArcInner {
ptr: NonNull::from(Box::into_unique(box ArcInner {
strong: atomic::AtomicUsize::new(0),
weak: atomic::AtomicUsize::new(1),
data: uninitialized(),

2
src/liballoc/heap.rs
View File

@ -232,7 +232,7 @@ unsafe impl Alloc for Heap {
///
/// This preserves the non-null invariant for types like `Box<T>`. The address
/// may overlap with non-zero-size memory allocations.
#[rustc_deprecated(since = "1.19", reason = "Use Unique/Shared::empty() instead")]
#[rustc_deprecated(since = "1.19", reason = "Use Unique/NonNull::empty() instead")]
#[unstable(feature = "heap_api", issue = "27700")]
pub const EMPTY: *mut () = 1 as *mut ();

2
src/liballoc/lib.rs
View File

@ -103,6 +103,7 @@
#![feature(iter_rfold)]
#![feature(lang_items)]
#![feature(needs_allocator)]
#![feature(nonnull)]
#![feature(nonzero)]
#![feature(offset_to)]
#![feature(optin_builtin_traits)]
@ -110,7 +111,6 @@
#![feature(placement_in_syntax)]
#![feature(placement_new_protocol)]
#![feature(rustc_attrs)]
#![feature(shared)]
#![feature(slice_get_slice)]
#![feature(slice_patterns)]
#![feature(slice_rsplit)]

28
src/liballoc/linked_list.rs
View File

@ -29,7 +29,7 @@ use core::iter::{FromIterator, FusedIterator};
use core::marker::PhantomData;
use core::mem;
use core::ops::{BoxPlace, InPlace, Place, Placer};
use core::ptr::{self, Shared};
use core::ptr::{self, NonNull};
use boxed::{Box, IntermediateBox};
use super::SpecExtend;
@ -44,15 +44,15 @@ use super::SpecExtend;
/// more memory efficient and make better use of CPU cache.
#[stable(feature = "rust1", since = "1.0.0")]
pub struct LinkedList<T> {
head: Option<Shared<Node<T>>>,
tail: Option<Shared<Node<T>>>,
head: Option<NonNull<Node<T>>>,
tail: Option<NonNull<Node<T>>>,
len: usize,
marker: PhantomData<Box<Node<T>>>,
}
struct Node<T> {
next: Option<Shared<Node<T>>>,
prev: Option<Shared<Node<T>>>,
next: Option<NonNull<Node<T>>>,
prev: Option<NonNull<Node<T>>>,
element: T,
}
@ -65,8 +65,8 @@ struct Node<T> {
/// [`LinkedList`]: struct.LinkedList.html
#[stable(feature = "rust1", since = "1.0.0")]
pub struct Iter<'a, T: 'a> {
head: Option<Shared<Node<T>>>,
tail: Option<Shared<Node<T>>>,
head: Option<NonNull<Node<T>>>,
tail: Option<NonNull<Node<T>>>,
len: usize,
marker: PhantomData<&'a Node<T>>,
}
@ -98,8 +98,8 @@ impl<'a, T> Clone for Iter<'a, T> {
#[stable(feature = "rust1", since = "1.0.0")]
pub struct IterMut<'a, T: 'a> {
list: &'a mut LinkedList<T>,
head: Option<Shared<Node<T>>>,
tail: Option<Shared<Node<T>>>,
head: Option<NonNull<Node<T>>>,
tail: Option<NonNull<Node<T>>>,
len: usize,
}
@ -157,7 +157,7 @@ impl<T> LinkedList<T> {
unsafe {
node.next = self.head;
node.prev = None;
let node = Some(Shared::from(Box::into_unique(node)));
let node = Some(NonNull::from(Box::into_unique(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(Shared::from(Box::into_unique(node)));
let node = Some(NonNull::from(Box::into_unique(node)));
match self.tail {
None => self.head = node,
@ -225,7 +225,7 @@ impl<T> LinkedList<T> {
///
/// Warning: this will not check that the provided node belongs to the current list.
#[inline]
unsafe fn unlink_node(&mut self, mut node: Shared<Node<T>>) {
unsafe fn unlink_node(&mut self, mut node: NonNull<Node<T>>) {
let node = node.as_mut();
match node.prev {
@ -986,7 +986,7 @@ impl<'a, T> IterMut<'a, T> {
Some(prev) => prev,
};
let node = Some(Shared::from(Box::into_unique(box Node {
let node = Some(NonNull::from(Box::into_unique(box Node {
next: Some(head),
prev: Some(prev),
element,
@ -1038,7 +1038,7 @@ pub struct DrainFilter<'a, T: 'a, F: 'a>
where F: FnMut(&mut T) -> bool,
{
list: &'a mut LinkedList<T>,
it: Option<Shared<Node<T>>>,
it: Option<NonNull<Node<T>>>,
pred: F,
idx: usize,
old_len: usize,

20
src/liballoc/rc.rs
View File

@ -256,7 +256,7 @@ use core::marker::{Unsize, PhantomData};
use core::mem::{self, align_of_val, forget, size_of_val, uninitialized};
use core::ops::Deref;
use core::ops::CoerceUnsized;
use core::ptr::{self, Shared};
use core::ptr::{self, NonNull};
use core::convert::From;
use heap::{Heap, Alloc, Layout, box_free};
@ -282,7 +282,7 @@ struct RcBox<T: ?Sized> {
/// [get_mut]: #method.get_mut
#[stable(feature = "rust1", since = "1.0.0")]
pub struct Rc<T: ?Sized> {
ptr: Shared<RcBox<T>>,
ptr: NonNull<RcBox<T>>,
phantom: PhantomData<T>,
}
@ -311,7 +311,7 @@ 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: Shared::from(Box::into_unique(box RcBox {
ptr: NonNull::from(Box::into_unique(box RcBox {
strong: Cell::new(1),
weak: Cell::new(1),
value,
@ -428,7 +428,7 @@ impl<T: ?Sized> Rc<T> {
let rc_ptr = set_data_ptr(fake_ptr, (ptr as *mut u8).offset(-offset));
Rc {
ptr: Shared::new_unchecked(rc_ptr),
ptr: NonNull::new_unchecked(rc_ptr),
phantom: PhantomData,
}
}
@ -649,7 +649,7 @@ impl Rc<Any> {
let raw: *const RcBox<Any> = self.ptr.as_ptr();
forget(self);
Ok(Rc {
ptr: Shared::new_unchecked(raw as *const RcBox<T> as *mut _),
ptr: NonNull::new_unchecked(raw as *const RcBox<T> as *mut _),
phantom: PhantomData,
})
}
@ -695,7 +695,7 @@ impl<T: ?Sized> Rc<T> {
// Free the allocation without dropping its contents
box_free(bptr);
Rc { ptr: Shared::new_unchecked(ptr), phantom: PhantomData }
Rc { ptr: NonNull::new_unchecked(ptr), phantom: PhantomData }
}
}
}
@ -722,7 +722,7 @@ impl<T> Rc<[T]> {
&mut (*ptr).value as *mut [T] as *mut T,
v.len());
Rc { ptr: Shared::new_unchecked(ptr), phantom: PhantomData }
Rc { ptr: NonNull::new_unchecked(ptr), phantom: PhantomData }
}
}
@ -781,7 +781,7 @@ impl<T: Clone> RcFromSlice<T> for Rc<[T]> {
// All clear. Forget the guard so it doesn't free the new RcBox.
forget(guard);
Rc { ptr: Shared::new_unchecked(ptr), phantom: PhantomData }
Rc { ptr: NonNull::new_unchecked(ptr), phantom: PhantomData }
}
}
}
@ -1160,7 +1160,7 @@ impl<T> From<Vec<T>> for Rc<[T]> {
/// [`None`]: ../../std/option/enum.Option.html#variant.None
#[stable(feature = "rc_weak", since = "1.4.0")]
pub struct Weak<T: ?Sized> {
ptr: Shared<RcBox<T>>,
ptr: NonNull<RcBox<T>>,
}
#[stable(feature = "rc_weak", since = "1.4.0")]
@ -1190,7 +1190,7 @@ impl<T> Weak<T> {
pub fn new() -> Weak<T> {
unsafe {
Weak {
ptr: Shared::from(Box::into_unique(box RcBox {
ptr: NonNull::from(Box::into_unique(box RcBox {
strong: Cell::new(0),
weak: Cell::new(1),
value: uninitialized(),

10
src/liballoc/vec.rs
View File

@ -78,7 +78,7 @@ use core::num::Float;
use core::ops::{InPlace, Index, IndexMut, Place, Placer};
use core::ops;
use core::ptr;
use core::ptr::Shared;
use core::ptr::NonNull;
use core::slice;
use borrow::ToOwned;
@ -1124,7 +1124,7 @@ impl<T> Vec<T> {
tail_start: end,
tail_len: len - end,
iter: range_slice.iter(),
vec: Shared::from(self),
vec: NonNull::from(self),
}
}
}
@ -1745,7 +1745,7 @@ impl<T> IntoIterator for Vec<T> {
let cap = self.buf.cap();
mem::forget(self);
IntoIter {
buf: Shared::new_unchecked(begin),
buf: NonNull::new_unchecked(begin),
phantom: PhantomData,
cap,
ptr: begin,
@ -2267,7 +2267,7 @@ impl<'a, T> FromIterator<T> for Cow<'a, [T]> where T: Clone {
/// [`IntoIterator`]: ../../std/iter/trait.IntoIterator.html
#[stable(feature = "rust1", since = "1.0.0")]
pub struct IntoIter<T> {
buf: Shared<T>,
buf: NonNull<T>,
phantom: PhantomData<T>,
cap: usize,
ptr: *const T,
@ -2442,7 +2442,7 @@ pub struct Drain<'a, T: 'a> {
tail_len: usize,
/// Current remaining range to remove
iter: slice::Iter<'a, T>,
vec: Shared<Vec<T>>,
vec: NonNull<Vec<T>>,
}
#[stable(feature = "collection_debug", since = "1.17.0")]

6
src/liballoc/vec_deque.rs
View File

@ -23,7 +23,7 @@ use core::iter::{repeat, FromIterator, FusedIterator};
use core::mem;
use core::ops::{Index, IndexMut, Place, Placer, InPlace};
use core::ptr;
use core::ptr::Shared;
use core::ptr::NonNull;
use core::slice;
use core::hash::{Hash, Hasher};
@ -895,7 +895,7 @@ impl<T> VecDeque<T> {
self.head = drain_tail;
Drain {
deque: Shared::from(&mut *self),
deque: NonNull::from(&mut *self),
after_tail: drain_head,
after_head: head,
iter: Iter {
@ -2154,7 +2154,7 @@ pub struct Drain<'a, T: 'a> {
after_tail: usize,
after_head: usize,
iter: Iter<'a, T>,
deque: Shared<VecDeque<T>>,
deque: NonNull<VecDeque<T>>,
}
#[stable(feature = "collection_debug", since = "1.17.0")]

87
src/libcore/ptr.rs
View File

@ -2321,7 +2321,7 @@ impl<T: ?Sized> PartialOrd for *mut T {
/// its owning Unique.
///
/// If you're uncertain of whether it's correct to use `Unique` for your purposes,
/// consider using `Shared`, which has weaker semantics.
/// consider using `NonNull`, which has weaker semantics.
///
/// Unlike `*mut T`, the pointer must always be non-null, even if the pointer
/// is never dereferenced. This is so that enums may use this forbidden value
@ -2452,18 +2452,23 @@ impl<'a, T: ?Sized> From<&'a T> for Unique<T> {
}
}
/// Previous name of `NonNull`.
#[rustc_deprecated(since = "1.24", reason = "renamed to `NonNull`")]
#[unstable(feature = "shared", issue = "27730")]
pub type Shared<T> = NonNull<T>;
/// `*mut T` but non-zero and covariant.
///
/// This is often the correct thing to use when building data structures using
/// raw pointers, but is ultimately more dangerous to use because of its additional
/// properties. If you're not sure if you should use `Shared<T>`, just use `*mut T`!
/// properties. If you're not sure if you should use `NonNull<T>`, just use `*mut T`!
///
/// Unlike `*mut T`, the pointer must always be non-null, even if the pointer
/// is never dereferenced. This is so that enums may use this forbidden value
/// as a discriminant -- `Option<Shared<T>>` has the same size as `Shared<T>`.
/// as a discriminant -- `Option<NonNull<T>>` has the same size as `NonNull<T>`.
/// However the pointer may still dangle if it isn't dereferenced.
///
/// Unlike `*mut T`, `Shared<T>` is covariant over `T`. If this is incorrect
/// Unlike `*mut T`, `NonNull<T>` is covariant over `T`. If this is incorrect
/// for your use case, you should include some PhantomData in your type to
/// provide invariance, such as `PhantomData<Cell<T>>` or `PhantomData<&'a mut T>`.
/// Usually this won't be necessary; covariance is correct for most safe abstractions,
@ -2471,56 +2476,56 @@ impl<'a, T: ?Sized> From<&'a T> for Unique<T> {
/// 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")]
pub struct Shared<T: ?Sized> {
pub struct NonNull<T: ?Sized> {
pointer: NonZero<*const T>,
}
#[unstable(feature = "shared", issue = "27730")]
impl<T: ?Sized> fmt::Debug for Shared<T> {
impl<T: ?Sized> fmt::Debug for NonNull<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{:p}", self.as_ptr())
}
}
/// `Shared` pointers are not `Send` because the data they reference may be aliased.
/// `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 = "shared", issue = "27730")]
impl<T: ?Sized> !Send for Shared<T> { }
#[unstable(feature = "nonnull", issue = "27730")]
impl<T: ?Sized> !Send for NonNull<T> { }
/// `Shared` pointers are not `Sync` because the data they reference may be aliased.
/// `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 = "shared", issue = "27730")]
impl<T: ?Sized> !Sync for Shared<T> { }
#[unstable(feature = "nonnull", issue = "27730")]
impl<T: ?Sized> !Sync for NonNull<T> { }
#[unstable(feature = "shared", issue = "27730")]
impl<T: Sized> Shared<T> {
/// Creates a new `Shared` that is dangling, but well-aligned.
#[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.
pub fn empty() -> Self {
unsafe {
let ptr = mem::align_of::<T>() as *mut T;
Shared::new_unchecked(ptr)
NonNull::new_unchecked(ptr)
}
}
}
#[unstable(feature = "shared", issue = "27730")]
impl<T: ?Sized> Shared<T> {
/// Creates a new `Shared`.
#[unstable(feature = "nonnull", issue = "27730")]
impl<T: ?Sized> NonNull<T> {
/// Creates a new `NonNull`.
///
/// # Safety
///
/// `ptr` must be non-null.
#[unstable(feature = "shared", issue = "27730")]
#[unstable(feature = "nonnull", issue = "27730")]
pub const unsafe fn new_unchecked(ptr: *mut T) -> Self {
Shared { pointer: NonZero::new_unchecked(ptr) }
NonNull { pointer: NonZero::new_unchecked(ptr) }
}
/// Creates a new `Shared` if `ptr` is non-null.
/// Creates a new `NonNull` if `ptr` is non-null.
pub fn new(ptr: *mut T) -> Option<Self> {
NonZero::new(ptr as *const T).map(|nz| Shared { pointer: nz })
NonZero::new(ptr as *const T).map(|nz| NonNull { pointer: nz })
}
/// Acquires the underlying `*mut` pointer.
@ -2548,49 +2553,49 @@ impl<T: ?Sized> Shared<T> {
/// Acquires the underlying pointer as a `*mut` pointer.
#[rustc_deprecated(since = "1.19", reason = "renamed to `as_ptr` for ergonomics/consistency")]
#[unstable(feature = "shared", issue = "27730")]
#[unstable(feature = "nonnull", issue = "27730")]
pub unsafe fn as_mut_ptr(&self) -> *mut T {
self.as_ptr()
}
}
#[unstable(feature = "shared", issue = "27730")]
impl<T: ?Sized> Clone for Shared<T> {
#[unstable(feature = "nonnull", issue = "27730")]
impl<T: ?Sized> Clone for NonNull<T> {
fn clone(&self) -> Self {
*self
}
}
#[unstable(feature = "shared", issue = "27730")]
impl<T: ?Sized> Copy for Shared<T> { }
#[unstable(feature = "nonnull", issue = "27730")]
impl<T: ?Sized> Copy for NonNull<T> { }
#[unstable(feature = "shared", issue = "27730")]
impl<T: ?Sized, U: ?Sized> CoerceUnsized<Shared<U>> for Shared<T> where T: Unsize<U> { }
#[unstable(feature = "nonnull", issue = "27730")]
impl<T: ?Sized, U: ?Sized> CoerceUnsized<NonNull<U>> for NonNull<T> where T: Unsize<U> { }
#[unstable(feature = "shared", issue = "27730")]
impl<T: ?Sized> fmt::Pointer for Shared<T> {
#[unstable(feature = "nonnull", issue = "27730")]
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 = "shared", issue = "27730")]
impl<T: ?Sized> From<Unique<T>> for Shared<T> {
#[unstable(feature = "nonnull", issue = "27730")]
impl<T: ?Sized> From<Unique<T>> for NonNull<T> {
fn from(unique: Unique<T>) -> Self {
Shared { pointer: unique.pointer }
NonNull { pointer: unique.pointer }
}
}
#[unstable(feature = "shared", issue = "27730")]
impl<'a, T: ?Sized> From<&'a mut T> for Shared<T> {
#[unstable(feature = "nonnull", issue = "27730")]
impl<'a, T: ?Sized> From<&'a mut T> for NonNull<T> {
fn from(reference: &'a mut T) -> Self {
Shared { pointer: NonZero::from(reference) }
NonNull { pointer: NonZero::from(reference) }
}
}
#[unstable(feature = "shared", issue = "27730")]
impl<'a, T: ?Sized> From<&'a T> for Shared<T> {
#[unstable(feature = "nonnull", issue = "27730")]
impl<'a, T: ?Sized> From<&'a T> for NonNull<T> {
fn from(reference: &'a T) -> Self {
Shared { pointer: NonZero::from(reference) }
NonNull { pointer: NonZero::from(reference) }
}
}

6
src/librustc_data_structures/array_vec.rs
View File

@ -12,7 +12,7 @@
use std::marker::Unsize;
use std::iter::Extend;
use std::ptr::{self, drop_in_place, Shared};
use std::ptr::{self, drop_in_place, NonNull};
use std::ops::{Deref, DerefMut, Range};
use std::hash::{Hash, Hasher};
use std::slice;
@ -146,7 +146,7 @@ impl<A: Array> ArrayVec<A> {
tail_start: end,
tail_len: len - end,
iter: range_slice.iter(),
array_vec: Shared::from(self),
array_vec: NonNull::from(self),
}
}
}
@ -232,7 +232,7 @@ pub struct Drain<'a, A: Array>
tail_start: usize,
tail_len: usize,
iter: slice::Iter<'a, ManuallyDrop<A::Element>>,
array_vec: Shared<ArrayVec<A>>,
array_vec: NonNull<ArrayVec<A>>,
}
impl<'a, A: Array> Iterator for Drain<'a, A> {

2
src/librustc_data_structures/lib.rs
View File

@ -21,8 +21,8 @@
html_root_url = "https://doc.rust-lang.org/nightly/")]
#![deny(warnings)]
#![feature(shared)]
#![feature(collections_range)]
#![feature(nonnull)]
#![feature(nonzero)]
#![feature(unboxed_closures)]
#![feature(fn_traits)]

6
src/libstd/collections/hash/table.rs
View File

@ -16,7 +16,7 @@ use marker;
use mem::{align_of, size_of, needs_drop};
use mem;
use ops::{Deref, DerefMut};
use ptr::{self, Unique, Shared};
use ptr::{self, Unique, NonNull};
use self::BucketState::*;
@ -873,7 +873,7 @@ impl<K, V> RawTable<K, V> {
elems_left,
marker: marker::PhantomData,
},
table: Shared::from(self),
table: NonNull::from(self),
marker: marker::PhantomData,
}
}
@ -1020,7 +1020,7 @@ impl<K, V> IntoIter<K, V> {
/// Iterator over the entries in a table, clearing the table.
pub struct Drain<'a, K: 'a, V: 'a> {
table: Shared<RawTable<K, V>>,
table: NonNull<RawTable<K, V>>,
iter: RawBuckets<'static, K, V>,
marker: marker::PhantomData<&'a RawTable<K, V>>,
}

2
src/libstd/lib.rs
View File

@ -283,6 +283,7 @@
#![feature(macro_vis_matcher)]
#![feature(needs_panic_runtime)]
#![feature(never_type)]
#![feature(nonnull)]
#![feature(num_bits_bytes)]
#![feature(old_wrapping)]
#![feature(on_unimplemented)]
@ -297,7 +298,6 @@
#![feature(raw)]
#![feature(repr_align)]
#![feature(rustc_attrs)]
#![feature(shared)]
#![feature(sip_hash_13)]
#![feature(slice_bytes)]
#![feature(slice_concat_ext)]

6
src/libstd/panic.rs
View File

@ -17,7 +17,7 @@ use cell::UnsafeCell;
use fmt;
use ops::{Deref, DerefMut};
use panicking;
use ptr::{Unique, Shared};
use ptr::{Unique, NonNull};
use rc::Rc;
use sync::{Arc, Mutex, RwLock, atomic};
use thread::Result;
@ -198,8 +198,8 @@ impl<T: RefUnwindSafe + ?Sized> UnwindSafe for *const T {}
impl<T: RefUnwindSafe + ?Sized> UnwindSafe for *mut T {}
#[unstable(feature = "unique", issue = "27730")]
impl<T: UnwindSafe + ?Sized> UnwindSafe for Unique<T> {}
#[unstable(feature = "shared", issue = "27730")]
impl<T: RefUnwindSafe + ?Sized> UnwindSafe for Shared<T> {}
#[unstable(feature = "nonnull", issue = "27730")]
impl<T: RefUnwindSafe + ?Sized> UnwindSafe for NonNull<T> {}
#[stable(feature = "catch_unwind", since = "1.9.0")]
impl<T: ?Sized> UnwindSafe for Mutex<T> {}
#[stable(feature = "catch_unwind", since = "1.9.0")]