From 851acdd22dd2e99759e7f2f3e613ee9566ea0dcc Mon Sep 17 00:00:00 2001 From: Jorge Aparicio Date: Sun, 19 Aug 2018 17:45:31 +0200 Subject: [PATCH] core: fix deprecated warnings --- src/libcore/fmt/float.rs | 27 ++++++++++++++------------- src/libcore/lib.rs | 2 ++ src/libcore/ptr.rs | 32 ++++++++++++++------------------ src/libcore/slice/rotate.rs | 9 +++------ src/libcore/slice/sort.rs | 14 +++++++------- 5 files changed, 40 insertions(+), 44 deletions(-) diff --git a/src/libcore/fmt/float.rs b/src/libcore/fmt/float.rs index 03e7a9a49d8..d01cd012031 100644 --- 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(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(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(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(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 index 675e73e952c..3b7646fa268 100644 --- a/src/libcore/lib.rs +++ b/src/libcore/lib.rs @@ -246,6 +246,8 @@ #[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 index 57351822cc3..caea8881514 100644 --- a/src/libcore/ptr.rs +++ b/src/libcore/ptr.rs @@ -22,7 +22,7 @@ use fmt; use hash; use marker::{PhantomData, Unsize}; -use mem; +use mem::{self, MaybeUninit}; use nonzero::NonZero; use cmp::Ordering::{self, Less, Equal, Greater}; @@ -142,16 +142,12 @@ pub const fn null_mut() -> *mut T { 0 as *mut T } #[stable(feature = "rust1", since = "1.0.0")] pub unsafe fn swap(x: *mut T, y: *mut T) { // Give ourselves some scratch space to work with - let mut tmp: T = mem::uninitialized(); + let mut tmp = MaybeUninit::::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 a sequence of values at two mutable locations of the same type. @@ -224,8 +220,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::::uninitialized(); + let t = t.as_mut_ptr() as *mut u8; let x = x.add(i); let y = y.add(i); @@ -239,10 +235,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::::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); @@ -296,9 +292,9 @@ pub unsafe fn replace(dest: *mut T, mut src: T) -> T { #[inline] #[stable(feature = "rust1", since = "1.0.0")] pub unsafe fn read(src: *const T) -> T { - let mut tmp: T = mem::uninitialized(); - copy_nonoverlapping(src, &mut tmp, 1); - tmp + let mut tmp = MaybeUninit::::uninitialized(); + copy_nonoverlapping(src, tmp.get_mut(), 1); + tmp.into_inner() } /// Reads the value from `src` without moving it. This leaves the @@ -330,11 +326,11 @@ pub unsafe fn read(src: *const T) -> T { #[inline] #[stable(feature = "ptr_unaligned", since = "1.17.0")] pub unsafe fn read_unaligned(src: *const T) -> T { - let mut tmp: T = mem::uninitialized(); + let mut tmp = MaybeUninit::::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::()); - 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 index 0d182b84974..affe525ae46 100644 --- 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 { } impl RawArray { - 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(mut left: usize, mid: *mut T, mut right: usize) { } } - let rawarray = RawArray::new(); - let buf = rawarray.ptr(); + let rawarray = MaybeUninit::>::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 index e4c1fd03f9e..cf0c5d876ab 100644 --- 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(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 width(l: *mut T, r: *mut T) -> 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 width(l: *mut T, r: *mut T) -> 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 { -- 2.44.0