Add MaybeUninit::assume_init_drop.

library/core/src/mem/maybe_uninit.rs

@@ -2,6 +2,7 @@ use crate::any::type_name;
 use crate::fmt;
 use crate::intrinsics;
 use crate::mem::ManuallyDrop;
+use crate::ptr;
 
 /// A wrapper type to construct uninitialized instances of `T`.
 ///
@@ -573,6 +574,27 @@ impl<T> MaybeUninit<T> {
         }
     }
 
+    /// Drops the contained value in place.
+    ///
+    /// If you have ownership of the `MaybeUninit`, you can use [`assume_init`] instead.
+    ///
+    /// # Safety
+    ///
+    /// Calling this when the content is not yet fully initialized causes undefined
+    /// behavior: it is up to the caller to guarantee that the `MaybeUninit<T>` really
+    /// is in an initialized state.
+    ///
+    /// This function runs the destructor of the contained value in place.
+    /// Afterwards, the memory is considered uninitialized again, but remains unmodified.
+    ///
+    /// [`assume_init`]: MaybeUninit::assume_init
+    #[unstable(feature = "maybe_uninit_extra", issue = "63567")]
+    pub unsafe fn drop(&mut self) {
+        // SAFETY: the caller must guarantee that `self` is initialized.
+        // Dropping the value in place is safe if that is the case.
+        unsafe { ptr::drop_in_place(self.as_mut_ptr()) }
+    }
+
     /// Gets a shared reference to the contained value.
     ///
     /// This can be useful when we want to access a `MaybeUninit` that has been