const-checking accepts some code that executes non-const drops

@tmiasko

Example 1

struct NotConstDestruct;

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

pub const _: () = {
    let mut a = Some(NotConstDestruct); //~ ERROR destructor of
    let b = NotConstDestruct;
    let p = &raw mut a;
    let x = unsafe { std::ptr::read(p) };
    std::mem::forget(a);
    std::mem::forget(x);
    a = None;
    unsafe { std::ptr::write(p, Some(b)) };
};

This should be fixed by #164081.

Example 2

use std::num::NonZero;

#[repr(transparent)]
struct NotConstDestruct(NonZero<u8>);

impl Drop for NotConstDestruct {
    fn drop(&mut self) {
        eprintln!("this is not const");
    }
}

enum MyOpt {
    None(()),
    Some(NotConstDestruct),
}

const _: () = {
    assert!(std::mem::size_of::<MyOpt>() == 1);
    let mut x = MyOpt::None(());
    let ptr = match x {
        MyOpt::None(ref mut field) => field as *mut (),
        _ => unreachable!(),
    };
    unsafe { ptr.cast::<u8>().write(1) };
};

See here for why this happens. There is no fix yet.

Cc @tmiasko @oli-obk

Another way to ICE (variant of "example 2"):

struct NotConstDestruct;

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

const _: () = {
    let mut x: (Option<NotConstDestruct>, u8) = (None, 0_u8);
    unsafe {
        (&raw mut x.1).sub(1).write(1);
    }
};

Another variant:

#![feature(const_trait_impl, const_closures)]

struct NotConstDestruct;

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

const _: () = {
    let x = None::<NotConstDestruct>;
    let mut y = 0_u8;
    let f = const move || {
        &x;
        unsafe { (&raw mut y).sub(1).write(1_u8); }
    };
    call_once(f);
};

const fn call_once(f: impl const FnOnce()) {
    f();
}

Another variant:

#![feature(const_trait_impl, const_destruct)]

struct NotConstDestruct;
impl Drop for NotConstDestruct {
    fn drop(&mut self) {}
}

struct Weird(u8);
const impl Drop for Weird {
    fn drop(&mut self) {
        unsafe { (&raw mut self.0).sub(1).write(1_u8) ; }
    }
}

const _: () = {
    let x = Weird(0_u8);
    let y = None::<NotConstDestruct>;
    let _ = move || {
        &x;
        &y;
    };
};

Another way to ICE:

#![feature(const_trait_impl, const_destruct)]

struct NotConstDestruct;
impl Drop for NotConstDestruct {
    fn drop(&mut self) {}
}

struct Weird(u8);
const impl Drop for Weird {
    fn drop(&mut self) {
        unsafe { (&raw mut self.0).add(1).write(1_u8) ; }
    }
}

const _: () = {
    let _ = (Weird(0_u8), None::<NotConstDestruct>);
};

Navigation Menu

Repository navigation

const-checking accepts some code that executes non-const drops #164194

Example 1

Example 2

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

const-checking accepts some code that executes non-const drops #164194

Description

Example 1

Example 2

Activity

theemathas commented on Oct 12, 2026

theemathas commented on Oct 12, 2026

theemathas commented on Oct 12, 2026

theemathas commented on Oct 12, 2026

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions