Auto merge of #54554 - RalfJung:maybe-uninit, r=nagisa

Revert most of MaybeUninit, except for the new API itself

This reverts most of #53508 for perf reasons (first commit reverts that entire PR), except for the new API itself (added back in 2nd commit).

Author: bors

src/etc/gdb_rust_pretty_printing.py

@@ -322,11 +322,8 @@ def to_string(self):
     def children(self):
         (length, data_ptr) = \
             rustpp.extract_length_and_ptr_from_std_btreeset(self.__val)
-        leaf_node = GdbValue(data_ptr.get_wrapped_value().dereference())
-        maybe_uninit_keys = leaf_node.get_child_at_index(3)
-        manually_drop_keys = maybe_uninit_keys.get_child_at_index(1)
-        keys = manually_drop_keys.get_child_at_index(0)
-        gdb_ptr = keys.get_wrapped_value()
+        val = GdbValue(data_ptr.get_wrapped_value().dereference()).get_child_at_index(3)
+        gdb_ptr = val.get_wrapped_value()
         for index in xrange(length):
             yield (str(index), gdb_ptr[index])
 
@@ -348,14 +345,9 @@ def to_string(self):
     def children(self):
         (length, data_ptr) = \
             rustpp.extract_length_and_ptr_from_std_btreemap(self.__val)
-        leaf_node = GdbValue(data_ptr.get_wrapped_value().dereference())
-        maybe_uninit_keys = leaf_node.get_child_at_index(3)
-        manually_drop_keys = maybe_uninit_keys.get_child_at_index(1)
-        keys = manually_drop_keys.get_child_at_index(0)
+        keys = GdbValue(data_ptr.get_wrapped_value().dereference()).get_child_at_index(3)
         keys_ptr = keys.get_wrapped_value()
-        maybe_uninit_vals = leaf_node.get_child_at_index(4)
-        manually_drop_vals = maybe_uninit_vals.get_child_at_index(1)
-        vals = manually_drop_vals.get_child_at_index(0)
+        vals = GdbValue(data_ptr.get_wrapped_value().dereference()).get_child_at_index(4)
         vals_ptr = vals.get_wrapped_value()
         for index in xrange(length):
             yield (str(index), keys_ptr[index])

src/liballoc/collections/btree/node.rs

@@ -42,7 +42,7 @@
 //   This implies that even an empty internal node has at least one edge.
 
 use core::marker::PhantomData;
-use core::mem::{self, MaybeUninit};
+use core::mem;
 use core::ptr::{self, Unique, NonNull};
 use core::slice;
 
@@ -73,7 +73,7 @@ struct LeafNode<K, V> {
     /// This node's index into the parent node's `edges` array.
     /// `*node.parent.edges[node.parent_idx]` should be the same thing as `node`.
     /// This is only guaranteed to be initialized when `parent` is nonnull.
-    parent_idx: MaybeUninit<u16>,
+    parent_idx: u16,
 
     /// The number of keys and values this node stores.
     ///
@@ -83,8 +83,8 @@ struct LeafNode<K, V> {
 
     /// The arrays storing the actual data of the node. Only the first `len` elements of each
     /// array are initialized and valid.
-    keys: MaybeUninit<[K; CAPACITY]>,
-    vals: MaybeUninit<[V; CAPACITY]>,
+    keys: [K; CAPACITY],
+    vals: [V; CAPACITY],
 }
 
 impl<K, V> LeafNode<K, V> {
@@ -94,10 +94,10 @@ impl<K, V> LeafNode<K, V> {
         LeafNode {
             // As a general policy, we leave fields uninitialized if they can be, as this should
             // be both slightly faster and easier to track in Valgrind.
-            keys: MaybeUninit::uninitialized(),
-            vals: MaybeUninit::uninitialized(),
+            keys: mem::uninitialized(),
+            vals: mem::uninitialized(),
             parent: ptr::null(),
-            parent_idx: MaybeUninit::uninitialized(),
+            parent_idx: mem::uninitialized(),
             len: 0
         }
     }
@@ -115,10 +115,10 @@ unsafe impl Sync for LeafNode<(), ()> {}
 // ever take a pointer past the first key.
 static EMPTY_ROOT_NODE: LeafNode<(), ()> = LeafNode {
     parent: ptr::null(),
-    parent_idx: MaybeUninit::uninitialized(),
+    parent_idx: 0,
     len: 0,
-    keys: MaybeUninit::uninitialized(),
-    vals: MaybeUninit::uninitialized(),
+    keys: [(); CAPACITY],
+    vals: [(); CAPACITY],
 };
 
 /// The underlying representation of internal nodes. As with `LeafNode`s, these should be hidden
@@ -430,7 +430,7 @@ impl<BorrowType, K, V, Type> NodeRef<BorrowType, K, V, Type> {
                     root: self.root,
                     _marker: PhantomData
                 },
-                idx: unsafe { usize::from(*self.as_leaf().parent_idx.get_ref()) },
+                idx: self.as_leaf().parent_idx as usize,
                 _marker: PhantomData
             })
         } else {
@@ -567,7 +567,7 @@ impl<'a, K: 'a, V: 'a, Type> NodeRef<marker::Immut<'a>, K, V, Type> {
             // the node, which is allowed by LLVM.
             unsafe {
                 slice::from_raw_parts(
-                    self.as_leaf().keys.as_ptr() as *const K,
+                    self.as_leaf().keys.as_ptr(),
                     self.len()
                 )
             }
@@ -578,7 +578,7 @@ impl<'a, K: 'a, V: 'a, Type> NodeRef<marker::Immut<'a>, K, V, Type> {
         debug_assert!(!self.is_shared_root());
         unsafe {
             slice::from_raw_parts(
-                self.as_leaf().vals.as_ptr() as *const V,
+                self.as_leaf().vals.as_ptr(),
                 self.len()
             )
         }
@@ -605,7 +605,7 @@ impl<'a, K: 'a, V: 'a, Type> NodeRef<marker::Mut<'a>, K, V, Type> {
         } else {
             unsafe {
                 slice::from_raw_parts_mut(
-                    self.as_leaf_mut().keys.get_mut() as *mut [K] as *mut K,
+                    &mut self.as_leaf_mut().keys as *mut [K] as *mut K,
                     self.len()
                 )
             }
@@ -616,7 +616,7 @@ impl<'a, K: 'a, V: 'a, Type> NodeRef<marker::Mut<'a>, K, V, Type> {
         debug_assert!(!self.is_shared_root());
         unsafe {
             slice::from_raw_parts_mut(
-                self.as_leaf_mut().vals.get_mut() as *mut [V] as *mut V,
+                &mut self.as_leaf_mut().vals as *mut [V] as *mut V,
                 self.len()
             )
         }
@@ -1013,7 +1013,7 @@ impl<'a, K, V> Handle<NodeRef<marker::Mut<'a>, K, V, marker::Internal>, marker::
         let ptr = self.node.as_internal_mut() as *mut _;
         let mut child = self.descend();
         child.as_leaf_mut().parent = ptr;
-        child.as_leaf_mut().parent_idx.set(idx);
+        child.as_leaf_mut().parent_idx = idx;
     }
 
     /// Unsafely asserts to the compiler some static information about whether the underlying
@@ -1152,12 +1152,12 @@ impl<'a, K, V> Handle<NodeRef<marker::Mut<'a>, K, V, marker::Leaf>, marker::KV>
 
             ptr::copy_nonoverlapping(
                 self.node.keys().as_ptr().add(self.idx + 1),
-                new_node.keys.as_mut_ptr() as *mut K,
+                new_node.keys.as_mut_ptr(),
                 new_len
             );
             ptr::copy_nonoverlapping(
                 self.node.vals().as_ptr().add(self.idx + 1),
-                new_node.vals.as_mut_ptr() as *mut V,
+                new_node.vals.as_mut_ptr(),
                 new_len
             );
 
@@ -1210,12 +1210,12 @@ impl<'a, K, V> Handle<NodeRef<marker::Mut<'a>, K, V, marker::Internal>, marker::
 
             ptr::copy_nonoverlapping(
                 self.node.keys().as_ptr().add(self.idx + 1),
-                new_node.data.keys.as_mut_ptr() as *mut K,
+                new_node.data.keys.as_mut_ptr(),
                 new_len
             );
             ptr::copy_nonoverlapping(
                 self.node.vals().as_ptr().add(self.idx + 1),
-                new_node.data.vals.as_mut_ptr() as *mut V,
+                new_node.data.vals.as_mut_ptr(),
                 new_len
             );
             ptr::copy_nonoverlapping(

src/liballoc/lib.rs

@@ -120,7 +120,6 @@
 #![feature(rustc_const_unstable)]
 #![feature(const_vec_new)]
 #![feature(slice_partition_dedup)]
-#![feature(maybe_uninit)]
 
 // Allow testing this library
 

src/libcore/fmt/float.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 use fmt::{Formatter, Result, LowerExp, UpperExp, Display, Debug};
-use mem::MaybeUninit;
+use mem;
 use num::flt2dec;
 
 // Don't inline this so callers don't use the stack space this function
@@ -20,11 +20,11 @@ fn float_to_decimal_common_exact<T>(fmt: &mut Formatter, num: &T,
     where T: flt2dec::DecodableFloat
 {
     unsafe {
-        let mut buf = MaybeUninit::<[u8; 1024]>::uninitialized(); // enough for f32 and f64
-        let mut parts = MaybeUninit::<[flt2dec::Part; 4]>::uninitialized();
+        let mut buf: [u8; 1024] = mem::uninitialized(); // enough for f32 and f64
+        let mut parts: [flt2dec::Part; 4] = mem::uninitialized();
         let formatted = flt2dec::to_exact_fixed_str(flt2dec::strategy::grisu::format_exact,
                                                     *num, sign, precision,
-                                                    false, buf.get_mut(), parts.get_mut());
+                                                    false, &mut buf, &mut parts);
         fmt.pad_formatted_parts(&formatted)
     }
 }
@@ -38,11 +38,10 @@ fn float_to_decimal_common_shortest<T>(fmt: &mut Formatter, num: &T,
 {
     unsafe {
         // enough for f32 and f64
-        let mut buf = MaybeUninit::<[u8; flt2dec::MAX_SIG_DIGITS]>::uninitialized();
-        let mut parts = MaybeUninit::<[flt2dec::Part; 4]>::uninitialized();
+        let mut buf: [u8; flt2dec::MAX_SIG_DIGITS] = mem::uninitialized();
+        let mut parts: [flt2dec::Part; 4] = mem::uninitialized();
         let formatted = flt2dec::to_shortest_str(flt2dec::strategy::grisu::format_shortest, *num,
-                                                 sign, precision, false, buf.get_mut(),
-                                                 parts.get_mut());
+                                                 sign, precision, false, &mut buf, &mut parts);
         fmt.pad_formatted_parts(&formatted)
     }
 }
@@ -76,11 +75,11 @@ fn float_to_exponential_common_exact<T>(fmt: &mut Formatter, num: &T,
     where T: flt2dec::DecodableFloat
 {
     unsafe {
-        let mut buf = MaybeUninit::<[u8; 1024]>::uninitialized(); // enough for f32 and f64
-        let mut parts = MaybeUninit::<[flt2dec::Part; 6]>::uninitialized();
+        let mut buf: [u8; 1024] = mem::uninitialized(); // enough for f32 and f64
+        let mut parts: [flt2dec::Part; 6] = mem::uninitialized();
         let formatted = flt2dec::to_exact_exp_str(flt2dec::strategy::grisu::format_exact,
                                                   *num, sign, precision,
-                                                  upper, buf.get_mut(), parts.get_mut());
+                                                  upper, &mut buf, &mut parts);
         fmt.pad_formatted_parts(&formatted)
     }
 }
@@ -95,11 +94,11 @@ fn float_to_exponential_common_shortest<T>(fmt: &mut Formatter,
 {
     unsafe {
         // enough for f32 and f64
-        let mut buf = MaybeUninit::<[u8; flt2dec::MAX_SIG_DIGITS]>::uninitialized();
-        let mut parts = MaybeUninit::<[flt2dec::Part; 6]>::uninitialized();
+        let mut buf: [u8; flt2dec::MAX_SIG_DIGITS] = mem::uninitialized();
+        let mut parts: [flt2dec::Part; 6] = mem::uninitialized();
         let formatted = flt2dec::to_shortest_exp_str(flt2dec::strategy::grisu::format_shortest,
                                                      *num, sign, (0, 0), upper,
-                                                     buf.get_mut(), parts.get_mut());
+                                                     &mut buf, &mut parts);
         fmt.pad_formatted_parts(&formatted)
     }
 }

src/libcore/lib.rs

@@ -246,8 +246,6 @@ macro_rules! test_v512 { ($item:item) => {}; }
 #[allow(unused_macros)]
 macro_rules! vector_impl { ($([$f:ident, $($args:tt)*]),*) => { $($f!($($args)*);)* } }
 #[path = "../stdsimd/coresimd/mod.rs"]
-// replacing uses of mem::{uninitialized,zeroed} with MaybeUninit needs to be in the stdsimd repo
-#[allow(deprecated)]
 #[allow(missing_docs, missing_debug_implementations, dead_code, unused_imports)]
 #[unstable(feature = "stdsimd", issue = "48556")]
 #[cfg(not(stage0))] // allow changes to how stdsimd works in stage0

src/libcore/ptr.rs

@@ -79,7 +79,7 @@ use ops::CoerceUnsized;
 use fmt;
 use hash;
 use marker::{PhantomData, Unsize};
-use mem::{self, MaybeUninit};
+use mem;
 use nonzero::NonZero;
 
 use cmp::Ordering::{self, Less, Equal, Greater};
@@ -294,12 +294,16 @@ pub const fn null_mut<T>() -> *mut T { 0 as *mut T }
 #[stable(feature = "rust1", since = "1.0.0")]
 pub unsafe fn swap<T>(x: *mut T, y: *mut T) {
     // Give ourselves some scratch space to work with
-    let mut tmp = MaybeUninit::<T>::uninitialized();
+    let mut tmp: T = mem::uninitialized();
 
     // Perform the swap
-    copy_nonoverlapping(x, tmp.as_mut_ptr(), 1);
+    copy_nonoverlapping(x, &mut tmp, 1);
     copy(y, x, 1); // `x` and `y` may overlap
-    copy_nonoverlapping(tmp.get_ref(), y, 1);
+    copy_nonoverlapping(&tmp, y, 1);
+
+    // y and t now point to the same thing, but we need to completely forget `tmp`
+    // because it's no longer relevant.
+    mem::forget(tmp);
 }
 
 /// Swaps `count * size_of::<T>()` bytes between the two regions of memory
@@ -386,8 +390,8 @@ unsafe fn swap_nonoverlapping_bytes(x: *mut u8, y: *mut u8, len: usize) {
     while i + block_size <= len {
         // Create some uninitialized memory as scratch space
         // Declaring `t` here avoids aligning the stack when this loop is unused
-        let mut t = mem::MaybeUninit::<Block>::uninitialized();
-        let t = t.as_mut_ptr() as *mut u8;
+        let mut t: Block = mem::uninitialized();
+        let t = &mut t as *mut _ as *mut u8;
         let x = x.add(i);
         let y = y.add(i);
 
@@ -401,10 +405,10 @@ unsafe fn swap_nonoverlapping_bytes(x: *mut u8, y: *mut u8, len: usize) {
 
     if i < len {
         // Swap any remaining bytes
-        let mut t = mem::MaybeUninit::<UnalignedBlock>::uninitialized();
+        let mut t: UnalignedBlock = mem::uninitialized();
         let rem = len - i;
 
-        let t = t.as_mut_ptr() as *mut u8;
+        let t = &mut t as *mut _ as *mut u8;
         let x = x.add(i);
         let y = y.add(i);
 
@@ -569,9 +573,9 @@ pub unsafe fn replace<T>(dst: *mut T, mut src: T) -> T {
 #[inline]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub unsafe fn read<T>(src: *const T) -> T {
-    let mut tmp = MaybeUninit::<T>::uninitialized();
-    copy_nonoverlapping(src, tmp.as_mut_ptr(), 1);
-    tmp.into_inner()
+    let mut tmp: T = mem::uninitialized();
+    copy_nonoverlapping(src, &mut tmp, 1);
+    tmp
 }
 
 /// Reads the value from `src` without moving it. This leaves the
@@ -636,11 +640,11 @@ pub unsafe fn read<T>(src: *const T) -> T {
 #[inline]
 #[stable(feature = "ptr_unaligned", since = "1.17.0")]
 pub unsafe fn read_unaligned<T>(src: *const T) -> T {
-    let mut tmp = MaybeUninit::<T>::uninitialized();
+    let mut tmp: T = mem::uninitialized();
     copy_nonoverlapping(src as *const u8,
-                        tmp.as_mut_ptr() as *mut u8,
+                        &mut tmp as *mut T as *mut u8,
                         mem::size_of::<T>());
-    tmp.into_inner()
+    tmp
 }
 
 /// Overwrites a memory location with the given value without reading or

src/libcore/slice/rotate.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 use cmp;
-use mem::{self, MaybeUninit};
+use mem;
 use ptr;
 
 /// Rotation is much faster if it has access to a little bit of memory. This
@@ -26,6 +26,12 @@ union RawArray<T> {
 }
 
 impl<T> RawArray<T> {
+    fn new() -> Self {
+        unsafe { mem::uninitialized() }
+    }
+    fn ptr(&self) -> *mut T {
+        unsafe { &self.typed as *const T as *mut T }
+    }
     fn cap() -> usize {
         if mem::size_of::<T>() == 0 {
             usize::max_value()
@@ -82,8 +88,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 rawarray = RawArray::new();
+    let buf = rawarray.ptr();
 
     let dim = mid.sub(left).add(right);
     if left <= right {