clean up some transmutes

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()

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)

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())
         }
     }
 

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<T> CVec<T> {
     /// 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)
         }
     }
 

src/libstd/char.rs

@@ -87,7 +87,7 @@ pub fn from_u32(i: u32) -> Option<char> {
     if (i > MAX as u32) || (i >= 0xD800 && i <= 0xDFFF) {
         None
     } else {
-        Some(unsafe { transmute(i) })
+        Some(unsafe { transmute::<u32, char>(i) })
     }
 }
 
@@ -277,9 +277,9 @@ pub fn from_digit(num: uint, radix: uint) -> Option<char> {
     if num < radix {
         unsafe {
             if num < 10 {
-                Some(transmute(('0' as uint + num) as u32))
+                Some(transmute::<u32, char>(('0' as uint + num) as u32))
             } else {
-                Some(transmute(('a' as uint + num - 10u) as u32))
+                Some(transmute::<u32, char>(('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::<u32, char>((L_BASE + li) as u32));
 
         let vi = (si % N_COUNT) / T_COUNT;
-        f(transmute((V_BASE + vi) as u32));
+        f(transmute::<u32, char>((V_BASE + vi) as u32));
 
         let ti = si % T_COUNT;
         if ti > 0 {
-            f(transmute((T_BASE + ti) as u32));
+            f(transmute::<u32, char>((T_BASE + ti) as u32));
         }
     }
 }
@@ -355,8 +355,8 @@ pub fn escape_unicode(c: char, f: |char|) {
     for offset in range_step::<i32>(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::<i32, char>('0' as i32 + i)); }
+                i => { f(transmute::<i32, char>('a' as i32 + (i - 10))); }
             }
         }
     }

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);
         }
     }

src/libstd/raw.rs

@@ -82,6 +82,14 @@ impl<T> Repr<*Box<T>> for @T {}
 impl<T> Repr<*Vec<T>> 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::*;

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))
         }
     }
 }

src/libstd/vec.rs

@@ -216,7 +216,7 @@ pub fn build<A>(size: Option<uint>, 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<T> OwnedVector<T> for ~[T] {
     #[inline]
     fn capacity(&self) -> uint {
         unsafe {
-            let repr: **Vec<()> = transmute(self);
-            (**repr).alloc / mem::nonzero_size_of::<T>()
+            (*self.repr()).alloc / mem::nonzero_size_of::<T>()
         }
     }