Wipe the transmutes off the libstd’s face

Author: nagisa

src/liballoc/sync.rs

@@ -517,6 +517,13 @@ impl<T: ?Sized> Arc<T> {
         unsafe { self.ptr.as_ref() }
     }
 
+    #[inline]
+    pub(crate) unsafe fn into_ptr<U>(self) -> NonNull<U> {
+        let ptr = self.ptr;
+        mem::forget(self);
+        ptr.cast()
+    }
+
     // Non-inlined part of `drop`.
     #[inline(never)]
     unsafe fn drop_slow(&mut self) {

src/liballoc/task.rs

@@ -19,9 +19,8 @@ pub use self::if_arc::*;
 mod if_arc {
     use super::*;
     use core::marker::PhantomData;
-    use core::mem;
-    use core::ptr::{self, NonNull};
     use sync::Arc;
+    use core::ptr;
 
     /// A way of waking up a specific task.
     ///
@@ -83,9 +82,9 @@ mod if_arc {
     {
         fn from(rc: Arc<T>) -> Self {
             unsafe {
-                let ptr = mem::transmute::<Arc<T>, NonNull<ArcWrapped<T>>>(rc);
-                Waker::new(ptr)
+                Waker::new(rc.into_ptr::<ArcWrapped<T>>())
             }
+
         }
     }
 
@@ -96,8 +95,7 @@ mod if_arc {
     /// will call `wake.wake()` if awoken after being converted to a `Waker`.
     #[inline]
     pub unsafe fn local_waker<W: Wake + 'static>(wake: Arc<W>) -> LocalWaker {
-        let ptr = mem::transmute::<Arc<W>, NonNull<ArcWrapped<W>>>(wake);
-        LocalWaker::new(ptr)
+        LocalWaker::new(wake.into_ptr::<ArcWrapped<W>>())
     }
 
     struct NonLocalAsLocal<T>(ArcWrapped<T>);
@@ -133,8 +131,7 @@ mod if_arc {
     #[inline]
     pub fn local_waker_from_nonlocal<W: Wake + 'static>(wake: Arc<W>) -> LocalWaker {
         unsafe {
-            let ptr = mem::transmute::<Arc<W>, NonNull<NonLocalAsLocal<W>>>(wake);
-            LocalWaker::new(ptr)
+            LocalWaker::new(wake.into_ptr::<NonLocalAsLocal<W>>())
         }
     }
 }

src/libcore/str/lossy.rs

@@ -12,7 +12,6 @@ use char;
 use str as core_str;
 use fmt;
 use fmt::Write;
-use mem;
 
 /// Lossy UTF-8 string.
 #[unstable(feature = "str_internals", issue = "0")]
@@ -26,7 +25,7 @@ impl Utf8Lossy {
     }
 
     pub fn from_bytes(bytes: &[u8]) -> &Utf8Lossy {
-        unsafe { mem::transmute(bytes) }
+        unsafe { &*(bytes as *const [u8] as *const Utf8Lossy) }
     }
 
     pub fn chunks(&self) -> Utf8LossyChunksIter {

src/libpanic_unwind/lib.rs

@@ -51,7 +51,7 @@ extern crate unwind;
 
 use alloc::boxed::Box;
 use core::intrinsics;
-use core::mem;
+use core::any::Any;
 use core::raw;
 use core::panic::BoxMeUp;
 
@@ -105,7 +105,8 @@ pub unsafe extern "C" fn __rust_maybe_catch_panic(f: fn(*mut u8),
     if intrinsics::try(f, data, &mut payload as *mut _ as *mut _) == 0 {
         0
     } else {
-        let obj = mem::transmute::<_, raw::TraitObject>(imp::cleanup(payload));
+        let raw = &Box::into_raw(imp::cleanup(payload));
+        let obj = *(raw as *const *mut (Any + Send) as *const raw::TraitObject);
         *data_ptr = obj.data as usize;
         *vtable_ptr = obj.vtable as usize;
         1

src/libstd/error.rs

@@ -30,7 +30,6 @@ use cell;
 use char;
 use core::array;
 use fmt::{self, Debug, Display};
-use mem::transmute;
 use num;
 use str;
 use string;
@@ -483,7 +482,7 @@ impl Error + Send {
         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 (Error + Send))
         })
     }
 }
@@ -497,7 +496,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 (Error + Send + Sync))
         })
     }
 }

src/libstd/panicking.rs

@@ -297,10 +297,10 @@ pub unsafe fn try<R, F: FnOnce() -> R>(f: F) -> Result<R, Box<Any + Send>> {
     } else {
         update_panic_count(-1);
         debug_assert!(update_panic_count(0) == 0);
-        Err(mem::transmute(raw::TraitObject {
+        Err(Box::from_raw(*(&raw::TraitObject {
             data: any_data as *mut _,
             vtable: any_vtable as *mut _,
-        }))
+        } as *const _ as *const *mut _)))
     };
 
     fn do_call<F: FnOnce() -> R, R>(data: *mut u8) {

src/libstd/sync/mpsc/blocking.rs

@@ -13,7 +13,6 @@
 use thread::{self, Thread};
 use sync::atomic::{AtomicBool, Ordering};
 use sync::Arc;
-use mem;
 use time::Instant;
 
 struct Inner {
@@ -64,14 +63,14 @@ impl SignalToken {
     /// flag.
     #[inline]
     pub unsafe fn cast_to_usize(self) -> usize {
-        mem::transmute(self.inner)
+        Arc::into_raw(self.inner) as usize
     }
 
     /// Convert from an unsafe usize value. Useful for retrieving a pipe's state
     /// flag.
     #[inline]
     pub unsafe fn cast_from_usize(signal_ptr: usize) -> SignalToken {
-        SignalToken { inner: mem::transmute(signal_ptr) }
+        SignalToken { inner: Arc::from_raw(signal_ptr as *const _) }
     }
 }
 

src/libstd/sys/unix/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};
 
@@ -111,7 +110,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

src/libstd/sys/unix/ext/net.rs

@@ -211,7 +211,7 @@ impl SocketAddr {
 
     fn address<'a>(&'a self) -> AddressKind<'a> {
         let len = self.len as usize - sun_path_offset();
-        let path = unsafe { mem::transmute::<&[libc::c_char], &[u8]>(&self.addr.sun_path) };
+        let path = unsafe { &*(&self.addr.sun_path as *const [libc::c_char] as *const [u8]) };
 
         // macOS seems to return a len of 16 and a zeroed sun_path for unnamed addresses
         if len == 0

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};
@@ -110,7 +109,7 @@ impl Buf {
     }
 
     pub fn as_slice(&self) -> &Slice {
-        unsafe { mem::transmute(&*self.inner) }
+        Slice::from_u8_slice(&*self.inner)
     }
 
     pub fn into_string(self) -> Result<String, Buf> {
@@ -123,12 +122,12 @@ impl Buf {
 
     #[inline]
     pub fn into_box(self) -> Box<Slice> {
-        unsafe { mem::transmute(self.inner.into_boxed_slice()) }
+        unsafe { Box::from_raw(Box::into_raw(self.inner.into_boxed_slice()) as *mut Slice) }
     }
 
     #[inline]
     pub fn from_box(boxed: Box<Slice>) -> Buf {
-        let inner: Box<[u8]> = unsafe { mem::transmute(boxed) };
+        let inner: Box<[u8]> = unsafe { Box::from_raw(&mut (*Box::into_raw(boxed)).inner) };
         Buf { inner: inner.into_vec() }
     }
 
@@ -145,7 +144,7 @@ impl Buf {
 
 impl Slice {
     fn from_u8_slice(s: &[u8]) -> &Slice {
-        unsafe { mem::transmute(s) }
+        unsafe { &*(s as *const _ as *const Slice) }
     }
 
     pub fn from_str(s: &str) -> &Slice {
@@ -167,12 +166,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]

src/libstd/sys_common/wtf8.rs

@@ -32,7 +32,6 @@ use char;
 use fmt;
 use hash::{Hash, Hasher};
 use iter::FromIterator;
-use mem;
 use ops;
 use rc::Rc;
 use slice;
@@ -366,12 +365,12 @@ impl Wtf8Buf {
     /// Converts this `Wtf8Buf` into a boxed `Wtf8`.
     #[inline]
     pub fn into_box(self) -> Box<Wtf8> {
-        unsafe { mem::transmute(self.bytes.into_boxed_slice()) }
+        unsafe { Box::from_raw(Box::into_raw(self.bytes.into_boxed_slice()) as *mut Wtf8) }
     }
 
     /// Converts a `Box<Wtf8>` into a `Wtf8Buf`.
     pub fn from_box(boxed: Box<Wtf8>) -> Wtf8Buf {
-        let bytes: Box<[u8]> = unsafe { mem::transmute(boxed) };
+        let bytes: Box<[u8]> = unsafe { Box::from_raw(Box::into_raw(boxed) as *mut [u8]) };
         Wtf8Buf { bytes: bytes.into_vec() }
     }
 }
@@ -493,7 +492,7 @@ impl Wtf8 {
     /// marked unsafe.
     #[inline]
     unsafe fn from_bytes_unchecked(value: &[u8]) -> &Wtf8 {
-        mem::transmute(value)
+        &*(value as *const _ as *const Wtf8)
     }
 
     /// Creates a mutable WTF-8 slice from a mutable WTF-8 byte slice.
@@ -502,7 +501,7 @@ impl Wtf8 {
     /// marked unsafe.
     #[inline]
     unsafe fn from_mut_bytes_unchecked(value: &mut [u8]) -> &mut Wtf8 {
-        mem::transmute(value)
+        &mut *(value as *mut _ as *mut Wtf8)
     }
 
     /// Returns the length, in WTF-8 bytes.
@@ -651,13 +650,13 @@ impl Wtf8 {
     #[inline]
     pub fn into_box(&self) -> Box<Wtf8> {
         let boxed: Box<[u8]> = self.bytes.into();
-        unsafe { mem::transmute(boxed) }
+        unsafe { Box::from_raw(Box::into_raw(boxed) as *mut Wtf8) }
     }
 
     /// Creates a boxed, empty `Wtf8`.
     pub fn empty_box() -> Box<Wtf8> {
         let boxed: Box<[u8]> = Default::default();
-        unsafe { mem::transmute(boxed) }
+        unsafe { Box::from_raw(Box::into_raw(boxed) as *mut Wtf8) }
     }
 
     #[inline]