df1d6168f4
Previously, `Tree::from_enum`'s implementation branched into three disjoint
cases:
1. enums that uninhabited
2. enums for which all but one variant is uninhabited
3. enums with multiple inhabited variants
This branching (incorrectly) did not differentiate between variantful and
variantless uninhabited enums. In both cases, we assumed (and asserted) that
uninhabited enums are zero-sized types. This assumption is false for enums like:
enum Uninhabited { A(!, u128) }
...which, currently, has the same size as `u128`. This faulty assumption
manifested as the ICE reported in #126460.
In this PR, we revise the first case of `Tree::from_enum` to consider only the
narrow category of "enums that are uninhabited ZSTs". These enums, whose layouts
are described with `Variants::Single { index }`, are special in their layouts
otherwise resemble the `!` type and cannot be descended into like typical enums.
This first case captures uninhabited enums like:
enum Uninhabited { A(!, !), B(!) }
The second case is revised to consider the broader category of "enums that defer
their layout to one of their variants"; i.e., enums whose layouts are described
with `Variants::Single { index }` and that do have a variant at `index`. This
second case captures uninhabited enums that are not ZSTs, like:
enum Uninhabited { A(!, u128) }
...which represent their variants with `Variants::Single`.
Finally, the third case is revised to cover the broader category of "enums with
multiple variants", which captures uninhabited, non-ZST enums like:
enum Uninhabited { A(u8, !), B(!, u32) }
...which represent their variants with `Variants::Multiple`.
This PR also adds a comment requested by RalfJung in his review of #126358 to
`compiler/rustc_const_eval/src/interpret/discriminant.rs`.
Fixes #126460
33 lines
601 B
Rust
33 lines
601 B
Rust
//@ check-pass
|
|
//! Tests that we do not regress rust-lang/rust#125811
|
|
#![feature(transmutability)]
|
|
|
|
fn assert_transmutable<T>()
|
|
where
|
|
(): std::mem::BikeshedIntrinsicFrom<T>
|
|
{}
|
|
|
|
enum Uninhabited {}
|
|
|
|
enum SingleInhabited {
|
|
X,
|
|
Y(Uninhabited)
|
|
}
|
|
|
|
enum SingleUninhabited {
|
|
X(Uninhabited),
|
|
Y(Uninhabited),
|
|
}
|
|
|
|
enum MultipleUninhabited {
|
|
X(u8, Uninhabited),
|
|
Y(Uninhabited, u16),
|
|
}
|
|
|
|
fn main() {
|
|
assert_transmutable::<Uninhabited>();
|
|
assert_transmutable::<SingleInhabited>();
|
|
assert_transmutable::<SingleUninhabited>();
|
|
assert_transmutable::<MultipleUninhabited>();
|
|
}
|