Replace many transmutes with casts or safe code

nvzqz · nvzqz · commit 90a17e949c0b · 2018-01-07T17:08:01.000-05:00
diff --git a/src/bootstrap/cache.rs b/src/bootstrap/cache.rs
@@ -17,7 +17,6 @@ use std::ffi::OsStr;
 use std::fmt;
 use std::hash::{Hash, Hasher};
 use std::marker::PhantomData;
-use std::mem;
 use std::ops::Deref;
 use std::path::{Path, PathBuf};
 use std::sync::Mutex;
@@ -114,43 +113,47 @@ impl Deref for Interned<String> {
     type Target = str;
     fn deref(&self) -> &'static str {
         let l = INTERNER.strs.lock().unwrap();
-        unsafe { mem::transmute::<&str, &'static str>(l.get(*self)) }
+        let s: &str = l.get(*self).as_ref();
+        unsafe { &*(s *const _) }
     }
 }
 
 impl Deref for Interned<PathBuf> {
     type Target = Path;
     fn deref(&self) -> &'static Path {
         let l = INTERNER.paths.lock().unwrap();
-        unsafe { mem::transmute::<&Path, &'static Path>(l.get(*self)) }
+        let p: &Path = l.get(*self).as_ref();
+        unsafe { &*(p *const _) }
     }
 }
 
 impl AsRef<Path> for Interned<PathBuf> {
     fn as_ref(&self) -> &'static Path {
-        let l = INTERNER.paths.lock().unwrap();
-        unsafe { mem::transmute::<&Path, &'static Path>(l.get(*self)) }
+        &*self
     }
 }
 
 impl AsRef<Path> for Interned<String> {
     fn as_ref(&self) -> &'static Path {
         let l = INTERNER.strs.lock().unwrap();
-        unsafe { mem::transmute::<&Path, &'static Path>(l.get(*self).as_ref()) }
+        let p: &Path = l.get(*self).as_ref();
+        unsafe { &*(p *const _) }
     }
 }
 
 impl AsRef<OsStr> for Interned<PathBuf> {
     fn as_ref(&self) -> &'static OsStr {
         let l = INTERNER.paths.lock().unwrap();
-        unsafe { mem::transmute::<&OsStr, &'static OsStr>(l.get(*self).as_ref()) }
+        let s: &OsStr = l.get(*self).as_ref();
+        unsafe { &*(s *const _) }
     }
 }
 
 impl AsRef<OsStr> for Interned<String> {
     fn as_ref(&self) -> &'static OsStr {
         let l = INTERNER.strs.lock().unwrap();
-        unsafe { mem::transmute::<&OsStr, &'static OsStr>(l.get(*self).as_ref()) }
+        let s: &OsStr = l.get(*self).as_ref();
+        unsafe { &*(s *const _) }
     }
 }
 
diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs
@@ -46,7 +46,6 @@ use std::ops::Deref;
 use std::rc::Rc;
 use std::slice;
 use std::vec::IntoIter;
-use std::mem;
 use syntax::ast::{self, DUMMY_NODE_ID, Name, Ident, NodeId};
 use syntax::attr;
 use syntax::ext::hygiene::{Mark, SyntaxContext};
@@ -592,7 +591,8 @@ impl<'tcx> serialize::UseSpecializedDecodable for &'tcx Slice<Ty<'tcx>> {}
 impl<T> Slice<T> {
     pub fn empty<'a>() -> &'a Slice<T> {
         unsafe {
-            mem::transmute(slice::from_raw_parts(0x1 as *const T, 0))
+            let slice = slice::from_raw_parts(0x1 as *const T, 0);
+            &*(slice as *const [T] as *const Slice<T>)
         }
     }
 }
diff --git a/src/librustc_data_structures/blake2b.rs b/src/librustc_data_structures/blake2b.rs
@@ -128,8 +128,7 @@ fn blake2b_compress(ctx: &mut Blake2bCtx, last: bool) {
         // before it's overwritten.
 
         let m: &mut [u64; 16] = unsafe {
-            let b: &mut [u8; 128] = &mut ctx.b;
-            ::std::mem::transmute(b)
+            &*(&mut ctx.b as *mut [u8; 128] as *mut [u64; 16])
         };
 
         if cfg!(target_endian = "big") {
diff --git a/src/librustc_data_structures/stable_hasher.rs b/src/librustc_data_structures/stable_hasher.rs
@@ -241,21 +241,15 @@ impl<CTX> HashStable<CTX> for f32 {
     fn hash_stable<W: StableHasherResult>(&self,
                                           ctx: &mut CTX,
                                           hasher: &mut StableHasher<W>) {
-        let val: u32 = unsafe {
-            ::std::mem::transmute(*self)
-        };
-        val.hash_stable(ctx, hasher);
+        self.to_bits().hash_stable(ctx, hasher);
     }
 }
 
 impl<CTX> HashStable<CTX> for f64 {
     fn hash_stable<W: StableHasherResult>(&self,
                                           ctx: &mut CTX,
                                           hasher: &mut StableHasher<W>) {
-        let val: u64 = unsafe {
-            ::std::mem::transmute(*self)
-        };
-        val.hash_stable(ctx, hasher);
+        self.to_bits().hash_stable(ctx, hasher);
     }
 }
 
diff --git a/src/librustc_trans/type_.rs b/src/librustc_trans/type_.rs
@@ -21,7 +21,6 @@ use rustc::ty::layout::{self, Align, Size};
 
 use std::ffi::CString;
 use std::fmt;
-use std::mem;
 use std::ptr;
 
 use libc::c_uint;
@@ -59,7 +58,7 @@ impl Type {
     }
 
     pub fn to_ref_slice(slice: &[Type]) -> &[TypeRef] {
-        unsafe { mem::transmute(slice) }
+        unsafe { &*(slice as *const [Type] as *const [TypeRef]) }
     }
 
     pub fn void(ccx: &CrateContext) -> Type {
diff --git a/src/libstd/error.rs b/src/libstd/error.rs
@@ -59,7 +59,6 @@ use char;
 use convert;
 use core::array;
 use fmt::{self, Debug, Display};
-use mem::transmute;
 use num;
 use str;
 use string;
@@ -491,11 +490,11 @@ impl Error + Send {
     #[stable(feature = "error_downcast", since = "1.3.0")]
     /// Attempt to downcast the box to a concrete type.
     pub fn downcast<T: Error + 'static>(self: Box<Self>)
-                                        -> Result<Box<T>, Box<Error + Send>> {
+                                        -> Result<Box<T>, Box<Self>> {
         let err: Box<Error> = self;
         <Error>::downcast(err).map_err(|s| unsafe {
             // reapply the Send marker
-            transmute::<Box<Error>, Box<Error + Send>>(s)
+            Box::from_raw(Box::into_raw(s) as *mut Self)
         })
     }
 }
@@ -509,7 +508,7 @@ impl Error + Send + Sync {
         let err: Box<Error> = self;
         <Error>::downcast(err).map_err(|s| unsafe {
             // reapply the Send+Sync marker
-            transmute::<Box<Error>, Box<Error + Send + Sync>>(s)
+            Box::from_raw(Box::into_raw(s) as *mut Self)
         })
     }
 }
diff --git a/src/libstd/sys/redox/args.rs b/src/libstd/sys/redox/args.rs
@@ -57,7 +57,6 @@ impl DoubleEndedIterator for Args {
 
 mod imp {
     use os::unix::prelude::*;
-    use mem;
     use ffi::{CStr, OsString};
     use marker::PhantomData;
     use libc;
@@ -105,7 +104,7 @@ mod imp {
     }
 
     fn get_global_ptr() -> *mut Option<Box<Vec<Vec<u8>>>> {
-        unsafe { mem::transmute(&GLOBAL_ARGS_PTR) }
+        unsafe { &mut GLOBAL_ARGS_PTR as *mut _ as *mut _ }
     }
 
 }
diff --git a/src/libstd/sys/redox/ext/ffi.rs b/src/libstd/sys/redox/ext/ffi.rs
@@ -13,7 +13,6 @@
 #![stable(feature = "rust1", since = "1.0.0")]
 
 use ffi::{OsStr, OsString};
-use mem;
 use sys::os_str::Buf;
 use sys_common::{FromInner, IntoInner, AsInner};
 
@@ -53,7 +52,7 @@ pub trait OsStrExt {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl OsStrExt for OsStr {
     fn from_bytes(slice: &[u8]) -> &OsStr {
-        unsafe { mem::transmute(slice) }
+        unsafe { &*(slice as *const [u8] as *const OsStr) }
     }
     fn as_bytes(&self) -> &[u8] {
         &self.as_inner().inner
diff --git a/src/libstd/sys/redox/os_str.rs b/src/libstd/sys/redox/os_str.rs
@@ -14,7 +14,6 @@
 use borrow::Cow;
 use fmt;
 use str;
-use mem;
 use rc::Rc;
 use sync::Arc;
 use sys_common::{AsInner, IntoInner};
@@ -105,7 +104,7 @@ impl Buf {
     }
 
     pub fn as_slice(&self) -> &Slice {
-        unsafe { mem::transmute(&*self.inner) }
+        &*(&*self.inner as *const [u8] as *const Slice)
     }
 
     pub fn into_string(self) -> Result<String, Buf> {
@@ -118,12 +117,13 @@ impl Buf {
 
     #[inline]
     pub fn into_box(self) -> Box<Slice> {
-        unsafe { mem::transmute(self.inner.into_boxed_slice()) }
+        let boxed = self.inner.into_boxed_slice();
+        unsafe { Box::from_raw(Box::into_raw(boxed) as *mut Slice) }
     }
 
     #[inline]
     pub fn from_box(boxed: Box<Slice>) -> Buf {
-        let inner: Box<[u8]> = unsafe { mem::transmute(boxed) };
+        let inner = unsafe { Box::from_raw(Box::into_raw(boxed) as *mut [u8]) };
         Buf { inner: inner.into_vec() }
     }
 
@@ -140,7 +140,7 @@ impl Buf {
 
 impl Slice {
     fn from_u8_slice(s: &[u8]) -> &Slice {
-        unsafe { mem::transmute(s) }
+        unsafe { &*(s as *const [u8] as *const Slice) }
     }
 
     pub fn from_str(s: &str) -> &Slice {
@@ -162,12 +162,12 @@ impl Slice {
     #[inline]
     pub fn into_box(&self) -> Box<Slice> {
         let boxed: Box<[u8]> = self.inner.into();
-        unsafe { mem::transmute(boxed) }
+        unsafe { Box::from_raw(Box::into_raw(boxed) as *mut Slice) }
     }
 
     pub fn empty_box() -> Box<Slice> {
         let boxed: Box<[u8]> = Default::default();
-        unsafe { mem::transmute(boxed) }
+        unsafe { Box::from_raw(Box::into_raw(boxed) as *mut Slice) }
     }
 
     #[inline]
diff --git a/src/libstd/sys/unix/os_str.rs b/src/libstd/sys/unix/os_str.rs
@@ -14,7 +14,6 @@
 use borrow::Cow;
 use fmt;
 use str;
-use mem;
 use rc::Rc;
 use sync::Arc;
 use sys_common::{AsInner, IntoInner};
@@ -105,7 +104,7 @@ impl Buf {
     }
 
     pub fn as_slice(&self) -> &Slice {
-        unsafe { mem::transmute(&*self.inner) }
+        &*(&*self.inner as *const [u8] as *const Slice)
     }
 
     pub fn into_string(self) -> Result<String, Buf> {
@@ -118,12 +117,13 @@ impl Buf {
 
     #[inline]
     pub fn into_box(self) -> Box<Slice> {
-        unsafe { mem::transmute(self.inner.into_boxed_slice()) }
+        let boxed = self.inner.into_boxed_slice();
+        unsafe { Box::from_raw(Box::into_raw(boxed) as *mut Slice) }
     }
 
     #[inline]
     pub fn from_box(boxed: Box<Slice>) -> Buf {
-        let inner: Box<[u8]> = unsafe { mem::transmute(boxed) };
+        let inner = unsafe { Box::from_raw(Box::into_raw(boxed) as *mut [u8]) };
         Buf { inner: inner.into_vec() }
     }
 
@@ -140,7 +140,7 @@ impl Buf {
 
 impl Slice {
     fn from_u8_slice(s: &[u8]) -> &Slice {
-        unsafe { mem::transmute(s) }
+        unsafe { &*(s as *const [u8] as *const Slice) }
     }
 
     pub fn from_str(s: &str) -> &Slice {
@@ -162,12 +162,12 @@ impl Slice {
     #[inline]
     pub fn into_box(&self) -> Box<Slice> {
         let boxed: Box<[u8]> = self.inner.into();
-        unsafe { mem::transmute(boxed) }
+        unsafe { Box::from_raw(Box::into_raw(boxed) as *mut Slice) }
     }
 
     pub fn empty_box() -> Box<Slice> {
         let boxed: Box<[u8]> = Default::default();
-        unsafe { mem::transmute(boxed) }
+        unsafe { Box::from_raw(Box::into_raw(boxed) as *mut Slice) }
     }
 
     #[inline]
diff --git a/src/libstd/sys/wasm/os_str.rs b/src/libstd/sys/wasm/os_str.rs
@@ -14,7 +14,6 @@
 use borrow::Cow;
 use fmt;
 use str;
-use mem;
 use rc::Rc;
 use sync::Arc;
 use sys_common::{AsInner, IntoInner};
@@ -105,7 +104,7 @@ impl Buf {
     }
 
     pub fn as_slice(&self) -> &Slice {
-        unsafe { mem::transmute(&*self.inner) }
+        &*(&*self.inner as *const [u8] as *const Slice)
     }
 
     pub fn into_string(self) -> Result<String, Buf> {
@@ -118,12 +117,13 @@ impl Buf {
 
     #[inline]
     pub fn into_box(self) -> Box<Slice> {
-        unsafe { mem::transmute(self.inner.into_boxed_slice()) }
+        let boxed = self.inner.into_boxed_slice();
+        unsafe { Box::from_raw(Box::into_raw(boxed) as *mut Slice) }
     }
 
     #[inline]
     pub fn from_box(boxed: Box<Slice>) -> Buf {
-        let inner: Box<[u8]> = unsafe { mem::transmute(boxed) };
+        let inner = unsafe { Box::from_raw(Box::into_raw(boxed) as *mut [u8]) };
         Buf { inner: inner.into_vec() }
     }
 
@@ -140,7 +140,7 @@ impl Buf {
 
 impl Slice {
     fn from_u8_slice(s: &[u8]) -> &Slice {
-        unsafe { mem::transmute(s) }
+        unsafe { &*(s as *const [u8] as *const Slice) }
     }
 
     pub fn from_str(s: &str) -> &Slice {
@@ -162,12 +162,12 @@ impl Slice {
     #[inline]
     pub fn into_box(&self) -> Box<Slice> {
         let boxed: Box<[u8]> = self.inner.into();
-        unsafe { mem::transmute(boxed) }
+        unsafe { Box::from_raw(Box::into_raw(boxed) as *mut Slice) }
     }
 
     pub fn empty_box() -> Box<Slice> {
         let boxed: Box<[u8]> = Default::default();
-        unsafe { mem::transmute(boxed) }
+        unsafe { Box::from_raw(Box::into_raw(boxed) as *mut Slice) }
     }
 
     #[inline]
diff --git a/src/libstd/sys/windows/os_str.rs b/src/libstd/sys/windows/os_str.rs
diff --git a/src/libstd_unicode/lossy.rs b/src/libstd_unicode/lossy.rs

Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,6 @@ use std::ffi::OsStr;`
`17`	`17`	`use std::fmt;`
`18`	`18`	`use std::hash::{Hash, Hasher};`
`19`	`19`	`use std::marker::PhantomData;`
`20`		`-use std::mem;`
`21`	`20`	`use std::ops::Deref;`
`22`	`21`	`use std::path::{Path, PathBuf};`
`23`	`22`	`use std::sync::Mutex;`
`@@ -114,43 +113,47 @@ impl Deref for Interned<String> {`
`114`	`113`	`type Target = str;`
`115`	`114`	`fn deref(&self) -> &'static str {`
`116`	`115`	`let l = INTERNER.strs.lock().unwrap();`
`117`		`- unsafe { mem::transmute::<&str, &'static str>(l.get(*self)) }`
	`116`	`+ let s: &str = l.get(*self).as_ref();`
	`117`	`+ unsafe { &(s const _) }`
`118`	`118`	`}`
`119`	`119`	`}`
`120`	`120`
`121`	`121`	`impl Deref for Interned<PathBuf> {`
`122`	`122`	`type Target = Path;`
`123`	`123`	`fn deref(&self) -> &'static Path {`
`124`	`124`	`let l = INTERNER.paths.lock().unwrap();`
`125`		`- unsafe { mem::transmute::<&Path, &'static Path>(l.get(*self)) }`
	`125`	`+ let p: &Path = l.get(*self).as_ref();`
	`126`	`+ unsafe { &(p const _) }`
`126`	`127`	`}`
`127`	`128`	`}`
`128`	`129`
`129`	`130`	`impl AsRef<Path> for Interned<PathBuf> {`
`130`	`131`	`fn as_ref(&self) -> &'static Path {`
`131`		`- let l = INTERNER.paths.lock().unwrap();`
`132`		`- unsafe { mem::transmute::<&Path, &'static Path>(l.get(*self)) }`
	`132`	`+ &*self`
`133`	`133`	`}`
`134`	`134`	`}`
`135`	`135`
`136`	`136`	`impl AsRef<Path> for Interned<String> {`
`137`	`137`	`fn as_ref(&self) -> &'static Path {`
`138`	`138`	`let l = INTERNER.strs.lock().unwrap();`
`139`		`- unsafe { mem::transmute::<&Path, &'static Path>(l.get(*self).as_ref()) }`
	`139`	`+ let p: &Path = l.get(*self).as_ref();`
	`140`	`+ unsafe { &(p const _) }`
`140`	`141`	`}`
`141`	`142`	`}`
`142`	`143`
`143`	`144`	`impl AsRef<OsStr> for Interned<PathBuf> {`
`144`	`145`	`fn as_ref(&self) -> &'static OsStr {`
`145`	`146`	`let l = INTERNER.paths.lock().unwrap();`
`146`		`- unsafe { mem::transmute::<&OsStr, &'static OsStr>(l.get(*self).as_ref()) }`
	`147`	`+ let s: &OsStr = l.get(*self).as_ref();`
	`148`	`+ unsafe { &(s const _) }`
`147`	`149`	`}`
`148`	`150`	`}`
`149`	`151`
`150`	`152`	`impl AsRef<OsStr> for Interned<String> {`
`151`	`153`	`fn as_ref(&self) -> &'static OsStr {`
`152`	`154`	`let l = INTERNER.strs.lock().unwrap();`
`153`		`- unsafe { mem::transmute::<&OsStr, &'static OsStr>(l.get(*self).as_ref()) }`
	`155`	`+ let s: &OsStr = l.get(*self).as_ref();`
	`156`	`+ unsafe { &(s const _) }`
`154`	`157`	`}`
`155`	`158`	`}`
`156`	`159`
Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,6 @@ use std::ops::Deref;`
`46`	`46`	`use std::rc::Rc;`
`47`	`47`	`use std::slice;`
`48`	`48`	`use std::vec::IntoIter;`
`49`		`-use std::mem;`
`50`	`49`	`use syntax::ast::{self, DUMMY_NODE_ID, Name, Ident, NodeId};`
`51`	`50`	`use syntax::attr;`
`52`	`51`	`use syntax::ext::hygiene::{Mark, SyntaxContext};`
`@@ -592,7 +591,8 @@ impl<'tcx> serialize::UseSpecializedDecodable for &'tcx Slice<Ty<'tcx>> {}`
`592`	`591`	`impl<T> Slice<T> {`
`593`	`592`	`pub fn empty<'a>() -> &'a Slice<T> {`
`594`	`593`	`unsafe {`
`595`		`- mem::transmute(slice::from_raw_parts(0x1 as *const T, 0))`
	`594`	`+ let slice = slice::from_raw_parts(0x1 as *const T, 0);`
	`595`	`+ &(slice as const [T] as *const Slice<T>)`
`596`	`596`	`}`
`597`	`597`	`}`
`598`	`598`	`}`
Original file line number	Diff line number	Diff line change
`@@ -241,21 +241,15 @@ impl<CTX> HashStable<CTX> for f32 {`
`241`	`241`	`fn hash_stable<W: StableHasherResult>(&self,`
`242`	`242`	`ctx: &mut CTX,`
`243`	`243`	`hasher: &mut StableHasher<W>) {`
`244`		`- let val: u32 = unsafe {`
`245`		`- ::std::mem::transmute(*self)`
`246`		`- };`
`247`		`- val.hash_stable(ctx, hasher);`
	`244`	`+ self.to_bits().hash_stable(ctx, hasher);`
`248`	`245`	`}`
`249`	`246`	`}`
`250`	`247`
`251`	`248`	`impl<CTX> HashStable<CTX> for f64 {`
`252`	`249`	`fn hash_stable<W: StableHasherResult>(&self,`
`253`	`250`	`ctx: &mut CTX,`
`254`	`251`	`hasher: &mut StableHasher<W>) {`
`255`		`- let val: u64 = unsafe {`
`256`		`- ::std::mem::transmute(*self)`
`257`		`- };`
`258`		`- val.hash_stable(ctx, hasher);`
	`252`	`+ self.to_bits().hash_stable(ctx, hasher);`
`259`	`253`	`}`
`260`	`254`	`}`
`261`	`255`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,6 @@ use rustc::ty::layout::{self, Align, Size};`
`21`	`21`
`22`	`22`	`use std::ffi::CString;`
`23`	`23`	`use std::fmt;`
`24`		`-use std::mem;`
`25`	`24`	`use std::ptr;`
`26`	`25`
`27`	`26`	`use libc::c_uint;`
`@@ -59,7 +58,7 @@ impl Type {`
`59`	`58`	`}`
`60`	`59`
`61`	`60`	`pub fn to_ref_slice(slice: &[Type]) -> &[TypeRef] {`
`62`		`- unsafe { mem::transmute(slice) }`
	`61`	`+ unsafe { &(slice as const [Type] as *const [TypeRef]) }`
`63`	`62`	`}`
`64`	`63`
`65`	`64`	`pub fn void(ccx: &CrateContext) -> Type {`
Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,6 @@ impl DoubleEndedIterator for Args {`
`57`	`57`
`58`	`58`	`mod imp {`
`59`	`59`	`use os::unix::prelude::*;`
`60`		`- use mem;`
`61`	`60`	`use ffi::{CStr, OsString};`
`62`	`61`	`use marker::PhantomData;`
`63`	`62`	`use libc;`
`@@ -105,7 +104,7 @@ mod imp {`
`105`	`104`	`}`
`106`	`105`
`107`	`106`	`fn get_global_ptr() -> *mut Option<Box<Vec<Vec<u8>>>> {`
`108`		`- unsafe { mem::transmute(&GLOBAL_ARGS_PTR) }`
	`107`	`+ unsafe { &mut GLOBAL_ARGS_PTR as mut _ as mut _ }`
`109`	`108`	`}`
`110`	`109`
`111`	`110`	`}`