attribute to reserve None value on Option<enum>

[npmccallum]

For example:

#[repr(u8)]
#[reserved(0)]
enum Foo {
    Bar = 17,
    Baz = 32,
}

fn main() {
    assert_eq!(std::mem::size_of::<Option<Foo>>(), std::mem::size_of::<Foo>());

    let foo: Option<Foo> = None;
    let byte: u8 = std::mem::transmute(foo);
    println!("{}", byte); // Prints 0
}

This would be incredibly useful in FFI situations. Often there is an enum of values for which a particular value (usually zero) is reserved to represent "none" or "invalid" or "empty". This would make translation into idiomatic Rust both easy and safe.

Rust already optimizes Option<enum> this way. However, it always selects the highest used discriminant + 1 to represent None (this is likely undefined behavior). Having control over this value simply makes the behavior defined. It would also mean that the compiler could warn if there was any attempt to use the reserved value in an actual enumeration item.

[npmccallum]

Please keep in mind I have several cases where the "special" number is non-zero. So while zero is the dominant value in FFI, there are uses of other values.

[estebank]

I'm intrigued if some special syntax to address this case in a general way would be reasonable. Something along the lines of

#[repr(u8)]
enum Foo {
    Bar = 1,
    Baz = 2,
    #[repr(reserved=Option::None)]
    _ = 0,
    #[repr(reserved)]
    _ = 42..100,
}

I don't know enough about this space if it's a common need to specify different "holes" for different container types, or even different formats for the same underlying type depending what outwardly interfacing endpoint it is used in.

[npmccallum]

@estebank I think that is a fair question. As of right now, Rust will do this optimization using any enum encapsulation. It is not just limited to Option<T>. It might be useful to find a way to express this more flexibly.