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.
- // Creating a `[MaybeUninit; N]` array by first creating a
- // `MaybeUninit<[MaybeUninit; N]>`; the `into_inner` is safe because the inner
- // array does not require initialization.
- keys: MaybeUninit::uninitialized().into_inner(),
- vals: MaybeUninit::uninitialized().into_inner(),
+ keys: uninitialized_array![_; CAPACITY],
+ vals: uninitialized_array![_; CAPACITY],
parent: ptr::null(),
parent_idx: MaybeUninit::uninitialized(),
len: 0
unsafe fn new() -> Self {
InternalNode {
data: LeafNode::new(),
- // Creating a `[MaybeUninit; N]` array by first creating a
- // `MaybeUninit<[MaybeUninit; N]>`; the `into_inner` is safe because the inner
- // array does not require initialization.
- edges: MaybeUninit::uninitialized().into_inner(),
+ edges: uninitialized_array![_; 2*B],
}
}
}
// characters for a base 2 number.
let zero = T::zero();
let is_nonnegative = x >= zero;
- // Creating a `[MaybeUninit; N]` array by first creating a
- // `MaybeUninit<[MaybeUninit; N]>`; the `into_inner` is safe because the inner
- // array does not require initialization.
- let mut buf: [MaybeUninit<u8>; 128] = unsafe {
- MaybeUninit::uninitialized().into_inner()
- };
+ let mut buf = uninitialized_array![u8; 128];
let mut curr = buf.len();
let base = T::from_u8(Self::BASE);
if is_nonnegative {
// convert the negative num to positive by summing 1 to it's 2 complement
(!self.$conv_fn()).wrapping_add(1)
};
- // Creating a `[MaybeUninit; N]` array by first creating a
- // `MaybeUninit<[MaybeUninit; N]>`; the `into_inner` is safe because the inner
- // array does not require initialization.
- let mut buf: [MaybeUninit<u8>; 39] = unsafe {
- MaybeUninit::uninitialized().into_inner()
- };
+ let mut buf = uninitialized_array![u8; 39];
let mut curr = buf.len() as isize;
let buf_ptr = MaybeUninit::first_mut_ptr(&mut buf);
let lut_ptr = DEC_DIGITS_LUT.as_ptr();
#![feature(structural_match)]
#![feature(abi_unadjusted)]
#![feature(adx_target_feature)]
+#![feature(maybe_uninit)]
#[prelude_import]
#[allow(unused)]
($($arg:tt)+) => (panic!("not yet implemented: {}", format_args!($($arg)*)));
}
+/// A macro to create an array of [`MaybeUninit`]
+///
+/// This macro constructs and uninitialized array of the type `[MaybeUninit<K>; N]`.
+///
+/// [`MaybeUninit`]: mem/union.MaybeUninit.html
+#[macro_export]
+#[unstable(feature = "maybe_uninit", issue = "53491")]
+macro_rules! uninitialized_array {
+ // This `into_inner` is safe because an array of `MaybeUninit` does not
+ // require initialization.
+ // FIXME(#49147): Could be replaced by an array initializer, once those can
+ // be any const expression.
+ ($t:ty; $size:expr) => (unsafe {
+ MaybeUninit::<[MaybeUninit<$t>; $size]>::uninitialized().into_inner()
+ });
+}
+
/// Built-in macros to the compiler itself.
///
/// These macros do not have any corresponding definition with a `macro_rules!`
let mut block_l = BLOCK;
let mut start_l = ptr::null_mut();
let mut end_l = ptr::null_mut();
- // Creating a `[MaybeUninit; N]` array by first creating a
- // `MaybeUninit<[MaybeUninit; N]>`; the `into_inner` is safe because the inner
- // array does not require initialization.
- let mut offsets_l: [MaybeUninit<u8>; BLOCK] = unsafe {
- MaybeUninit::uninitialized().into_inner()
- };
+ let mut offsets_l: [MaybeUninit<u8>; BLOCK] = uninitialized_array![u8; BLOCK];
// 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: [MaybeUninit<u8>; BLOCK] = unsafe {
- MaybeUninit::uninitialized().into_inner()
- };
+ let mut offsets_r: [MaybeUninit<u8>; BLOCK] = uninitialized_array![u8; BLOCK];
// 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.