Add MaybeUninit method array_assume_init

[joboet]

When initialising an array element-by-element, the conversion to the initialised array is done through mem::transmute, which is both ugly and does not work with const generics (see #61956). This PR proposes the associated method array_assume_init, matching the style of slice_assume_init_*:

unsafe fn array_assume_init<T, const N: usize>(array: [MaybeUninit<T>; N]) -> [T; N];

Example:

let mut array: [MaybeUninit<i32>; 3] = MaybeUninit::uninit_array();
array[0].write(0);
array[1].write(1);
array[2].write(2);

// SAFETY: Now safe as we initialised all elements
let array: [i32; 3] = unsafe {
     MaybeUninit::array_assume_init(array)
};

Things I'm unsure about:

• Should this be a method of array instead?
• Should the function be const?

[rust-highfive]

Thanks for the pull request, and welcome! The Rust team is excited to review your changes, and you should hear from @dtolnay (or someone else) soon.

If any changes to this PR are deemed necessary, please add them as extra commits. This ensures that the reviewer can see what has changed since they last reviewed the code. Due to the way GitHub handles out-of-date commits, this should also make it reasonably obvious what issues have or haven't been addressed. Large or tricky changes may require several passes of review and changes.

Please see the contribution instructions for more information.

[dtolnay]

This looks good to me. Could you please open a tracking issue or pick one of the existing maybeuninit ones to track this under?

[joboet]

Here it is: #80908

[dtolnay]

@bors r+

[bors]

📌 Commit dec8c03 has been approved by dtolnay

[rust-log-analyzer]

The job mingw-check failed! Check out the build log: (web) (plain)

Click to see the possible cause of the failure (guessed by this bot)

   Compiling unwind v0.0.0 (/checkout/library/unwind)
error[E0308]: mismatched types
   --> library/core/src/mem/maybe_uninit.rs:843:13
    |
242 | impl<T> MaybeUninit<T> {
    |      - this type parameter
...
835 |     pub unsafe fn array_assume_init<const N: usize>(array: [Self; N]) -> [T; N] {
    |                                                                          ------ expected `[T; N]` because of return type
...
843 |             (&array as *const _ as *const T).read()
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected array, found type parameter `T`
    |
    = note:       expected array `[T; N]`
            found type parameter `T`
error: aborting due to previous error

For more information about this error, try `rustc --explain E0308`.
error: could not compile `core`
error: could not compile `core`

To learn more, run the command again with --verbose.
command did not execute successfully: "/checkout/obj/build/x86_64-unknown-linux-gnu/stage0/bin/cargo" "check" "--target" "x86_64-unknown-linux-gnu" "-Zbinary-dep-depinfo" "-j" "16" "--release" "--color" "always" "--features" "panic-unwind backtrace compiler-builtins-c" "--manifest-path" "/checkout/library/test/Cargo.toml" "--message-format" "json-render-diagnostics"
failed to run: /checkout/obj/build/bootstrap/debug/bootstrap check
Build completed unsuccessfully in 0:01:16

[RalfJung]

Okay then let's @bors r- until the new implementation is done.

[dtolnay]

@bors r+

[bors]

📌 Commit 985071b has been approved by dtolnay

[ghost]

Is this assertion really correct?

I tried this code:

#![feature(maybe_uninit_array_assume_init)]

use std::mem::MaybeUninit;

enum Uninhabited {}

fn main() {
    unsafe {
        MaybeUninit::<Uninhabited>::array_assume_init([]);
    }
}

And it panicked with attempted to instantiate uninhabited type `Uninhabited`.

   Compiling playground v0.0.1 (/playground)
    Finished dev [unoptimized + debuginfo] target(s) in 1.12s
     Running `target/debug/playground`
thread 'main' panicked at 'attempted to instantiate uninhabited type `Uninhabited`', /rustc/f4eb5d9f719cd3c849befc8914ad8ce0ddcf34ed/library/core/src/mem/maybe_uninit.rs:842:13
stack backtrace:
   0: rust_begin_unwind
             at /rustc/f4eb5d9f719cd3c849befc8914ad8ce0ddcf34ed/library/std/src/panicking.rs:493:5
   1: core::panicking::panic_fmt
             at /rustc/f4eb5d9f719cd3c849befc8914ad8ce0ddcf34ed/library/core/src/panicking.rs:92:14
   2: core::panicking::panic
             at /rustc/f4eb5d9f719cd3c849befc8914ad8ce0ddcf34ed/library/core/src/panicking.rs:50:5
   3: core::mem::maybe_uninit::MaybeUninit<T>::array_assume_init
             at /rustc/f4eb5d9f719cd3c849befc8914ad8ce0ddcf34ed/library/core/src/mem/maybe_uninit.rs:842:13
   4: playground::main
             at ./src/main.rs:9:9
   5: core::ops::function::FnOnce::call_once
             at /rustc/f4eb5d9f719cd3c849befc8914ad8ce0ddcf34ed/library/core/src/ops/function.rs:227:5
note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.

But it seems that creating an array of uninhabited type with length of zero is not UB (playground):

#![forbid(unsafe_code)]

#[derive(Debug)]
enum Uninhabited {}

fn main() {
    let not_ub: [Uninhabited; 0] = [];
    dbg!(not_ub);
}

[RalfJung]

Good point! This should probably be

if N > 0 { assert_inhabited(); }

[ghost]

I'll submit a PR to fix it.