Tracking Issue for `const_destruct`

[compiler-errors]

Feature gate: #![feature(const_destruct)]

This is a tracking issue for const_destruct, which enables the naming of the Destruct trait and its use in ~const bounds to allow dropping values in const contexts.

Public API

pub trait Destruct { }

Steps / History

• Implementation: It was already implemented, but it's getting a new feature gate in Implement ~const Destruct effect goal in the new solver #132329.
• Final comment period (FCP)¹
• Stabilization PR

Unresolved Questions

• Do we want to allow ~const bounds on const Drop impls?

I think we do, and sorely need them for const drop to ever be useful. See my justification in #132329 (comment). We want to be able to implement a conditional drop impl like:

struct DropAndCall<F: Fn()>(F);

impl<F> const Drop for DropAndCall<F>
where
    F: ~const Fn(),
{
    fn drop(&mut self) {
        (self.0)(); // This should be allowed.
    }
}

This is what is implemented on nightly.

Footnotes

1. https://std-dev-guide.rust-lang.org/feature-lifecycle/stabilization.html ↩

[RalfJung]

Cc @rust-lang/wg-const-eval

[gamozolabs]

Should we be able to compile code like this https://play.rust-lang.org/?version=nightly&mode=debug&edition=2024&gist=732816bc01b89398f1806c0ea207976a .

#![feature(const_destruct)]
#![feature(const_trait_impl)]

use std::mem::ManuallyDrop;

struct Moose;

impl Drop for Moose {
    fn drop(&mut self) {}
}

struct ConstDropper<T>(ManuallyDrop<T>);

impl<T> const Drop for ConstDropper<T> {
    fn drop(&mut self) {}
}

const fn foo(_var: ConstDropper<Moose>) {}

Such that a wrapper around a type with a ManuallyDrop would allow dropping in a const environment? Currently this fails with destructor of `ConstDropper<Moose>` cannot be evaluated at compile-time.

I suspect this is due to the in_any_value_of_ty being unaware of the disablement of Drop glue around ManuallyDrop? Would also need to get it to work with MaybeUninit and friends too (which I think use ManuallyDrop under the hood?)

[oli-obk]

Considering that

use std::mem::ManuallyDrop;

struct Moose;

impl Drop for Moose {
    fn drop(&mut self) {}
}

struct ConstDropper<T>(ManuallyDrop<T>);

const fn foo(_var: ConstDropper<Moose>) {}

compiles fine on stable, yes, we should support that very much 😆 I have a branch working, will open a PR soon

[gamozolabs]

Considering that

use std::mem::ManuallyDrop;

struct Moose;

impl Drop for Moose {
fn drop(&mut self) {}
}

struct ConstDropper(ManuallyDrop);

const fn foo(_var: ConstDropper) {}

compiles fine on stable, yes, we should support that very much 😆 I have a branch working, will open a PR soon

Awesome! This is the exact same change I had sitting in my branch!