I need statics with destructors for https://github.com/Kimundi/lazy-static.rs to not depend on dynamical allocations.

Since a program can always be terminated at arbitrary points without having its destructors run, having statics contain types with destructors that will never be run is not memory unsafe, and should be allowed.

As a proof, these two programs would be semantically equivalent:

fn main() {
    let FOO = /* moving type */;
    ...
    abort();
    // abort, 
    // process ends, 
    // FOOs destructor does not run
}

static FOO = /* moving type */;
fn main() {
    ...
    // end of main, 
    // process ends, 
    // FOOs destructor does not run
}

Why was this restriction added in the first place?

With the introduction of const fn and the conversion of forget to be safe, this is restriction is very likely not needed any more. What would be required to remove it? A new RFC, or just a compiler change?

I've started drafting a RFC to lift this restriction. https://github.com/thepowersgang/rust-lang_rfcs/blob/drop-types-in-const/text/0000-drop-types-in-const.md

@thepowersgang

This restriction was never needed for safety - you could always call exit(3)/_exit(2) and not call any destructor.

@arielb1 ... good point... so why did this restriction exist? To avoid surprises?

@thepowersgang

I don't have a ****** idea.

I think the restriction existed because rust was adamant to not support code outside of main ("global constructors and destructors").

This can be closed in favor of #1111 which has more details.

I think the restriction existed because rust was adamant to not support code outside of main ("global constructors and destructors").

We also were disillusioned about our capability to guarantee execution of destructors.

With #1440 merged this can probably be closed now.

Closing after having verified that everything works as expected.