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/libstd/rt/thread.rs | 21 ++++++++++----------- 1 file changed, 10 insertions(+), 11 deletions(-) (limited to 'src/libstd/rt/thread.rs') diff --git a/src/libstd/rt/thread.rs b/src/libstd/rt/thread.rs index 89d44473a94..4f0d7d35ce8 100644 --- a/src/libstd/rt/thread.rs +++ b/src/libstd/rt/thread.rs @@ -17,9 +17,9 @@ #![allow(non_camel_case_types)] #![allow(unsigned_negate)] -use cast; use kinds::Send; use libc; +use mem; use ops::Drop; use option::{Option, Some, None}; use owned::Box; @@ -46,9 +46,9 @@ extern fn thread_start(main: *libc::c_void) -> imp::rust_thread_return { use rt::stack; unsafe { stack::record_stack_bounds(0, uint::MAX); - let f: Box = cast::transmute(main); + let f: Box = mem::transmute(main); (*f)(); - cast::transmute(0 as imp::rust_thread_return) + mem::transmute(0 as imp::rust_thread_return) } } @@ -83,7 +83,7 @@ impl Thread<()> { // so. let packet = box None; let packet2: *mut Option = unsafe { - *cast::transmute::<&Box>, **mut Option>(&packet) + *mem::transmute::<&Box>, **mut Option>(&packet) }; let main = proc() unsafe { *packet2 = Some(main()); }; let native = unsafe { imp::create(stack, box main) }; @@ -146,7 +146,7 @@ impl Drop for Thread { #[cfg(windows)] mod imp { - use cast; + use mem; use cmp; use kinds::Send; use libc; @@ -161,7 +161,7 @@ mod imp { pub type rust_thread_return = DWORD; pub unsafe fn create(stack: uint, p: Box) -> rust_thread { - let arg: *mut libc::c_void = cast::transmute(p); + let arg: *mut libc::c_void = mem::transmute(p); // FIXME On UNIX, we guard against stack sizes that are too small but // that's because pthreads enforces that stacks are at least // PTHREAD_STACK_MIN bytes big. Windows has no such lower limit, it's @@ -177,7 +177,7 @@ mod imp { if ret as uint == 0 { // be sure to not leak the closure - let _p: Box = cast::transmute(arg); + let _p: Box = mem::transmute(arg); fail!("failed to spawn native thread: {}", os::last_os_error()); } return ret; @@ -213,7 +213,6 @@ mod imp { #[cfg(unix)] mod imp { - use cast; use cmp; use kinds::Send; use libc::consts::os::posix01::{PTHREAD_CREATE_JOINABLE, PTHREAD_STACK_MIN}; @@ -254,13 +253,13 @@ mod imp { }, }; - let arg: *libc::c_void = cast::transmute(p); + let arg: *libc::c_void = mem::transmute(p); let ret = pthread_create(&mut native, &attr, super::thread_start, arg); assert_eq!(pthread_attr_destroy(&mut attr), 0); if ret != 0 { // be sure to not leak the closure - let _p: Box = cast::transmute(arg); + let _p: Box = mem::transmute(arg); fail!("failed to spawn native thread: {}", os::last_os_error()); } native @@ -302,7 +301,7 @@ mod imp { if __pthread_get_minstack.is_null() { PTHREAD_STACK_MIN } else { - unsafe { cast::transmute::<*(), F>(__pthread_get_minstack)(attr) } + unsafe { mem::transmute::<*(), F>(__pthread_get_minstack)(attr) } } } -- cgit 1.4.1-3-g733a5