Compiler Explorer

Source code

use std::mem::ManuallyDrop;
use std::ops::DerefMut;
use std::ops::Deref;
use std::mem::MaybeUninit;

/// Represents an initialized MaybeUninit. The contained value is dropped with this
/// evidence.
///
/// Safety: The referenced MaybeUninit is initialized
struct SurelyInit<'u, T>(&'u mut MaybeUninit<T>);

impl<'u, T> SurelyInit<'u, T> {
    /// Writes a value into the MaybeUninit and returns evidence of initialization.
    /// Any previous value is overwritten without its drop impl being called.
    fn init(this: &'u mut MaybeUninit<T>, value: T) -> Self {
        this.write(value);
        // Safety: the MaybeUninit has been initialized.
        unsafe { Self::assume_init(this) }
    }
    /// Safety: must ensure that the MaybeUninit is initialized
    unsafe fn assume_init(this: &'u mut MaybeUninit<T>) -> Self {
        // Safety: by the caller contract
        Self(this)
    }
    /// Reads the value from the underlying MaybeUninit and "deinitializes" it.
    fn take(self) -> T {
        // We will shortly replace the contents destructively. Make sure no drop happens
        // on the uninitialized replacement
        let mut this = ManuallyDrop::new(self);
        // Allow the compiler to replace the old value with any garbage.
        // Subtly, this also allows the compiler to omit the copy all together and overwrite
        // and destructively consume whatever value exists here
        let old = std::mem::replace(this.0, MaybeUninit::uninit());
        // Safety: The old value is assumed to have been initialized
        //         The value read is not dropped twice.
        unsafe { old.assume_init() }
    }
}

impl<'u, T> Deref for SurelyInit<'u, T> {
    type Target = T;

fn deref(&self) -> &T {
        unsafe { self.0.assume_init_ref() }
    }
}

impl<'u, T> DerefMut for SurelyInit<'u, T> {
    fn deref_mut(&mut self) -> &mut T {
        unsafe { self.0.assume_init_mut() }
    }
}

impl<'u, T> Drop for SurelyInit<'u, T> {
    fn drop(&mut self) {
        unsafe { self.0.assume_init_drop() }
    }
}

struct LargeStruct([u8; 2048]);

#[inline(never)]
fn consume(place: SurelyInit<'_, LargeStruct>) -> u8 {
    std::hint::black_box(&*place); // Make sure to touch all the data. Otherwise the compiler might get the idea to only initialize half the value
    let data = place.take();
    data.0[1337]
}
#[inline(never)]
fn consume_by_ptr(ptr: *mut LargeStruct) -> u8 {
    let data = unsafe { &*ptr };
    std::hint::black_box(data); // Make sure to touch all the data. Otherwise the compiler might get the idea to only initialize half the value
    // In reality, we want to move out of this, not just copy data. Simulate only "picking out the data we need"
    // which should optimize better. We want to show that the above 'consume' doesn't generate
    // worse assembly
    data.0[1337]
}
#[inline(never)]
fn genlarge() -> LargeStruct {
    std::hint::black_box(LargeStruct([32; 2048]))
}
pub fn main() {
    let mut place = MaybeUninit::uninit();
    let this = SurelyInit::init(&mut place, genlarge());
    println!("{}", consume(this));
    let mut other = genlarge();
    println!("{}", consume_by_ptr(&mut other));
}