diff --git a/src/libserialize/ebml.rs b/src/libserialize/ebml.rs index bc9eee517536d..ceb49ec3f3796 100644 --- a/src/libserialize/ebml.rs +++ b/src/libserialize/ebml.rs @@ -401,12 +401,10 @@ pub mod reader { } fn read_f64(&mut self) -> f64 { - let bits = doc_as_u64(self.next_doc(EsF64)); - unsafe { transmute(bits) } + doc_as_u64(self.next_doc(EsF64)) as f64 } fn read_f32(&mut self) -> f32 { - let bits = doc_as_u32(self.next_doc(EsF32)); - unsafe { transmute(bits) } + doc_as_u32(self.next_doc(EsF32)) as f32 } fn read_char(&mut self) -> char { char::from_u32(doc_as_u32(self.next_doc(EsChar))).unwrap() diff --git a/src/libstd/any.rs b/src/libstd/any.rs index 80ead34b68adb..6c3f71fb9fea4 100644 --- a/src/libstd/any.rs +++ b/src/libstd/any.rs @@ -85,7 +85,7 @@ impl<'a> AnyRefExt<'a> for &'a Any { let to: TraitObject = transmute_copy(&self); // Extract the data pointer - Some(transmute(to.data)) + Some(transmute::<*(), &'a T>(to.data)) } } else { None @@ -109,7 +109,7 @@ impl<'a> AnyMutRefExt<'a> for &'a mut Any { let to: TraitObject = transmute_copy(&self); // Extract the data pointer - Some(transmute(to.data)) + Some(transmute::<*(), &'a mut T>(to.data)) } } else { None @@ -136,7 +136,7 @@ impl AnyOwnExt for ~Any { intrinsics::forget(self); // Extract the data pointer - Ok(transmute(to.data)) + Ok(transmute::<*(), ~T>(to.data)) } } else { Err(self) diff --git a/src/libstd/c_str.rs b/src/libstd/c_str.rs index af5d9838186d3..7bba3d53d66fa 100644 --- a/src/libstd/c_str.rs +++ b/src/libstd/c_str.rs @@ -78,8 +78,8 @@ use str::StrSlice; use str; use vec::{ImmutableVector, MutableVector}; use vec; +use raw; use rt::global_heap::malloc_raw; -use raw::Slice; /// The representation of a C String. /// @@ -179,7 +179,7 @@ impl CString { pub fn as_bytes<'a>(&'a self) -> &'a [u8] { if self.buf.is_null() { fail!("CString is null!"); } unsafe { - cast::transmute(Slice { data: self.buf, len: self.len() + 1 }) + raw::slice_from_buf(self.buf as *u8, self.len() + 1) } } @@ -193,7 +193,7 @@ impl CString { pub fn as_bytes_no_nul<'a>(&'a self) -> &'a [u8] { if self.buf.is_null() { fail!("CString is null!"); } unsafe { - cast::transmute(Slice { data: self.buf, len: self.len() }) + raw::slice_from_buf(self.buf as *u8, self.len()) } } diff --git a/src/libstd/c_vec.rs b/src/libstd/c_vec.rs index 00d250a5fc70d..08470c9f8cf7c 100644 --- a/src/libstd/c_vec.rs +++ b/src/libstd/c_vec.rs @@ -33,7 +33,6 @@ //! handled correctly, i.e. that allocated memory is eventually freed //! if necessary. -use cast; use container::Container; use ptr; use ptr::RawPtr; @@ -101,14 +100,14 @@ impl CVec { /// View the stored data as a slice. pub fn as_slice<'a>(&'a self) -> &'a [T] { unsafe { - cast::transmute(raw::Slice { data: self.base as *T, len: self.len }) + raw::slice_from_buf(self.base as *T, self.len) } } /// View the stored data as a mutable slice. pub fn as_mut_slice<'a>(&'a mut self) -> &'a mut [T] { unsafe { - cast::transmute(raw::Slice { data: self.base as *T, len: self.len }) + raw::mut_slice_from_buf(self.base as *mut T, self.len) } } diff --git a/src/libstd/char.rs b/src/libstd/char.rs index 52ca28c4ce890..dfa0d4ab4bd56 100644 --- a/src/libstd/char.rs +++ b/src/libstd/char.rs @@ -87,7 +87,7 @@ pub fn from_u32(i: u32) -> Option { if (i > MAX as u32) || (i >= 0xD800 && i <= 0xDFFF) { None } else { - Some(unsafe { transmute(i) }) + Some(unsafe { transmute::(i) }) } } @@ -277,9 +277,9 @@ pub fn from_digit(num: uint, radix: uint) -> Option { if num < radix { unsafe { if num < 10 { - Some(transmute(('0' as uint + num) as u32)) + Some(transmute::(('0' as uint + num) as u32)) } else { - Some(transmute(('a' as uint + num - 10u) as u32)) + Some(transmute::(('a' as uint + num - 10u) as u32)) } } } else { @@ -304,14 +304,14 @@ fn decompose_hangul(s: char, f: |char|) { let li = si / N_COUNT; unsafe { - f(transmute((L_BASE + li) as u32)); + f(transmute::((L_BASE + li) as u32)); let vi = (si % N_COUNT) / T_COUNT; - f(transmute((V_BASE + vi) as u32)); + f(transmute::((V_BASE + vi) as u32)); let ti = si % T_COUNT; if ti > 0 { - f(transmute((T_BASE + ti) as u32)); + f(transmute::((T_BASE + ti) as u32)); } } } @@ -355,8 +355,8 @@ pub fn escape_unicode(c: char, f: |char|) { for offset in range_step::(4 * (pad - 1), -1, -4) { unsafe { match ((c as i32) >> offset) & 0xf { - i @ 0 .. 9 => { f(transmute('0' as i32 + i)); } - i => { f(transmute('a' as i32 + (i - 10))); } + i @ 0 .. 9 => { f(transmute::('0' as i32 + i)); } + i => { f(transmute::('a' as i32 + (i - 10))); } } } } diff --git a/src/libstd/option.rs b/src/libstd/option.rs index e4d843d88824d..b524ea1b370cb 100644 --- a/src/libstd/option.rs +++ b/src/libstd/option.rs @@ -470,10 +470,10 @@ mod tests { fn test_get_ptr() { unsafe { let x = ~0; - let addr_x: *int = ::cast::transmute(&*x); + let addr_x: *int = &*x as *int; let opt = Some(x); let y = opt.unwrap(); - let addr_y: *int = ::cast::transmute(&*y); + let addr_y: *int = &*y as *int; assert_eq!(addr_x, addr_y); } } diff --git a/src/libstd/raw.rs b/src/libstd/raw.rs index 94ad268f51206..6e42b7184db03 100644 --- a/src/libstd/raw.rs +++ b/src/libstd/raw.rs @@ -82,6 +82,14 @@ impl Repr<*Box> for @T {} impl Repr<*Vec> for ~[T] {} impl Repr<*String> for ~str {} +pub unsafe fn slice_from_buf<'a, T>(data: *T, len: uint) -> &'a [T] { + cast::transmute(Slice { data: data, len: len }) +} + +pub unsafe fn mut_slice_from_buf<'a, T>(data: *mut T, len: uint) -> &'a mut [T] { + cast::transmute(Slice { data: data as *T, len: len }) +} + #[cfg(test)] mod tests { use super::*; diff --git a/src/libstd/unstable/dynamic_lib.rs b/src/libstd/unstable/dynamic_lib.rs index 57dbc045a65fe..f472ccebc2400 100644 --- a/src/libstd/unstable/dynamic_lib.rs +++ b/src/libstd/unstable/dynamic_lib.rs @@ -74,7 +74,7 @@ impl DynamicLibrary { // the destructor does not run. match maybe_symbol_value { Err(err) => Err(err), - Ok(symbol_value) => Ok(cast::transmute(symbol_value)) + Ok(symbol_value) => Ok(cast::transmute::<*u8, T>(symbol_value)) } } } diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs index 8080f57550b3d..04ccfde008754 100644 --- a/src/libstd/vec.rs +++ b/src/libstd/vec.rs @@ -216,7 +216,7 @@ pub fn build(size: Option, builder: |push: |v: A||) -> ~[A] { */ pub fn ref_slice<'a, A>(s: &'a A) -> &'a [A] { unsafe { - transmute(Slice { data: s, len: 1 }) + ::raw::slice_from_buf(s as *A, 1) } } @@ -225,8 +225,7 @@ pub fn ref_slice<'a, A>(s: &'a A) -> &'a [A] { */ pub fn mut_ref_slice<'a, A>(s: &'a mut A) -> &'a mut [A] { unsafe { - let ptr: *A = transmute(s); - transmute(Slice { data: ptr, len: 1 }) + ::raw::mut_slice_from_buf(s as *mut A, 1) } } @@ -991,10 +990,7 @@ impl<'a,T> ImmutableVector<'a, T> for &'a [T] { assert!(start <= end); assert!(end <= self.len()); unsafe { - transmute(Slice { - data: self.as_ptr().offset(start as int), - len: (end - start) - }) + ::raw::slice_from_buf(self.as_ptr().offset(start as int), end - start) } } @@ -1473,8 +1469,7 @@ impl OwnedVector for ~[T] { #[inline] fn capacity(&self) -> uint { unsafe { - let repr: **Vec<()> = transmute(self); - (**repr).alloc / mem::nonzero_size_of::() + (*self.repr()).alloc / mem::nonzero_size_of::() } }