const drop

Author: bend-n

library/core/src/array/mod.rs

@@ -105,7 +105,7 @@ pub fn repeat<T: Clone, const N: usize>(val: T) -> [T; N] {
 #[inline]
 #[stable(feature = "array_from_fn", since = "1.63.0")]
 #[rustc_const_unstable(feature = "const_array", issue = "none")]
-pub const fn from_fn<T, const N: usize, F>(f: F) -> [T; N]
+pub const fn from_fn<T: [const] Destruct, const N: usize, F>(f: F) -> [T; N]
 where
     F: [const] FnMut(usize) -> T + [const] Destruct,
 {
@@ -148,6 +148,7 @@ pub const fn try_from_fn<R, const N: usize, F>(cb: F) -> ChangeOutputType<R, [R:
 where
     F: [const] FnMut(usize) -> R + [const] Destruct,
     R: [const] Try<Residual: Residual<[R::Output; N]>>,
+    R::Output: [const] Destruct,
     <R::Residual as Residual<[R::Output; N]>>::TryType: [const] Try,
 {
     let mut array = [const { MaybeUninit::uninit() }; N];
@@ -548,6 +549,7 @@ impl<T, const N: usize> [T; N] {
     pub const fn map<F, U>(self, f: F) -> [U; N]
     where
         F: [const] FnMut(T) -> U + [const] Destruct,
+        U: [const] Destruct,
     {
         self.try_map(NeverShortCircuit::wrap_mut_1(f)).0
     }
@@ -588,6 +590,7 @@ impl<T, const N: usize> [T; N] {
     where
         F: [const] FnMut(T) -> R + [const] Destruct,
         R: [const] Try<Residual: Residual<[R::Output; N]>>,
+        R::Output: [const] Destruct,
         <R::Residual as Residual<[R::Output; N]>>::TryType: [const] Try,
     {
         #[rustc_const_unstable(feature = "array_try_map", issue = "79711")]
@@ -624,13 +627,11 @@ impl<T, const N: usize> [T; N] {
             for Guardian<'_, T, U, N, F>
         {
             fn drop(&mut self) {
-                if mem::needs_drop::<T>() {
-                    let mut n = self.moved;
-                    while n != N {
-                        // SAFETY: moved must always be < N
-                        unsafe { self.array.as_mut_ptr().add(n).read() };
-                        n += 1;
-                    }
+                let mut n = self.moved;
+                while n != N {
+                    // SAFETY: moved must always be < N
+                    unsafe { self.array.as_mut_ptr().add(n).drop_in_place() };
+                    n += 1;
                 }
             }
         }
@@ -938,6 +939,7 @@ const fn try_from_fn_erased<T, R, F>(
     mut generator: F,
 ) -> ControlFlow<R::Residual>
 where
+    T: [const] Destruct,
     R: [const] Try<Output = T>,
     F: [const] FnMut(usize) -> R + [const] Destruct,
 {
@@ -992,20 +994,14 @@ impl<T> Guard<'_, T> {
 }
 
 #[rustc_const_unstable(feature = "array_try_from_fn", issue = "89379")]
-impl<T> const Drop for Guard<'_, T> {
+impl<T: [const] Destruct> const Drop for Guard<'_, T> {
     #[inline]
     fn drop(&mut self) {
         debug_assert!(self.initialized <= self.array_mut.len());
-        crate::intrinsics::const_eval_select!(
-            @capture [T] { x: &mut Guard<'_, T> = self } -> ():
-            if const {}
-            else {
-                // SAFETY: this slice will contain only initialized objects.
-                unsafe {
-                    x.array_mut.get_unchecked_mut(..x.initialized).assume_init_drop();
-                }
-            }
-        );
+        // SAFETY: this slice will contain only initialized objects.
+        unsafe {
+            self.array_mut.get_unchecked_mut(..self.initialized).assume_init_drop();
+        }
     }
 }
 

library/core/src/mem/maybe_uninit.rs

@@ -1389,8 +1389,12 @@ impl<T> [MaybeUninit<T>] {
     /// non-null. Dropping such a `Vec<T>` however will cause undefined
     /// behaviour.
     #[unstable(feature = "maybe_uninit_slice", issue = "63569")]
+    #[rustc_const_unstable(feature = "maybe_uninit_slice", issue = "63569")]
     #[inline(always)]
-    pub unsafe fn assume_init_drop(&mut self) {
+    pub const unsafe fn assume_init_drop(&mut self)
+    where
+        T: [const] crate::marker::Destruct,
+    {
         if !self.is_empty() {
             // SAFETY: the caller must guarantee that every element of `self`
             // is initialized and satisfies all invariants of `T`.

library/core/src/ptr/mod.rs

@@ -403,7 +403,7 @@
 
 use crate::cmp::Ordering;
 use crate::intrinsics::const_eval_select;
-use crate::marker::{FnPtr, PointeeSized};
+use crate::marker::{Destruct, FnPtr, PointeeSized};
 use crate::mem::{self, MaybeUninit, SizedTypeProperties};
 use crate::num::NonZero;
 use crate::{fmt, hash, intrinsics, ub_checks};
@@ -801,7 +801,8 @@ pub const unsafe fn write_bytes<T>(dst: *mut T, val: u8, count: usize) {
 #[lang = "drop_in_place"]
 #[allow(unconditional_recursion)]
 #[rustc_diagnostic_item = "ptr_drop_in_place"]
-pub unsafe fn drop_in_place<T: PointeeSized>(to_drop: *mut T) {
+#[rustc_const_unstable(feature = "const_drop_in_place", issue = "none")]
+pub const unsafe fn drop_in_place<T: PointeeSized + [const] Destruct>(to_drop: *mut T) {
     // Code here does not matter - this is replaced by the
     // real drop glue by the compiler.
 

library/core/src/ptr/mut_ptr.rs

@@ -1390,8 +1390,12 @@ impl<T: PointeeSized> *mut T {
     ///
     /// [`ptr::drop_in_place`]: crate::ptr::drop_in_place()
     #[stable(feature = "pointer_methods", since = "1.26.0")]
+    #[rustc_const_unstable(feature = "const_drop_in_place", issue = "none")]
     #[inline(always)]
-    pub unsafe fn drop_in_place(self) {
+    pub const unsafe fn drop_in_place(self)
+    where
+        T: [const] Destruct,
+    {
         // SAFETY: the caller must uphold the safety contract for `drop_in_place`.
         unsafe { drop_in_place(self) }
     }

src/tools/miri/tests/fail/stacked_borrows/drop_in_place_retag.stderr

@@ -1,8 +1,8 @@
 error: Undefined Behavior: trying to retag from <TAG> for Unique permission at ALLOC[0x0], but that tag only grants SharedReadOnly permission for this location
   --> RUSTLIB/core/src/ptr/mod.rs:LL:CC
    |
-LL | pub unsafe fn drop_in_place<T: PointeeSized>(to_drop: *mut T) {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this error occurs as part of retag at ALLOC[0x0..0x1]
+LL | pub const unsafe fn drop_in_place<T: PointeeSized + [const] Destruct>(to_drop: *mut T) {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this error occurs as part of retag at ALLOC[0x0..0x1]
    |
    = help: this indicates a potential bug in the program: it performed an invalid operation, but the Stacked Borrows rules it violated are still experimental
    = help: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/stacked-borrows.md for further information

src/tools/miri/tests/fail/unaligned_pointers/drop_in_place.stderr

@@ -1,8 +1,8 @@
 error: Undefined Behavior: constructing invalid value: encountered an unaligned reference (required ALIGN byte alignment but found ALIGN)
   --> RUSTLIB/core/src/ptr/mod.rs:LL:CC
    |
-LL | pub unsafe fn drop_in_place<T: PointeeSized>(to_drop: *mut T) {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
+LL | pub const unsafe fn drop_in_place<T: PointeeSized + [const] Destruct>(to_drop: *mut T) {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information