Skip to content

Commit fa08c41

Browse files
RalfJungRalfJung
committed
make no-variant types a dedicated Variants variant
1 parent 2b6afa6 commit fa08c41

File tree

53 files changed

+240
-486
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

53 files changed

+240
-486
lines changed

Diff for: ‎compiler/rustc_abi/src/callconv.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -206,7 +206,7 @@ impl<'a, Ty> TyAndLayout<'a, Ty> {
206206
let (mut result, mut total) = from_fields_at(*self, Size::ZERO)?;
207207

208208
match &self.variants {
209-
abi::Variants::Single { .. } => {}
209+
abi::Variants::Single { .. } | abi::Variants::Empty => {}
210210
abi::Variants::Multiple { variants, .. } => {
211211
// Treat enum variants like union members.
212212
// HACK(eddyb) pretend the `enum` field (discriminant)

Diff for: ‎compiler/rustc_abi/src/layout.rs

+10-9
Original file line numberDiff line numberDiff line change
@@ -120,7 +120,7 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
120120
.max_by_key(|niche| niche.available(dl));
121121

122122
LayoutData {
123-
variants: Variants::Single { index: Some(VariantIdx::new(0)) },
123+
variants: Variants::Single { index: VariantIdx::new(0) },
124124
fields: FieldsShape::Arbitrary {
125125
offsets: [Size::ZERO, b_offset].into(),
126126
memory_index: [0, 1].into(),
@@ -213,8 +213,9 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
213213
&self,
214214
) -> LayoutData<FieldIdx, VariantIdx> {
215215
let dl = self.cx.data_layout();
216+
// This is also used for uninhabited enums, so we use `Variants::Empty`.
216217
LayoutData {
217-
variants: Variants::Single { index: None },
218+
variants: Variants::Empty,
218219
fields: FieldsShape::Primitive,
219220
backend_repr: BackendRepr::Uninhabited,
220221
largest_niche: None,
@@ -385,7 +386,7 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
385386
};
386387

387388
Ok(LayoutData {
388-
variants: Variants::Single { index: Some(only_variant_idx) },
389+
variants: Variants::Single { index: only_variant_idx },
389390
fields: FieldsShape::Union(union_field_count),
390391
backend_repr: abi,
391392
largest_niche: None,
@@ -424,7 +425,7 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
424425
};
425426

426427
let mut st = self.univariant(&variants[v], repr, kind)?;
427-
st.variants = Variants::Single { index: Some(v) };
428+
st.variants = Variants::Single { index: v };
428429

429430
if is_unsafe_cell {
430431
let hide_niches = |scalar: &mut _| match scalar {
@@ -543,7 +544,7 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
543544
.iter_enumerated()
544545
.map(|(j, v)| {
545546
let mut st = self.univariant(v, repr, StructKind::AlwaysSized).ok()?;
546-
st.variants = Variants::Single { index: Some(j) };
547+
st.variants = Variants::Single { index: j };
547548

548549
align = align.max(st.align);
549550
max_repr_align = max_repr_align.max(st.max_repr_align);
@@ -736,7 +737,7 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
736737
repr,
737738
StructKind::Prefixed(min_ity.size(), prefix_align),
738739
)?;
739-
st.variants = Variants::Single { index: Some(i) };
740+
st.variants = Variants::Single { index: i };
740741
// Find the first field we can't move later
741742
// to make room for a larger discriminant.
742743
for field_idx in st.fields.index_by_increasing_offset() {
@@ -1004,8 +1005,8 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
10041005
Variants::Multiple { tag, tag_encoding, tag_field, .. } => {
10051006
Variants::Multiple { tag, tag_encoding, tag_field, variants: best_layout.variants }
10061007
}
1007-
Variants::Single { .. } => {
1008-
panic!("encountered a single-variant enum during multi-variant layout")
1008+
Variants::Single { .. } | Variants::Empty => {
1009+
panic!("encountered a single-variant or empty enum during multi-variant layout")
10091010
}
10101011
};
10111012
Ok(best_layout.layout)
@@ -1344,7 +1345,7 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
13441345
};
13451346

13461347
Ok(LayoutData {
1347-
variants: Variants::Single { index: Some(VariantIdx::new(0)) },
1348+
variants: Variants::Single { index: VariantIdx::new(0) },
13481349
fields: FieldsShape::Arbitrary { offsets, memory_index },
13491350
backend_repr: abi,
13501351
largest_niche,

Diff for: ‎compiler/rustc_abi/src/lib.rs

+6-4
Original file line numberDiff line numberDiff line change
@@ -1504,11 +1504,13 @@ impl BackendRepr {
15041504
#[derive(PartialEq, Eq, Hash, Clone, Debug)]
15051505
#[cfg_attr(feature = "nightly", derive(HashStable_Generic))]
15061506
pub enum Variants<FieldIdx: Idx, VariantIdx: Idx> {
1507+
/// A type with no valid variants. Must be uninhabited.
1508+
Empty,
1509+
15071510
/// Single enum variants, structs/tuples, unions, and all non-ADTs.
15081511
Single {
1509-
/// Always `Some(0)` for types without variants (i.e., everything except for `!`, enums, and
1510-
/// generators). `None` indicates an uninhabited type; this is used for zero-variant enums.
1511-
index: Option<VariantIdx>,
1512+
/// Always `0` for types that cannot have multiple variants.
1513+
index: VariantIdx,
15121514
},
15131515

15141516
/// Enum-likes with more than one variant: each variant comes with
@@ -1706,7 +1708,7 @@ impl<FieldIdx: Idx, VariantIdx: Idx> LayoutData<FieldIdx, VariantIdx> {
17061708
let size = scalar.size(cx);
17071709
let align = scalar.align(cx);
17081710
LayoutData {
1709-
variants: Variants::Single { index: Some(VariantIdx::new(0)) },
1711+
variants: Variants::Single { index: VariantIdx::new(0) },
17101712
fields: FieldsShape::Primitive,
17111713
backend_repr: BackendRepr::Scalar(scalar),
17121714
largest_niche,

Diff for: ‎compiler/rustc_codegen_cranelift/src/discriminant.rs

+4-3
Original file line numberDiff line numberDiff line change
@@ -18,8 +18,9 @@ pub(crate) fn codegen_set_discriminant<'tcx>(
1818
return;
1919
}
2020
match layout.variants {
21+
Variants::Empty => unreachable!("we already handled uninhabited types"),
2122
Variants::Single { index } => {
22-
assert_eq!(index.unwrap(), variant_index);
23+
assert_eq!(index, variant_index);
2324
}
2425
Variants::Multiple {
2526
tag: _,
@@ -85,11 +86,11 @@ pub(crate) fn codegen_get_discriminant<'tcx>(
8586
}
8687

8788
let (tag_scalar, tag_field, tag_encoding) = match &layout.variants {
89+
Variants::Empty => unreachable!("we already handled uninhabited types"),
8890
Variants::Single { index } => {
89-
let index = index.unwrap();
9091
let discr_val = layout
9192
.ty
92-
.discriminant_for_variant(fx.tcx, index)
93+
.discriminant_for_variant(fx.tcx, *index)
9394
.map_or(u128::from(index.as_u32()), |discr| discr.val);
9495

9596
let val = match dest_layout.ty.kind() {

Diff for: ‎compiler/rustc_codegen_gcc/src/type_of.rs

+3-3
Original file line numberDiff line numberDiff line change
@@ -99,14 +99,14 @@ fn uncached_gcc_type<'gcc, 'tcx>(
9999
if !cx.sess().fewer_names() =>
100100
{
101101
let mut name = with_no_trimmed_paths!(layout.ty.to_string());
102-
if let (&ty::Adt(def, _), &Variants::Single { index: Some(index) }) =
102+
if let (&ty::Adt(def, _), &Variants::Single { index }) =
103103
(layout.ty.kind(), &layout.variants)
104104
{
105105
if def.is_enum() && !def.variants().is_empty() {
106106
write!(&mut name, "::{}", def.variant(index).name).unwrap();
107107
}
108108
}
109-
if let (&ty::Coroutine(_, _), &Variants::Single { index: Some(index) }) =
109+
if let (&ty::Coroutine(_, _), &Variants::Single { index }) =
110110
(layout.ty.kind(), &layout.variants)
111111
{
112112
write!(&mut name, "::{}", ty::CoroutineArgs::variant_name(index)).unwrap();
@@ -230,7 +230,7 @@ impl<'tcx> LayoutGccExt<'tcx> for TyAndLayout<'tcx> {
230230

231231
// Check the cache.
232232
let variant_index = match self.variants {
233-
Variants::Single { index } => index,
233+
Variants::Single { index } => Some(index),
234234
_ => None,
235235
};
236236
let cached_type = cx.types.borrow().get(&(self.ty, variant_index)).cloned();

Diff for: ‎compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/cpp_like.rs

+12-14
Original file line numberDiff line numberDiff line change
@@ -205,21 +205,18 @@ pub(super) fn build_enum_type_di_node<'ll, 'tcx>(
205205
),
206206
|cx, enum_type_di_node| {
207207
match enum_type_and_layout.variants {
208-
Variants::Single { index: variant_index } => {
209-
let Some(variant_index) = variant_index else {
210-
// Uninhabited enums have Variants::Single. We don't generate
211-
// any members for them.
212-
return smallvec![];
213-
};
214-
215-
build_single_variant_union_fields(
216-
cx,
217-
enum_adt_def,
218-
enum_type_and_layout,
219-
enum_type_di_node,
220-
variant_index,
221-
)
208+
Variants::Empty => {
209+
// Uninhabited enums have Variants::Single. We don't generate
210+
// any members for them.
211+
return smallvec![];
222212
}
213+
Variants::Single { index: variant_index } => build_single_variant_union_fields(
214+
cx,
215+
enum_adt_def,
216+
enum_type_and_layout,
217+
enum_type_di_node,
218+
variant_index,
219+
),
223220
Variants::Multiple {
224221
tag_encoding: TagEncoding::Direct,
225222
ref variants,
@@ -287,6 +284,7 @@ pub(super) fn build_coroutine_di_node<'ll, 'tcx>(
287284
)
288285
}
289286
Variants::Single { .. }
287+
| Variants::Empty
290288
| Variants::Multiple { tag_encoding: TagEncoding::Niche { .. }, .. } => {
291289
bug!(
292290
"Encountered coroutine with non-direct-tag layout: {:?}",

Diff for: ‎compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/mod.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -366,7 +366,7 @@ fn compute_discriminant_value<'ll, 'tcx>(
366366
variant_index: VariantIdx,
367367
) -> DiscrResult {
368368
match enum_type_and_layout.layout.variants() {
369-
&Variants::Single { .. } => DiscrResult::NoDiscriminant,
369+
&Variants::Single { .. } | &Variants::Empty => DiscrResult::NoDiscriminant,
370370
&Variants::Multiple { tag_encoding: TagEncoding::Direct, .. } => DiscrResult::Value(
371371
enum_type_and_layout.ty.discriminant_for_variant(cx.tcx, variant_index).unwrap().val,
372372
),

Diff for: ‎compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/native.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -316,8 +316,8 @@ fn build_discr_member_di_node<'ll, 'tcx>(
316316
let containing_scope = enum_or_coroutine_type_di_node;
317317

318318
match enum_or_coroutine_type_and_layout.layout.variants() {
319-
// A single-variant enum has no discriminant.
320-
&Variants::Single { .. } => None,
319+
// A single-variant or no-variant enum has no discriminant.
320+
&Variants::Single { .. } | &Variants::Empty => None,
321321

322322
&Variants::Multiple { tag_field, .. } => {
323323
let tag_base_type = tag_base_type(cx.tcx, enum_or_coroutine_type_and_layout);

Diff for: ‎compiler/rustc_codegen_llvm/src/type_of.rs

+3-3
Original file line numberDiff line numberDiff line change
@@ -35,14 +35,14 @@ fn uncached_llvm_type<'a, 'tcx>(
3535
if !cx.sess().fewer_names() =>
3636
{
3737
let mut name = with_no_visible_paths!(with_no_trimmed_paths!(layout.ty.to_string()));
38-
if let (&ty::Adt(def, _), &Variants::Single { index: Some(index) }) =
38+
if let (&ty::Adt(def, _), &Variants::Single { index }) =
3939
(layout.ty.kind(), &layout.variants)
4040
{
4141
if def.is_enum() {
4242
write!(&mut name, "::{}", def.variant(index).name).unwrap();
4343
}
4444
}
45-
if let (&ty::Coroutine(_, _), &Variants::Single { index: Some(index) }) =
45+
if let (&ty::Coroutine(_, _), &Variants::Single { index }) =
4646
(layout.ty.kind(), &layout.variants)
4747
{
4848
write!(&mut name, "::{}", ty::CoroutineArgs::variant_name(index)).unwrap();
@@ -216,7 +216,7 @@ impl<'tcx> LayoutLlvmExt<'tcx> for TyAndLayout<'tcx> {
216216

217217
// Check the cache.
218218
let variant_index = match self.variants {
219-
Variants::Single { index } => index,
219+
Variants::Single { index } => Some(index),
220220
_ => None,
221221
};
222222
if let Some(llty) = cx.type_lowering.borrow().get(&(self.ty, variant_index)) {

Diff for: ‎compiler/rustc_codegen_ssa/src/debuginfo/mod.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -65,8 +65,8 @@ fn tag_base_type_opt<'tcx>(
6565
});
6666

6767
match enum_type_and_layout.layout.variants() {
68-
// A single-variant enum has no discriminant.
69-
Variants::Single { .. } => None,
68+
// A single-variant or no-variant enum has no discriminant.
69+
Variants::Single { .. } | Variants::Empty => None,
7070

7171
Variants::Multiple { tag_encoding: TagEncoding::Niche { .. }, tag, .. } => {
7272
// Niche tags are always normalized to unsized integers of the correct size.

Diff for: ‎compiler/rustc_codegen_ssa/src/mir/place.rs

+5-4
Original file line numberDiff line numberDiff line change
@@ -242,8 +242,9 @@ impl<'a, 'tcx, V: CodegenObject> PlaceRef<'tcx, V> {
242242
return bx.cx().const_poison(cast_to);
243243
}
244244
let (tag_scalar, tag_encoding, tag_field) = match self.layout.variants {
245+
Variants::Empty => unreachable!("we already handled uninhabited types"),
245246
Variants::Single { index } => {
246-
let index = index.unwrap(); // we already checked `is_uninhabited`
247+
// we already checked `is_uninhabited`
247248
let discr_val = self
248249
.layout
249250
.ty
@@ -365,9 +366,9 @@ impl<'a, 'tcx, V: CodegenObject> PlaceRef<'tcx, V> {
365366
return;
366367
}
367368
match self.layout.variants {
368-
Variants::Single { index } => {
369-
assert_eq!(index.unwrap(), variant_index);
370-
}
369+
Variants::Empty => unreachable!("we already handled uninhabited types"),
370+
Variants::Single { index } => assert_eq!(index, variant_index),
371+
371372
Variants::Multiple { tag_encoding: TagEncoding::Direct, tag_field, .. } => {
372373
let ptr = self.project_field(bx, tag_field);
373374
let to =

Diff for: ‎compiler/rustc_const_eval/src/interpret/discriminant.rs

+5-1
Original file line numberDiff line numberDiff line change
@@ -65,6 +65,9 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
6565
// We use "tag" to refer to how the discriminant is encoded in memory, which can be either
6666
// straight-forward (`TagEncoding::Direct`) or with a niche (`TagEncoding::Niche`).
6767
let (tag_scalar_layout, tag_encoding, tag_field) = match op.layout().variants {
68+
Variants::Empty => {
69+
throw_ub!(UninhabitedEnumVariantRead(None));
70+
}
6871
Variants::Single { index } => {
6972
if op.layout().is_uninhabited() {
7073
// For consistency with `write_discriminant`, and to make sure that
@@ -73,7 +76,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
7376
throw_ub!(UninhabitedEnumVariantRead(None));
7477
}
7578
// Since the type is inhabited, there must be an index.
76-
return interp_ok(index.unwrap());
79+
return interp_ok(index);
7780
}
7881
Variants::Multiple { tag, ref tag_encoding, tag_field, .. } => {
7982
(tag, tag_encoding, tag_field)
@@ -238,6 +241,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
238241
}
239242

240243
match layout.variants {
244+
abi::Variants::Empty => unreachable!("we already handled uninhabited types"),
241245
abi::Variants::Single { .. } => {
242246
// The tag of a `Single` enum is like the tag of the niched
243247
// variant: there's no tag as the discriminant is encoded

Diff for: ‎compiler/rustc_const_eval/src/interpret/validity.rs

+4-5
Original file line numberDiff line numberDiff line change
@@ -302,7 +302,7 @@ impl<'rt, 'tcx, M: Machine<'tcx>> ValidityVisitor<'rt, 'tcx, M> {
302302
};
303303
}
304304
}
305-
Variants::Single { .. } => {}
305+
Variants::Single { .. } | Variants::Empty => {}
306306
}
307307

308308
// Now we know we are projecting to a field, so figure out which one.
@@ -342,10 +342,9 @@ impl<'rt, 'tcx, M: Machine<'tcx>> ValidityVisitor<'rt, 'tcx, M> {
342342
match layout.variants {
343343
Variants::Single { index } => {
344344
// Inside a variant
345-
PathElem::Field(
346-
def.variant(index.unwrap()).fields[FieldIdx::from_usize(field)].name,
347-
)
345+
PathElem::Field(def.variant(index).fields[FieldIdx::from_usize(field)].name)
348346
}
347+
Variants::Empty => panic!("there is no field in Variants::Empty types"),
349348
Variants::Multiple { .. } => bug!("we handled variants above"),
350349
}
351350
}
@@ -1012,7 +1011,7 @@ impl<'rt, 'tcx, M: Machine<'tcx>> ValidityVisitor<'rt, 'tcx, M> {
10121011
}
10131012
// Don't forget potential other variants.
10141013
match &layout.variants {
1015-
Variants::Single { .. } => {
1014+
Variants::Single { .. } | Variants::Empty => {
10161015
// Fully handled above.
10171016
}
10181017
Variants::Multiple { variants, .. } => {

Diff for: ‎compiler/rustc_const_eval/src/interpret/visitor.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -218,8 +218,8 @@ pub trait ValueVisitor<'tcx, M: Machine<'tcx>>: Sized {
218218
// recurse with the inner type
219219
self.visit_variant(v, idx, &inner)?;
220220
}
221-
// For single-variant layouts, we already did anything there is to do.
222-
Variants::Single { .. } => {}
221+
// For single-variant layouts, we already did everything there is to do.
222+
Variants::Single { .. } | Variants::Empty => {}
223223
}
224224

225225
interp_ok(())

Diff for: ‎compiler/rustc_const_eval/src/util/check_validity_requirement.rs

+1
Original file line numberDiff line numberDiff line change
@@ -155,6 +155,7 @@ fn check_validity_requirement_lax<'tcx>(
155155
}
156156

157157
match &this.variants {
158+
Variants::Empty => return Ok(false),
158159
Variants::Single { .. } => {
159160
// All fields of this single variant have already been checked above, there is nothing
160161
// else to do.

0 commit comments

Comments
 (0)