Option<char> should be represented as just one 32 bit value

[Kimundi]

A char is a u32, but Unicode is standardized to only take up 21bit, so there is more than enough space for that optimization.

Might be useful for specifying code page conversion tables with holes in them.

[msullivan]

In the same vein as #6791. Is a reasonable optimization but probably not critical. We do similar optimizations for pointer types, I think.

[thestinger]

Okay, this would mean representing Some(char) as the zero tag and None with the non-zero tag. If we fix char to actually always be 21-bit, that would work.

[thestinger]

Once #8974 lands, we can go ahead with this.

[Thiez]

If the compiler knew about possible values a type could take perhaps it could make these optimizations automatically? E.g. an ASCII character can have values in the range 0-127, so Option<ASCII> could automatically get optimized to 1 byte.
The following could be optimized to a single byte as well.

enum T {
    On,
    Off
}
enum Repeats {
    Zero
    One(T),
    Two(T,T),
    Three(T,T,T)
    Four(T,T,T,T)
    Five(T,T,T,T,T)
}

Because Repeats has 6 variants it can use 3 tag bits, and T uses 1 bit, so the largest variant uses 5 bits for the data, it all fits in a byte.

[huonw]

@Thiez what happens for:

match repeats {
    Five(ref x, _, _, _, _) => {}
    _ => {}
}

it'd have to be able to handle sub-word references.

[thestinger]

This will only work for Option. The compiler knows the high bits will always be zero for char so it can reuse one of them as the tag, with zero representing a Some(char) and non-zero representing None. It can't actually set any of the bits or references won't work.

[glaebhoerl]

I think it would work for any enum with up to 2047 nullary variants and one variant containing a char.

[thestinger]

If you set any of the bits in the char, a reference to the char will be corrupt.

[bluss]

Can this case be extended to bool as well? it has 7 unused bits.

[glaebhoerl]

@thestinger: Yes. But if you have:

enum MaybeChar {
    HasChar(char),
    NoChar_0,
    NoChar_1,
    NoChar_2,
    ...,
    NoChar_N
}

You can freely use up to 11 bits to represent which variant it is, with the restriction that zero is reserved for HasChar.

[alexcrichton]

We now have range asserts on char, so this is more possible than it was before.

[huonw]

Similar to #14540.

[Yoric]

If someone can mentor me through this bug, I'd be interested in giving it a try.

[pnkfelix]

@Yoric one starting point to look would be src/librustc_trans/trans/adt.rs ; you might look over how PR #19765 changed that file to expand how we search for potential discriminant representations in an enum.

[mrhota]

FYI @pnkfelix I rebased @Yoric's work onto @eddyb's recent PR #35764

I'll wait for that to land, then I'll issue a PR for Yoric's rebased work.

[frewsxcv]

For anyone wanting to see the status of this, here's code you can run:

fn main() {
    println!("{}", ::std::mem::size_of::<Option<char>>());
}

playpen

it currently prints '8' (bytes)