user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rename {NonZero,Shared,Unique}::new to new_unchecked

Browse source
This commit is contained in:
Simon Sapin 2017-06-29 01:03:35 +02:00
parent e9af03a222
commit 0a08ad0443
20 changed files with 47 additions and 47 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/liballoc/allocator.rs
View file

@ -892,7 +892,7 @@ pub unsafe trait Alloc {
{
let k = Layout::new::<T>();
if k.size() > 0 {
unsafe { self.alloc(k).map(|p| Unique::new(p as *mut T)) }
unsafe { self.alloc(k).map(|p| Unique::new_unchecked(p as *mut T)) }
} else {
Err(AllocErr::invalid_input("zero-sized type invalid for alloc_one"))
}
@ -963,7 +963,7 @@ pub unsafe trait Alloc {
unsafe {
self.alloc(layout.clone())
.map(|p| {
Unique::new(p as *mut T)
Unique::new_unchecked(p as *mut T)
})
}
}
@ -1012,7 +1012,7 @@ pub unsafe trait Alloc {
match (Layout::array::<T>(n_old), Layout::array::<T>(n_new), ptr.as_ptr()) {
(Some(ref k_old), Some(ref k_new), ptr) if k_old.size() > 0 && k_new.size() > 0 => {
self.realloc(ptr as *mut u8, k_old.clone(), k_new.clone())
.map(|p|Unique::new(p as *mut T))
.map(|p|Unique::new_unchecked(p as *mut T))
}
_ => {
Err(AllocErr::invalid_input("invalid layout for realloc_array"))

6
src/liballoc/arc.rs
View file

@ -280,7 +280,7 @@ impl<T> Arc<T> {
weak: atomic::AtomicUsize::new(1),
data: data,
};
Arc { ptr: unsafe { Shared::new(Box::into_raw(x)) } }
Arc { ptr: unsafe { Shared::new_unchecked(Box::into_raw(x)) } }
}
/// Returns the contained value, if the `Arc` has exactly one strong reference.
@ -382,7 +382,7 @@ impl<T> Arc<T> {
// `data` field from the pointer.
let ptr = (ptr as *const u8).offset(-offset_of!(ArcInner<T>, data));
Arc {
ptr: Shared::new(ptr as *mut u8 as *mut _),
ptr: Shared::new_unchecked(ptr as *mut u8 as *mut _),
}
}
}
@ -842,7 +842,7 @@ impl<T> Weak<T> {
pub fn new() -> Weak<T> {
unsafe {
Weak {
ptr: Shared::new(Box::into_raw(box ArcInner {
ptr: Shared::new_unchecked(Box::into_raw(box ArcInner {
strong: atomic::AtomicUsize::new(0),
weak: atomic::AtomicUsize::new(1),
data: uninitialized(),

10
src/liballoc/btree/node.rs
View file

@ -141,23 +141,23 @@ struct BoxedNode<K, V> {
impl<K, V> BoxedNode<K, V> {
fn from_leaf(node: Box<LeafNode<K, V>>) -> Self {
unsafe {
BoxedNode { ptr: Unique::new(Box::into_raw(node)) }
BoxedNode { ptr: Unique::new_unchecked(Box::into_raw(node)) }
}
}
fn from_internal(node: Box<InternalNode<K, V>>) -> Self {
unsafe {
BoxedNode { ptr: Unique::new(Box::into_raw(node) as *mut LeafNode<K, V>) }
BoxedNode { ptr: Unique::new_unchecked(Box::into_raw(node) as *mut LeafNode<K, V>) }
}
}
unsafe fn from_ptr(ptr: NonZero<*const LeafNode<K, V>>) -> Self {
BoxedNode { ptr: Unique::new(ptr.get() as *mut LeafNode<K, V>) }
BoxedNode { ptr: Unique::new_unchecked(ptr.get() as *mut LeafNode<K, V>) }
}
fn as_ptr(&self) -> NonZero<*const LeafNode<K, V>> {
unsafe {
NonZero::new(self.ptr.as_ptr())
NonZero::new_unchecked(self.ptr.as_ptr())
}
}
}
@ -391,7 +391,7 @@ impl<BorrowType, K, V, Type> NodeRef<BorrowType, K, V, Type> {
node: NodeRef {
height: self.height + 1,
node: unsafe {
NonZero::new(self.as_leaf().parent as *mut LeafNode<K, V>)
NonZero::new_unchecked(self.as_leaf().parent as *mut LeafNode<K, V>)
},
root: self.root,
_marker: PhantomData

6
src/liballoc/linked_list.rs
View file

@ -157,7 +157,7 @@ impl<T> LinkedList<T> {
unsafe {
node.next = self.head;
node.prev = None;
let node = Some(Shared::new(Box::into_raw(node)));
let node = Some(Shared::new_unchecked(Box::into_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(Shared::new(Box::into_raw(node)));
let node = Some(Shared::new_unchecked(Box::into_raw(node)));
match self.tail {
None => self.head = node,
@ -921,7 +921,7 @@ impl<'a, T> IterMut<'a, T> {
Some(prev) => prev,
};
let node = Some(Shared::new(Box::into_raw(box Node {
let node = Some(Shared::new_unchecked(Box::into_raw(box Node {
next: Some(head),
prev: Some(prev),
element: element,

6
src/liballoc/raw_vec.rs
View file

@ -104,7 +104,7 @@ impl<T, A: Alloc> RawVec<T, A> {
};
RawVec {
ptr: Unique::new(ptr as *mut _),
ptr: Unique::new_unchecked(ptr as *mut _),
cap: cap,
a: a,
}
@ -159,7 +159,7 @@ impl<T, A: Alloc> RawVec<T, A> {
/// If the ptr and capacity come from a RawVec created via `a`, then this is guaranteed.
pub unsafe fn from_raw_parts_in(ptr: *mut T, cap: usize, a: A) -> Self {
RawVec {
ptr: Unique::new(ptr),
ptr: Unique::new_unchecked(ptr),
cap: cap,
a: a,
}
@ -176,7 +176,7 @@ impl<T> RawVec<T, Heap> {
/// If the ptr and capacity come from a RawVec, then this is guaranteed.
pub unsafe fn from_raw_parts(ptr: *mut T, cap: usize) -> Self {
RawVec {
ptr: Unique::new(ptr),
ptr: Unique::new_unchecked(ptr),
cap: cap,
a: Heap,
}

10
src/liballoc/rc.rs
View file

@ -309,7 +309,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::new(Box::into_raw(box RcBox {
ptr: Shared::new_unchecked(Box::into_raw(box RcBox {
strong: Cell::new(1),
weak: Cell::new(1),
value: value,
@ -418,7 +418,7 @@ impl<T> Rc<T> {
let ptr = (ptr as *const u8).offset(-offset_of!(RcBox<T>, value));
Rc {
ptr: Shared::new(ptr as *mut u8 as *mut _)
ptr: Shared::new_unchecked(ptr as *mut u8 as *mut _)
}
}
}
@ -443,7 +443,7 @@ impl Rc<str> {
// Combine the allocation address and the string length into a fat pointer to `RcBox`.
let rcbox_ptr: *mut RcBox<str> = mem::transmute([ptr as usize, value.len()]);
assert!(aligned_len * size_of::<usize>() == size_of_val(&*rcbox_ptr));
Rc { ptr: Shared::new(rcbox_ptr) }
Rc { ptr: Shared::new_unchecked(rcbox_ptr) }
}
}
}
@ -476,7 +476,7 @@ impl<T> Rc<[T]> {
// Free the original allocation without freeing its (moved) contents.
box_free(Box::into_raw(value));
Rc { ptr: Shared::new(ptr as *mut _) }
Rc { ptr: Shared::new_unchecked(ptr as *mut _) }
}
}
}
@ -1016,7 +1016,7 @@ impl<T> Weak<T> {
pub fn new() -> Weak<T> {
unsafe {
Weak {
ptr: Shared::new(Box::into_raw(box RcBox {
ptr: Shared::new_unchecked(Box::into_raw(box RcBox {
strong: Cell::new(0),
weak: Cell::new(1),
value: uninitialized(),

4
src/liballoc/vec.rs
View file

@ -1126,7 +1126,7 @@ impl<T> Vec<T> {
tail_start: end,
tail_len: len - end,
iter: range_slice.iter(),
vec: Shared::new(self as *mut _),
vec: Shared::new_unchecked(self as *mut _),
}
}
}
@ -1727,7 +1727,7 @@ impl<T> IntoIterator for Vec<T> {
let cap = self.buf.cap();
mem::forget(self);
IntoIter {
buf: Shared::new(begin),
buf: Shared::new_unchecked(begin),
cap: cap,
ptr: begin,
end: end,

2
src/liballoc/vec_deque.rs
View file

@ -893,7 +893,7 @@ impl<T> VecDeque<T> {
self.head = drain_tail;
Drain {
deque: unsafe { Shared::new(self as *mut _) },
deque: unsafe { Shared::new_unchecked(self as *mut _) },
after_tail: drain_head,
after_head: head,
iter: Iter {