Union of non-null types should not be non-null

[andrepd]

Example

use std::mem::size_of;
use std::num::NonZeroIsize;

type Foo = &'static i32;

type Bar = NonZeroIsize;

union FooBar {
    foo: Foo, 
    bar: Bar,
}

fn main() {
    println!("{} {}", size_of::<Foo>(), size_of::<Option<Foo>>());
    println!("{} {}", size_of::<Bar>(), size_of::<Option<Bar>>());
    println!("{} {}", size_of::<FooBar>(), size_of::<Option<FooBar>>());
}

Expected behaviour

Just as Option<Foo> and Option<Bar> have the same size as Foo and Bar respectively, I expected that Option<FooBar> also has the same size as FooBar. However this does not happen. Adding #[rustc_nonnull_optimization_guaranteed] does not seem to make a difference.

[deltragon]

AFAIK, this is undecided currently - see rust-lang/unsafe-code-guidelines#73 for more background/discussion on how to handle unions.

[RalfJung]

This is deliberate, unions are currently by design not having any niches. unions are used to do whacky low-level things with the underlying bytes, and e.g. we do not assume that the list of variants is actually exhaustive -- one might want to add new variants in a future-compatible way later (this is not an uncommon use of unions in C).

[andrepd]

AFAIK, this is undecided currently - see rust-lang/unsafe-code-guidelines#73 for more background/discussion on how to handle unions.

Thanks for the link! I read through pretty much the entire thread. Looks like there's much more to it that I thought.

[Noratrieb]

I don't think keeping this issue open will have too much value. The validity of unions are tracked on the opsem repo already. Feel free to reopen if you disagree.