core: fix deprecated warnings

japaric · RalfJung · commit 318cfd5d1630 · 2018-10-08T12:06:16.000+02:00
diff --git a/src/libcore/fmt/float.rs b/src/libcore/fmt/float.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 use fmt::{Formatter, Result, LowerExp, UpperExp, Display, Debug};
-use mem;
+use mem::MaybeUninit;
 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: [u8; 1024] = mem::uninitialized(); // enough for f32 and f64
-        let mut parts: [flt2dec::Part; 4] = mem::uninitialized();
+        let mut buf = MaybeUninit::<[u8; 1024]>::uninitialized(); // enough for f32 and f64
+        let mut parts = MaybeUninit::<[flt2dec::Part; 4]>::uninitialized();
         let formatted = flt2dec::to_exact_fixed_str(flt2dec::strategy::grisu::format_exact,
                                                     *num, sign, precision,
-                                                    false, &mut buf, &mut parts);
+                                                    false, buf.get_mut(), parts.get_mut());
         fmt.pad_formatted_parts(&formatted)
     }
 }
@@ -38,10 +38,11 @@ fn float_to_decimal_common_shortest<T>(fmt: &mut Formatter, num: &T,
 {
     unsafe {
         // enough for f32 and f64
-        let mut buf: [u8; flt2dec::MAX_SIG_DIGITS] = mem::uninitialized();
-        let mut parts: [flt2dec::Part; 4] = mem::uninitialized();
+        let mut buf = MaybeUninit::<[u8; flt2dec::MAX_SIG_DIGITS]>::uninitialized();
+        let mut parts = MaybeUninit::<[flt2dec::Part; 4]>::uninitialized();
         let formatted = flt2dec::to_shortest_str(flt2dec::strategy::grisu::format_shortest, *num,
-                                                 sign, precision, false, &mut buf, &mut parts);
+                                                 sign, precision, false, buf.get_mut(),
+                                                 parts.get_mut());
         fmt.pad_formatted_parts(&formatted)
     }
 }
@@ -75,11 +76,11 @@ fn float_to_exponential_common_exact<T>(fmt: &mut Formatter, num: &T,
     where T: flt2dec::DecodableFloat
 {
     unsafe {
-        let mut buf: [u8; 1024] = mem::uninitialized(); // enough for f32 and f64
-        let mut parts: [flt2dec::Part; 6] = mem::uninitialized();
+        let mut buf = MaybeUninit::<[u8; 1024]>::uninitialized(); // enough for f32 and f64
+        let mut parts = MaybeUninit::<[flt2dec::Part; 6]>::uninitialized();
         let formatted = flt2dec::to_exact_exp_str(flt2dec::strategy::grisu::format_exact,
                                                   *num, sign, precision,
-                                                  upper, &mut buf, &mut parts);
+                                                  upper, buf.get_mut(), parts.get_mut());
         fmt.pad_formatted_parts(&formatted)
     }
 }
@@ -94,11 +95,11 @@ fn float_to_exponential_common_shortest<T>(fmt: &mut Formatter,
 {
     unsafe {
         // enough for f32 and f64
-        let mut buf: [u8; flt2dec::MAX_SIG_DIGITS] = mem::uninitialized();
-        let mut parts: [flt2dec::Part; 6] = mem::uninitialized();
+        let mut buf = MaybeUninit::<[u8; flt2dec::MAX_SIG_DIGITS]>::uninitialized();
+        let mut parts = MaybeUninit::<[flt2dec::Part; 6]>::uninitialized();
         let formatted = flt2dec::to_shortest_exp_str(flt2dec::strategy::grisu::format_shortest,
                                                      *num, sign, (0, 0), upper,
-                                                     &mut buf, &mut parts);
+                                                     buf.get_mut(), parts.get_mut());
         fmt.pad_formatted_parts(&formatted)
     }
 }
diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs
@@ -248,6 +248,8 @@ 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
diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs
@@ -79,7 +79,7 @@ use ops::CoerceUnsized;
 use fmt;
 use hash;
 use marker::{PhantomData, Unsize};
-use mem;
+use mem::{self, MaybeUninit};
 use nonzero::NonZero;
 
 use cmp::Ordering::{self, Less, Equal, Greater};
@@ -296,16 +296,12 @@ 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: T = mem::uninitialized();
+    let mut tmp = MaybeUninit::<T>::uninitialized();
 
     // Perform the swap
-    copy_nonoverlapping(x, &mut tmp, 1);
+    copy_nonoverlapping(x, tmp.get_mut(), 1);
     copy(y, x, 1); // `x` and `y` may overlap
-    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);
+    copy_nonoverlapping(tmp.get_ref(), y, 1);
 }
 
 /// Swaps `count * size_of::<T>()` bytes between the two regions of memory
@@ -392,8 +388,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: Block = mem::uninitialized();
-        let t = &mut t as *mut _ as *mut u8;
+        let mut t = mem::MaybeUninit::<Block>::uninitialized();
+        let t = t.as_mut_ptr() as *mut u8;
         let x = x.add(i);
         let y = y.add(i);
 
@@ -407,10 +403,10 @@ unsafe fn swap_nonoverlapping_bytes(x: *mut u8, y: *mut u8, len: usize) {
 
     if i < len {
         // Swap any remaining bytes
-        let mut t: UnalignedBlock = mem::uninitialized();
+        let mut t = mem::MaybeUninit::<UnalignedBlock>::uninitialized();
         let rem = len - i;
 
-        let t = &mut t as *mut _ as *mut u8;
+        let t = t.as_mut_ptr() as *mut u8;
         let x = x.add(i);
         let y = y.add(i);
 
@@ -575,9 +571,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: T = mem::uninitialized();
-    copy_nonoverlapping(src, &mut tmp, 1);
-    tmp
+    let mut tmp = MaybeUninit::<T>::uninitialized();
+    copy_nonoverlapping(src, tmp.get_mut(), 1);
+    tmp.into_inner()
 }
 
 /// Reads the value from `src` without moving it. This leaves the
@@ -642,11 +638,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: T = mem::uninitialized();
+    let mut tmp = MaybeUninit::<T>::uninitialized();
     copy_nonoverlapping(src as *const u8,
-                        &mut tmp as *mut T as *mut u8,
+                        tmp.as_mut_ptr() as *mut u8,
                         mem::size_of::<T>());
-    tmp
+    tmp.into_inner()
 }
 
 /// Overwrites a memory location with the given value without reading or
diff --git a/src/libcore/slice/rotate.rs b/src/libcore/slice/rotate.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 use cmp;
-use mem;
+use mem::{self, MaybeUninit};
 use ptr;
 
 /// Rotation is much faster if it has access to a little bit of memory. This
@@ -26,9 +26,6 @@ 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 }
     }
@@ -88,8 +85,8 @@ pub unsafe fn ptr_rotate<T>(mut left: usize, mid: *mut T, mut right: usize) {
         }
     }
 
-    let rawarray = RawArray::new();
-    let buf = rawarray.ptr();
+    let rawarray = MaybeUninit::<RawArray<T>>::uninitialized();
+    let buf = rawarray.get_ref().ptr();
 
     let dim = mid.sub(left).add(right);
     if left <= right {
diff --git a/src/libcore/slice/sort.rs b/src/libcore/slice/sort.rs
@@ -17,7 +17,7 @@
 //! stable sorting implementation.
 
 use cmp;
-use mem;
+use mem::{self, MaybeUninit};
 use ptr;
 
 /// When dropped, copies from `src` into `dest`.
@@ -226,14 +226,14 @@ fn partition_in_blocks<T, F>(v: &mut [T], pivot: &T, is_less: &mut F) -> usize
     let mut block_l = BLOCK;
     let mut start_l = ptr::null_mut();
     let mut end_l = ptr::null_mut();
-    let mut offsets_l: [u8; BLOCK] = unsafe { mem::uninitialized() };
+    let mut offsets_l = MaybeUninit::<[u8; BLOCK]>::uninitialized();
 
     // The current block on the right side (from `r.sub(block_r)` to `r`).
     let mut r = unsafe { l.add(v.len()) };
     let mut block_r = BLOCK;
     let mut start_r = ptr::null_mut();
     let mut end_r = ptr::null_mut();
-    let mut offsets_r: [u8; BLOCK] = unsafe { mem::uninitialized() };
+    let mut offsets_r = MaybeUninit::<[u8; BLOCK]>::uninitialized();
 
     // FIXME: When we get VLAs, try creating one array of length `min(v.len(), 2 * BLOCK)` rather
     // than two fixed-size arrays of length `BLOCK`. VLAs might be more cache-efficient.
@@ -272,8 +272,8 @@ fn partition_in_blocks<T, F>(v: &mut [T], pivot: &T, is_less: &mut F) -> usize
 
         if start_l == end_l {
             // Trace `block_l` elements from the left side.
-            start_l = offsets_l.as_mut_ptr();
-            end_l = offsets_l.as_mut_ptr();
+            start_l = unsafe { offsets_l.get_mut().as_mut_ptr() };
+            end_l = unsafe { offsets_l.get_mut().as_mut_ptr() };
             let mut elem = l;
 
             for i in 0..block_l {
@@ -288,8 +288,8 @@ fn partition_in_blocks<T, F>(v: &mut [T], pivot: &T, is_less: &mut F) -> usize
 
         if start_r == end_r {
             // Trace `block_r` elements from the right side.
-            start_r = offsets_r.as_mut_ptr();
-            end_r = offsets_r.as_mut_ptr();
+            start_r = unsafe { offsets_r.get_mut().as_mut_ptr() };
+            end_r = unsafe {  offsets_r.get_mut().as_mut_ptr() };
             let mut elem = r;
 
             for i in 0..block_r {

Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@`
`9`	`9`	`// except according to those terms.`
`10`	`10`
`11`	`11`	`use fmt::{Formatter, Result, LowerExp, UpperExp, Display, Debug};`
`12`		`-use mem;`
	`12`	`+use mem::MaybeUninit;`
`13`	`13`	`use num::flt2dec;`
`14`	`14`
`15`	`15`	`// 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,`
`20`	`20`	`where T: flt2dec::DecodableFloat`
`21`	`21`	`{`
`22`	`22`	`unsafe {`
`23`		`- let mut buf: [u8; 1024] = mem::uninitialized(); // enough for f32 and f64`
`24`		`- let mut parts: [flt2dec::Part; 4] = mem::uninitialized();`
	`23`	`+ let mut buf = MaybeUninit::<[u8; 1024]>::uninitialized(); // enough for f32 and f64`
	`24`	`+ let mut parts = MaybeUninit::<[flt2dec::Part; 4]>::uninitialized();`
`25`	`25`	`let formatted = flt2dec::to_exact_fixed_str(flt2dec::strategy::grisu::format_exact,`
`26`	`26`	`*num, sign, precision,`
`27`		`- false, &mut buf, &mut parts);`
	`27`	`+ false, buf.get_mut(), parts.get_mut());`
`28`	`28`	`fmt.pad_formatted_parts(&formatted)`
`29`	`29`	`}`
`30`	`30`	`}`
`@@ -38,10 +38,11 @@ fn float_to_decimal_common_shortest<T>(fmt: &mut Formatter, num: &T,`
`38`	`38`	`{`
`39`	`39`	`unsafe {`
`40`	`40`	`// enough for f32 and f64`
`41`		`- let mut buf: [u8; flt2dec::MAX_SIG_DIGITS] = mem::uninitialized();`
`42`		`- let mut parts: [flt2dec::Part; 4] = mem::uninitialized();`
	`41`	`+ let mut buf = MaybeUninit::<[u8; flt2dec::MAX_SIG_DIGITS]>::uninitialized();`
	`42`	`+ let mut parts = MaybeUninit::<[flt2dec::Part; 4]>::uninitialized();`
`43`	`43`	`let formatted = flt2dec::to_shortest_str(flt2dec::strategy::grisu::format_shortest, *num,`
`44`		`- sign, precision, false, &mut buf, &mut parts);`
	`44`	`+ sign, precision, false, buf.get_mut(),`
	`45`	`+ parts.get_mut());`
`45`	`46`	`fmt.pad_formatted_parts(&formatted)`
`46`	`47`	`}`
`47`	`48`	`}`
`@@ -75,11 +76,11 @@ fn float_to_exponential_common_exact<T>(fmt: &mut Formatter, num: &T,`
`75`	`76`	`where T: flt2dec::DecodableFloat`
`76`	`77`	`{`
`77`	`78`	`unsafe {`
`78`		`- let mut buf: [u8; 1024] = mem::uninitialized(); // enough for f32 and f64`
`79`		`- let mut parts: [flt2dec::Part; 6] = mem::uninitialized();`
	`79`	`+ let mut buf = MaybeUninit::<[u8; 1024]>::uninitialized(); // enough for f32 and f64`
	`80`	`+ let mut parts = MaybeUninit::<[flt2dec::Part; 6]>::uninitialized();`
`80`	`81`	`let formatted = flt2dec::to_exact_exp_str(flt2dec::strategy::grisu::format_exact,`
`81`	`82`	`*num, sign, precision,`
`82`		`- upper, &mut buf, &mut parts);`
	`83`	`+ upper, buf.get_mut(), parts.get_mut());`
`83`	`84`	`fmt.pad_formatted_parts(&formatted)`
`84`	`85`	`}`
`85`	`86`	`}`
`@@ -94,11 +95,11 @@ fn float_to_exponential_common_shortest<T>(fmt: &mut Formatter,`
`94`	`95`	`{`
`95`	`96`	`unsafe {`
`96`	`97`	`// enough for f32 and f64`
`97`		`- let mut buf: [u8; flt2dec::MAX_SIG_DIGITS] = mem::uninitialized();`
`98`		`- let mut parts: [flt2dec::Part; 6] = mem::uninitialized();`
	`98`	`+ let mut buf = MaybeUninit::<[u8; flt2dec::MAX_SIG_DIGITS]>::uninitialized();`
	`99`	`+ let mut parts = MaybeUninit::<[flt2dec::Part; 6]>::uninitialized();`
`99`	`100`	`let formatted = flt2dec::to_shortest_exp_str(flt2dec::strategy::grisu::format_shortest,`
`100`	`101`	`*num, sign, (0, 0), upper,`
`101`		`- &mut buf, &mut parts);`
	`102`	`+ buf.get_mut(), parts.get_mut());`
`102`	`103`	`fmt.pad_formatted_parts(&formatted)`
`103`	`104`	`}`
`104`	`105`	`}`