From f94d671bfae5d8e9a4a4add310b1c40af0ab62a6 Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Fri, 9 May 2014 10:34:51 -0700 Subject: core: Remove the cast module This commit revisits the `cast` module in libcore and libstd, and scrutinizes all functions inside of it. The result was to remove the `cast` module entirely, folding all functionality into the `mem` module. Specifically, this is the fate of each function in the `cast` module. * transmute - This function was moved to `mem`, but it is now marked as #[unstable]. This is due to planned changes to the `transmute` function and how it can be invoked (see the #[unstable] comment). For more information, see RFC 5 and #12898 * transmute_copy - This function was moved to `mem`, with clarification that is is not an error to invoke it with T/U that are different sizes, but rather that it is strongly discouraged. This function is now #[stable] * forget - This function was moved to `mem` and marked #[stable] * bump_box_refcount - This function was removed due to the deprecation of managed boxes as well as its questionable utility. * transmute_mut - This function was previously deprecated, and removed as part of this commit. * transmute_mut_unsafe - This function doesn't serve much of a purpose when it can be achieved with an `as` in safe code, so it was removed. * transmute_lifetime - This function was removed because it is likely a strong indication that code is incorrect in the first place. * transmute_mut_lifetime - This function was removed for the same reasons as `transmute_lifetime` * copy_lifetime - This function was moved to `mem`, but it is marked `#[unstable]` now due to the likelihood of being removed in the future if it is found to not be very useful. * copy_mut_lifetime - This function was also moved to `mem`, but had the same treatment as `copy_lifetime`. * copy_lifetime_vec - This function was removed because it is not used today, and its existence is not necessary with DST (copy_lifetime will suffice). In summary, the cast module was stripped down to these functions, and then the functions were moved to the `mem` module. transmute - #[unstable] transmute_copy - #[stable] forget - #[stable] copy_lifetime - #[unstable] copy_mut_lifetime - #[unstable] [breaking-change] --- src/libsync/arc.rs | 6 +++--- src/libsync/mpsc_intrusive.rs | 8 ++++---- src/libsync/raw.rs | 17 ++++++++--------- 3 files changed, 15 insertions(+), 16 deletions(-) (limited to 'src/libsync') diff --git a/src/libsync/arc.rs b/src/libsync/arc.rs index 226eb7afb5f..4dc965d5d84 100644 --- a/src/libsync/arc.rs +++ b/src/libsync/arc.rs @@ -13,7 +13,7 @@ * between tasks. */ -use std::cast; +use std::mem; use std::ptr; use std::rt::heap::exchange_free; use std::sync::atomics; @@ -76,7 +76,7 @@ impl Arc { weak: atomics::AtomicUint::new(1), data: data, }; - Arc { x: unsafe { cast::transmute(x) } } + Arc { x: unsafe { mem::transmute(x) } } } #[inline] @@ -149,7 +149,7 @@ impl Arc { // reference count is guaranteed to be 1 at this point, and we required // the Arc itself to be `mut`, so we're returning the only possible // reference to the inner data. - unsafe { cast::transmute::<&_, &mut _>(self.deref()) } + unsafe { mem::transmute::<&_, &mut _>(self.deref()) } } } diff --git a/src/libsync/mpsc_intrusive.rs b/src/libsync/mpsc_intrusive.rs index 14dfa8417fa..acbb2982c90 100644 --- a/src/libsync/mpsc_intrusive.rs +++ b/src/libsync/mpsc_intrusive.rs @@ -33,7 +33,7 @@ // http://www.1024cores.net/home/lock-free-algorithms // /queues/intrusive-mpsc-node-based-queue -use std::cast; +use std::mem; use std::sync::atomics; use std::ty::Unsafe; @@ -97,7 +97,7 @@ impl Queue { pub unsafe fn pop(&self) -> Option<*mut Node> { let tail = *self.tail.get(); let mut tail = if !tail.is_null() {tail} else { - cast::transmute(&self.stub) + mem::transmute(&self.stub) }; let mut next = (*tail).next(atomics::Relaxed); if tail as uint == &self.stub as *DummyNode as uint { @@ -116,7 +116,7 @@ impl Queue { if tail != head { return None; } - let stub = cast::transmute(&self.stub); + let stub = mem::transmute(&self.stub); self.push(stub); next = (*tail).next(atomics::Relaxed); if !next.is_null() { @@ -135,6 +135,6 @@ impl Node { } } pub unsafe fn next(&self, ord: atomics::Ordering) -> *mut Node { - cast::transmute::>(self.next.load(ord)) + mem::transmute::>(self.next.load(ord)) } } diff --git a/src/libsync/raw.rs b/src/libsync/raw.rs index 313720fa932..990aba3ebff 100644 --- a/src/libsync/raw.rs +++ b/src/libsync/raw.rs @@ -15,9 +15,8 @@ //! `sync` crate which wrap values directly and provide safer abstractions for //! containing data. -use std::cast; use std::kinds::marker; -use std::mem::replace; +use std::mem; use std::sync::atomics; use std::unstable::finally::Finally; @@ -109,7 +108,7 @@ struct SemGuard<'a, Q> { impl Sem { fn new(count: int, q: Q) -> Sem { let inner = unsafe { - cast::transmute(box SemInner { + mem::transmute(box SemInner { waiters: WaitQueue::new(), count: count, blocked: q, @@ -168,7 +167,7 @@ impl Sem { impl Drop for Sem { fn drop(&mut self) { let _waiters: Box> = unsafe { - cast::transmute(self.inner) + mem::transmute(self.inner) }; self.inner = 0 as *(); } @@ -317,8 +316,8 @@ impl<'a> Condvar<'a> { // To avoid :broadcast_heavy, we make a new waitqueue, // swap it out with the old one, and broadcast on the // old one outside of the little-lock. - queue = Some(replace(state.blocked.get_mut(condvar_id), - WaitQueue::new())); + queue = Some(mem::replace(state.blocked.get_mut(condvar_id), + WaitQueue::new())); } else { out_of_bounds = Some(state.blocked.len()); } @@ -578,7 +577,7 @@ impl<'a> RWLockWriteGuard<'a> { let lock = self.lock; // Don't run the destructor of the write guard, we're in charge of // things from now on - unsafe { cast::forget(self) } + unsafe { mem::forget(self) } let old_count = lock.read_count.fetch_add(1, atomics::Release); // If another reader was already blocking, we need to hand-off @@ -626,7 +625,7 @@ mod tests { use arc::Arc; use super::{Semaphore, Mutex, RWLock, Condvar}; - use std::cast; + use std::mem; use std::result; use std::task; @@ -902,7 +901,7 @@ mod tests { let ptr: *int = &*sharedstate; task::spawn(proc() { let sharedstate: &mut int = - unsafe { cast::transmute(ptr) }; + unsafe { mem::transmute(ptr) }; access_shared(sharedstate, &x2, mode1, 10); tx.send(()); }); -- cgit 1.4.1-3-g733a5