Update libcore/std for union fields with drop

We now use ManuallyDrop for equivalent effect.

Author: bluss

src/libcore/slice/rotate.rs

@@ -8,7 +8,7 @@ use ptr;
 union RawArray<T> {
     /// Ensure this is appropriately aligned for T, and is big
     /// enough for two elements even if T is enormous.
-    typed: [T; 2],
+    typed: [MaybeUninit<T>; 2],
     /// For normally-sized types, especially things like u8, having more
     /// than 2 in the buffer is necessary for usefulness, so pad it out
     /// enough to be helpful, but not so big as to risk overflow.
@@ -73,7 +73,8 @@ pub unsafe fn ptr_rotate<T>(mut left: usize, mid: *mut T, mut right: usize) {
     }
 
     let mut rawarray = MaybeUninit::<RawArray<T>>::uninitialized();
-    let buf = &mut (*rawarray.as_mut_ptr()).typed as *mut [T; 2] as *mut T;
+    let buf = &mut (*rawarray.as_mut_ptr()).typed as *mut [MaybeUninit<T>; 2]
+              as *mut [T; 2] as *mut T;
 
     let dim = mid.sub(left).add(right);
     if left <= right {

src/libstd/panicking.rs

@@ -16,7 +16,7 @@ use cell::RefCell;
 use core::panic::{PanicInfo, Location};
 use fmt;
 use intrinsics;
-use mem;
+use mem::{self, ManuallyDrop};
 use ptr;
 use raw;
 use sys::stdio::panic_output;
@@ -238,8 +238,8 @@ pub use realstd::rt::update_panic_count;
 pub unsafe fn try<R, F: FnOnce() -> R>(f: F) -> Result<R, Box<dyn Any + Send>> {
     #[allow(unions_with_drop_fields)]
     union Data<F, R> {
-        f: F,
-        r: R,
+        f: ManuallyDrop<F>,
+        r: ManuallyDrop<R>,
     }
 
     // We do some sketchy operations with ownership here for the sake of
@@ -270,7 +270,7 @@ pub unsafe fn try<R, F: FnOnce() -> R>(f: F) -> Result<R, Box<dyn Any + Send>> {
     let mut any_data = 0;
     let mut any_vtable = 0;
     let mut data = Data {
-        f,
+        f: ManuallyDrop::new(f)
     };
 
     let r = __rust_maybe_catch_panic(do_call::<F, R>,
@@ -280,7 +280,7 @@ pub unsafe fn try<R, F: FnOnce() -> R>(f: F) -> Result<R, Box<dyn Any + Send>> {
 
     return if r == 0 {
         debug_assert!(update_panic_count(0) == 0);
-        Ok(data.r)
+        Ok(ManuallyDrop::into_inner(data.r))
     } else {
         update_panic_count(-1);
         debug_assert!(update_panic_count(0) == 0);
@@ -293,8 +293,8 @@ pub unsafe fn try<R, F: FnOnce() -> R>(f: F) -> Result<R, Box<dyn Any + Send>> {
     fn do_call<F: FnOnce() -> R, R>(data: *mut u8) {
         unsafe {
             let data = data as *mut Data<F, R>;
-            let f = ptr::read(&mut (*data).f);
-            ptr::write(&mut (*data).r, f());
+            let f = ptr::read(&mut *(*data).f);
+            ptr::write(&mut *(*data).r, f());
         }
     }
 }