Skip to content

Commit e023590

Browse files
RalfJungRalfJung
committed
make no-variant types a dedicated Variants variant
1 parent 21de42b commit e023590

File tree

53 files changed

+246
-495
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

+246
-495
lines changed

‎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)

‎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,

‎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,

‎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() {

‎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();

‎compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/cpp_like.rs

+12-14
Original file line numberDiff line numberDiff line change
@@ -212,21 +212,18 @@ pub(super) fn build_enum_type_di_node<'ll, 'tcx>(
212212
),
213213
|cx, enum_type_di_node| {
214214
match enum_type_and_layout.variants {
215-
Variants::Single { index: variant_index } => {
216-
let Some(variant_index) = variant_index else {
217-
// Uninhabited enums have Variants::Single. We don't generate
218-
// any members for them.
219-
return smallvec![];
220-
};
221-
222-
build_single_variant_union_fields(
223-
cx,
224-
enum_adt_def,
225-
enum_type_and_layout,
226-
enum_type_di_node,
227-
variant_index,
228-
)
215+
Variants::Empty => {
216+
// Uninhabited enums have Variants::Single. We don't generate
217+
// any members for them.
218+
return smallvec![];
229219
}
220+
Variants::Single { index: variant_index } => build_single_variant_union_fields(
221+
cx,
222+
enum_adt_def,
223+
enum_type_and_layout,
224+
enum_type_di_node,
225+
variant_index,
226+
),
230227
Variants::Multiple {
231228
tag_encoding: TagEncoding::Direct,
232229
ref variants,
@@ -303,6 +300,7 @@ pub(super) fn build_coroutine_di_node<'ll, 'tcx>(
303300
)
304301
}
305302
Variants::Single { .. }
303+
| Variants::Empty
306304
| Variants::Multiple { tag_encoding: TagEncoding::Niche { .. }, .. } => {
307305
bug!(
308306
"Encountered coroutine with non-direct-tag layout: {:?}",

‎compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/mod.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -392,7 +392,7 @@ fn compute_discriminant_value<'ll, 'tcx>(
392392
variant_index: VariantIdx,
393393
) -> DiscrResult {
394394
match enum_type_and_layout.layout.variants() {
395-
&Variants::Single { .. } => DiscrResult::NoDiscriminant,
395+
&Variants::Single { .. } | &Variants::Empty => DiscrResult::NoDiscriminant,
396396
&Variants::Multiple { tag_encoding: TagEncoding::Direct, .. } => DiscrResult::Value(
397397
enum_type_and_layout.ty.discriminant_for_variant(cx.tcx, variant_index).unwrap().val,
398398
),

‎compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/native.rs

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

360360
match enum_or_coroutine_type_and_layout.layout.variants() {
361-
// A single-variant enum has no discriminant.
362-
&Variants::Single { .. } => None,
361+
// A single-variant or no-variant enum has no discriminant.
362+
&Variants::Single { .. } | &Variants::Empty => None,
363363

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

‎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)) {

‎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.

‎compiler/rustc_codegen_ssa/src/mir/place.rs

+4-4
Original file line numberDiff line numberDiff line change
@@ -243,8 +243,8 @@ impl<'a, 'tcx, V: CodegenObject> PlaceRef<'tcx, V> {
243243
return bx.cx().const_poison(cast_to);
244244
}
245245
let (tag_scalar, tag_encoding, tag_field) = match self.layout.variants {
246+
Variants::Empty => unreachable!("we already handled uninhabited types"),
246247
Variants::Single { index } => {
247-
let index = index.unwrap(); // we already checked `is_uninhabited`
248248
let discr_val = self
249249
.layout
250250
.ty
@@ -366,9 +366,9 @@ impl<'a, 'tcx, V: CodegenObject> PlaceRef<'tcx, V> {
366366
return;
367367
}
368368
match self.layout.variants {
369-
Variants::Single { index } => {
370-
assert_eq!(index.unwrap(), variant_index);
371-
}
369+
Variants::Empty => unreachable!("we already handled uninhabited types"),
370+
Variants::Single { index } => assert_eq!(index, variant_index),
371+
372372
Variants::Multiple { tag_encoding: TagEncoding::Direct, tag_field, .. } => {
373373
let ptr = self.project_field(bx, tag_field);
374374
let to =

‎compiler/rustc_const_eval/src/interpret/discriminant.rs

+6-2
Original file line numberDiff line numberDiff line change
@@ -65,15 +65,18 @@ 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
7174
// `project_downcast` cannot fail due to strange layouts, we declare immediate UB
7275
// for uninhabited enums.
73-
throw_ub!(UninhabitedEnumVariantRead(None));
76+
throw_ub!(UninhabitedEnumVariantRead(Some(index)));
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

‎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, .. } => {

‎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(())

‎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)