Skip to content

Commit 7a5376d

Browse files
petrochenkovpetrochenkov
committed
Unreserve braced enum variants in value namespace
1 parent 1cbc459 commit 7a5376d

File tree

71 files changed

+364
-642
lines changed

Some content is hidden

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

71 files changed

+364
-642
lines changed

‎compiler/rustc_ast/src/ast.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -2664,7 +2664,7 @@ impl VariantData {
26642664
}
26652665

26662666
/// Return the `NodeId` of this variant's constructor, if it has one.
2667-
pub fn ctor_id(&self) -> Option<NodeId> {
2667+
pub fn ctor_node_id(&self) -> Option<NodeId> {
26682668
match *self {
26692669
VariantData::Struct(..) => None,
26702670
VariantData::Tuple(_, id) | VariantData::Unit(id) => Some(id),

‎compiler/rustc_borrowck/src/diagnostics/mod.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -350,7 +350,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
350350
} else {
351351
def.non_enum_variant()
352352
};
353-
if !including_tuple_field.0 && variant.ctor_kind == CtorKind::Fn {
353+
if !including_tuple_field.0 && variant.ctor_kind() == Some(CtorKind::Fn) {
354354
return None;
355355
}
356356
Some(variant.fields[field.index()].name.to_string())

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

+1-1
Original file line numberDiff line numberDiff line change
@@ -998,7 +998,7 @@ fn build_struct_type_di_node<'ll, 'tcx>(
998998
.iter()
999999
.enumerate()
10001000
.map(|(i, f)| {
1001-
let field_name = if variant_def.ctor_kind == CtorKind::Fn {
1001+
let field_name = if variant_def.ctor_kind() == Some(CtorKind::Fn) {
10021002
// This is a tuple struct
10031003
tuple_field_name(i)
10041004
} else {

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

+1-1
Original file line numberDiff line numberDiff line change
@@ -269,7 +269,7 @@ fn build_enum_variant_struct_type_di_node<'ll, 'tcx>(
269269
|cx, struct_type_di_node| {
270270
(0..variant_layout.fields.count())
271271
.map(|field_index| {
272-
let field_name = if variant_def.ctor_kind != CtorKind::Fn {
272+
let field_name = if variant_def.ctor_kind() != Some(CtorKind::Fn) {
273273
// Fields have names
274274
Cow::from(variant_def.fields[field_index].name.as_str())
275275
} else {

‎compiler/rustc_hir/src/def.rs

+4-18
Original file line numberDiff line numberDiff line change
@@ -28,8 +28,6 @@ pub enum CtorKind {
2828
Fn,
2929
/// Constructor constant automatically created by a unit struct/variant.
3030
Const,
31-
/// Unusable name in value namespace created by a struct variant.
32-
Fictive,
3331
}
3432

3533
/// An attribute that is not a macro; e.g., `#[inline]` or `#[rustfmt::skip]`.
@@ -132,13 +130,9 @@ impl DefKind {
132130
DefKind::Variant => "variant",
133131
DefKind::Ctor(CtorOf::Variant, CtorKind::Fn) => "tuple variant",
134132
DefKind::Ctor(CtorOf::Variant, CtorKind::Const) => "unit variant",
135-
DefKind::Ctor(CtorOf::Variant, CtorKind::Fictive) => "struct variant",
136133
DefKind::Struct => "struct",
137134
DefKind::Ctor(CtorOf::Struct, CtorKind::Fn) => "tuple struct",
138135
DefKind::Ctor(CtorOf::Struct, CtorKind::Const) => "unit struct",
139-
DefKind::Ctor(CtorOf::Struct, CtorKind::Fictive) => {
140-
panic!("impossible struct constructor")
141-
}
142136
DefKind::OpaqueTy => "opaque type",
143137
DefKind::ImplTraitPlaceholder => "opaque type in trait",
144138
DefKind::TyAlias => "type alias",
@@ -562,19 +556,11 @@ impl<T> PerNS<Option<T>> {
562556
}
563557

564558
impl CtorKind {
565-
pub fn from_ast(vdata: &ast::VariantData) -> CtorKind {
566-
match *vdata {
567-
ast::VariantData::Tuple(..) => CtorKind::Fn,
568-
ast::VariantData::Unit(..) => CtorKind::Const,
569-
ast::VariantData::Struct(..) => CtorKind::Fictive,
570-
}
571-
}
572-
573-
pub fn from_hir(vdata: &hir::VariantData<'_>) -> CtorKind {
559+
pub fn from_ast(vdata: &ast::VariantData) -> Option<(CtorKind, NodeId)> {
574560
match *vdata {
575-
hir::VariantData::Tuple(..) => CtorKind::Fn,
576-
hir::VariantData::Unit(..) => CtorKind::Const,
577-
hir::VariantData::Struct(..) => CtorKind::Fictive,
561+
ast::VariantData::Tuple(_, node_id) => Some((CtorKind::Fn, node_id)),
562+
ast::VariantData::Unit(node_id) => Some((CtorKind::Const, node_id)),
563+
ast::VariantData::Struct(..) => None,
578564
}
579565
}
580566
}

‎compiler/rustc_hir/src/hir.rs

+17-8
Original file line numberDiff line numberDiff line change
@@ -2913,20 +2913,29 @@ impl<'hir> VariantData<'hir> {
29132913
}
29142914
}
29152915

2916-
/// Return the `LocalDefId` of this variant's constructor, if it has one.
2917-
pub fn ctor_def_id(&self) -> Option<LocalDefId> {
2916+
pub fn ctor(&self) -> Option<(CtorKind, HirId, LocalDefId)> {
29182917
match *self {
2919-
VariantData::Struct(_, _) => None,
2920-
VariantData::Tuple(_, _, def_id) | VariantData::Unit(_, def_id) => Some(def_id),
2918+
VariantData::Tuple(_, hir_id, def_id) => Some((CtorKind::Fn, hir_id, def_id)),
2919+
VariantData::Unit(hir_id, def_id) => Some((CtorKind::Const, hir_id, def_id)),
2920+
VariantData::Struct(..) => None,
29212921
}
29222922
}
29232923

2924+
#[inline]
2925+
pub fn ctor_kind(&self) -> Option<CtorKind> {
2926+
self.ctor().map(|(kind, ..)| kind)
2927+
}
2928+
29242929
/// Return the `HirId` of this variant's constructor, if it has one.
2930+
#[inline]
29252931
pub fn ctor_hir_id(&self) -> Option<HirId> {
2926-
match *self {
2927-
VariantData::Struct(_, _) => None,
2928-
VariantData::Tuple(_, hir_id, _) | VariantData::Unit(hir_id, _) => Some(hir_id),
2929-
}
2932+
self.ctor().map(|(_, hir_id, _)| hir_id)
2933+
}
2934+
2935+
/// Return the `LocalDefId` of this variant's constructor, if it has one.
2936+
#[inline]
2937+
pub fn ctor_def_id(&self) -> Option<LocalDefId> {
2938+
self.ctor().map(|(.., def_id)| def_id)
29302939
}
29312940
}
29322941

‎compiler/rustc_hir_analysis/src/check/check.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -1165,7 +1165,7 @@ fn check_enum<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) {
11651165
}
11661166

11671167
if def.repr().int.is_none() {
1168-
let is_unit = |var: &ty::VariantDef| matches!(var.ctor_kind, CtorKind::Const);
1168+
let is_unit = |var: &ty::VariantDef| matches!(var.ctor_kind(), Some(CtorKind::Const));
11691169
let has_disr = |var: &ty::VariantDef| matches!(var.discr, ty::VariantDiscr::Explicit(_));
11701170

11711171
let has_non_units = def.variants().iter().any(|var| !is_unit(var));

‎compiler/rustc_hir_analysis/src/collect.rs

+10-26
Original file line numberDiff line numberDiff line change
@@ -24,7 +24,6 @@ use rustc_data_structures::captures::Captures;
2424
use rustc_data_structures::fx::{FxHashMap, FxHashSet};
2525
use rustc_errors::{struct_span_err, Applicability, DiagnosticBuilder, ErrorGuaranteed, StashKey};
2626
use rustc_hir as hir;
27-
use rustc_hir::def::CtorKind;
2827
use rustc_hir::def_id::{DefId, LocalDefId, LOCAL_CRATE};
2928
use rustc_hir::intravisit::{self, Visitor};
3029
use rustc_hir::weak_lang_items::WEAK_LANG_ITEMS;
@@ -794,7 +793,7 @@ fn convert_enum_variant_types(tcx: TyCtxt<'_>, def_id: DefId) {
794793

795794
// Convert the ctor, if any. This also registers the variant as
796795
// an item.
797-
if let Some(ctor_def_id) = variant.ctor_def_id {
796+
if let Some(ctor_def_id) = variant.ctor_def_id() {
798797
convert_variant_ctor(tcx, ctor_def_id.expect_local());
799798
}
800799
}
@@ -803,7 +802,6 @@ fn convert_enum_variant_types(tcx: TyCtxt<'_>, def_id: DefId) {
803802
fn convert_variant(
804803
tcx: TyCtxt<'_>,
805804
variant_did: Option<LocalDefId>,
806-
ctor_did: Option<LocalDefId>,
807805
ident: Ident,
808806
discr: ty::VariantDiscr,
809807
def: &hir::VariantData<'_>,
@@ -840,10 +838,9 @@ fn convert_variant(
840838
ty::VariantDef::new(
841839
ident.name,
842840
variant_did.map(LocalDefId::to_def_id),
843-
ctor_did.map(LocalDefId::to_def_id),
841+
def.ctor().map(|(kind, _, def_id)| (kind, def_id.to_def_id())),
844842
discr,
845843
fields,
846-
CtorKind::from_hir(def),
847844
adt_kind,
848845
parent_did.to_def_id(),
849846
recovered,
@@ -882,7 +879,6 @@ fn adt_def<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> ty::AdtDef<'tcx> {
882879
convert_variant(
883880
tcx,
884881
Some(v.def_id),
885-
v.data.ctor_def_id(),
886882
v.ident,
887883
discr,
888884
&v.data,
@@ -894,35 +890,23 @@ fn adt_def<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> ty::AdtDef<'tcx> {
894890

895891
(AdtKind::Enum, variants)
896892
}
897-
ItemKind::Struct(ref def, _) => {
898-
let variants = std::iter::once(convert_variant(
899-
tcx,
900-
None,
901-
def.ctor_def_id(),
902-
item.ident,
903-
ty::VariantDiscr::Relative(0),
904-
def,
905-
AdtKind::Struct,
906-
def_id,
907-
))
908-
.collect();
909-
910-
(AdtKind::Struct, variants)
911-
}
912-
ItemKind::Union(ref def, _) => {
893+
ItemKind::Struct(ref def, _) | ItemKind::Union(ref def, _) => {
894+
let adt_kind = match item.kind {
895+
ItemKind::Struct(..) => AdtKind::Struct,
896+
_ => AdtKind::Union,
897+
};
913898
let variants = std::iter::once(convert_variant(
914899
tcx,
915900
None,
916-
def.ctor_def_id(),
917901
item.ident,
918902
ty::VariantDiscr::Relative(0),
919903
def,
920-
AdtKind::Union,
904+
adt_kind,
921905
def_id,
922906
))
923907
.collect();
924908

925-
(AdtKind::Union, variants)
909+
(adt_kind, variants)
926910
}
927911
_ => bug!(),
928912
};
@@ -1171,7 +1155,7 @@ fn fn_sig(tcx: TyCtxt<'_>, def_id: DefId) -> ty::PolyFnSig<'_> {
11711155
compute_sig_of_foreign_fn_decl(tcx, def_id.to_def_id(), fn_decl, abi)
11721156
}
11731157

1174-
Ctor(data) | Variant(hir::Variant { data, .. }) if data.ctor_hir_id().is_some() => {
1158+
Ctor(data) | Variant(hir::Variant { data, .. }) if data.ctor().is_some() => {
11751159
let ty = tcx.type_of(tcx.hir().get_parent_item(hir_id));
11761160
let inputs = data.fields().iter().map(|f| tcx.type_of(f.def_id));
11771161
ty::Binder::dummy(tcx.mk_fn_sig(

‎compiler/rustc_hir_analysis/src/variance/constraints.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -72,8 +72,8 @@ pub fn add_constraints_from_crate<'a, 'tcx>(
7272

7373
let adt = tcx.adt_def(def_id);
7474
for variant in adt.variants() {
75-
if let Some(ctor) = variant.ctor_def_id {
76-
constraint_cx.build_constraints_for_item(ctor.expect_local());
75+
if let Some(ctor_def_id) = variant.ctor_def_id() {
76+
constraint_cx.build_constraints_for_item(ctor_def_id.expect_local());
7777
}
7878
}
7979
}

‎compiler/rustc_hir_analysis/src/variance/terms.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -91,8 +91,8 @@ pub fn determine_parameters_to_be_inferred<'a, 'tcx>(
9191

9292
let adt = tcx.adt_def(def_id);
9393
for variant in adt.variants() {
94-
if let Some(ctor) = variant.ctor_def_id {
95-
terms_cx.add_inferreds_for_item(ctor.expect_local());
94+
if let Some(ctor_def_id) = variant.ctor_def_id() {
95+
terms_cx.add_inferreds_for_item(ctor_def_id.expect_local());
9696
}
9797
}
9898
}

‎compiler/rustc_hir_typeck/src/callee.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -6,7 +6,7 @@ use crate::type_error_struct;
66
use rustc_ast::util::parser::PREC_POSTFIX;
77
use rustc_errors::{struct_span_err, Applicability, Diagnostic, StashKey};
88
use rustc_hir as hir;
9-
use rustc_hir::def::{self, Namespace, Res};
9+
use rustc_hir::def::{self, CtorKind, Namespace, Res};
1010
use rustc_hir::def_id::DefId;
1111
use rustc_infer::{
1212
infer,
@@ -595,7 +595,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
595595
) {
596596
let mut unit_variant = None;
597597
if let hir::ExprKind::Path(qpath) = &callee_expr.kind
598-
&& let Res::Def(def::DefKind::Ctor(kind, def::CtorKind::Const), _)
598+
&& let Res::Def(def::DefKind::Ctor(kind, CtorKind::Const), _)
599599
= self.typeck_results.borrow().qpath_res(qpath, callee_expr.hir_id)
600600
// Only suggest removing parens if there are no arguments
601601
&& arg_exprs.is_empty()

‎compiler/rustc_hir_typeck/src/demand.rs

+8-7
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,7 @@ use crate::FnCtxt;
22
use rustc_ast::util::parser::PREC_POSTFIX;
33
use rustc_errors::{Applicability, Diagnostic, DiagnosticBuilder, ErrorGuaranteed};
44
use rustc_hir as hir;
5+
use rustc_hir::def::CtorKind;
56
use rustc_hir::lang_items::LangItem;
67
use rustc_hir::{is_range_literal, Node};
78
use rustc_infer::infer::InferOk;
@@ -404,27 +405,27 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
404405
if let Some(path) = variant_path.strip_prefix("std::prelude::")
405406
&& let Some((_, path)) = path.split_once("::")
406407
{
407-
return Some((path.to_string(), variant.ctor_kind, sole_field.name, note_about_variant_field_privacy));
408+
return Some((path.to_string(), variant.ctor_kind(), sole_field.name, note_about_variant_field_privacy));
408409
}
409-
Some((variant_path, variant.ctor_kind, sole_field.name, note_about_variant_field_privacy))
410+
Some((variant_path, variant.ctor_kind(), sole_field.name, note_about_variant_field_privacy))
410411
} else {
411412
None
412413
}
413414
})
414415
.collect();
415416

416-
let suggestions_for = |variant: &_, ctor, field_name| {
417+
let suggestions_for = |variant: &_, ctor_kind, field_name| {
417418
let prefix = match self.maybe_get_struct_pattern_shorthand_field(expr) {
418419
Some(ident) => format!("{ident}: "),
419420
None => String::new(),
420421
};
421422

422-
let (open, close) = match ctor {
423-
hir::def::CtorKind::Fn => ("(".to_owned(), ")"),
424-
hir::def::CtorKind::Fictive => (format!(" {{ {field_name}: "), " }"),
423+
let (open, close) = match ctor_kind {
424+
Some(CtorKind::Fn) => ("(".to_owned(), ")"),
425+
None => (format!(" {{ {field_name}: "), " }"),
425426

426427
// unit variants don't have fields
427-
hir::def::CtorKind::Const => unreachable!(),
428+
Some(CtorKind::Const) => unreachable!(),
428429
};
429430

430431
// Suggest constructor as deep into the block tree as possible.

‎compiler/rustc_hir_typeck/src/expr.rs

+4-4
Original file line numberDiff line numberDiff line change
@@ -533,8 +533,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
533533
self.set_tainted_by_errors(e);
534534
tcx.ty_error_with_guaranteed(e)
535535
}
536-
Res::Def(DefKind::Ctor(_, CtorKind::Fictive), _) => {
537-
let e = report_unexpected_variant_res(tcx, res, qpath, expr.span);
536+
Res::Def(DefKind::Variant, _) => {
537+
let e = report_unexpected_variant_res(tcx, res, qpath, expr.span, "E0533", "value");
538538
tcx.ty_error_with_guaranteed(e)
539539
}
540540
_ => self.instantiate_value_path(segs, opt_ty, res, expr.span, expr.hir_id).0,
@@ -2025,8 +2025,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
20252025
);
20262026

20272027
let variant_ident_span = self.tcx.def_ident_span(variant.def_id).unwrap();
2028-
match variant.ctor_kind {
2029-
CtorKind::Fn => match ty.kind() {
2028+
match variant.ctor_kind() {
2029+
Some(CtorKind::Fn) => match ty.kind() {
20302030
ty::Adt(adt, ..) if adt.is_enum() => {
20312031
err.span_label(
20322032
variant_ident_span,

‎compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs

+2-5
Original file line numberDiff line numberDiff line change
@@ -1164,11 +1164,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
11641164
match *ty.kind() {
11651165
ty::Adt(adt_def, substs) if adt_def.has_ctor() => {
11661166
let variant = adt_def.non_enum_variant();
1167-
let ctor_def_id = variant.ctor_def_id.unwrap();
1168-
(
1169-
Res::Def(DefKind::Ctor(CtorOf::Struct, variant.ctor_kind), ctor_def_id),
1170-
Some(substs),
1171-
)
1167+
let (ctor_kind, ctor_def_id) = variant.ctor.unwrap();
1168+
(Res::Def(DefKind::Ctor(CtorOf::Struct, ctor_kind), ctor_def_id), Some(substs))
11721169
}
11731170
_ => {
11741171
let mut err = tcx.sess.struct_span_err(

‎compiler/rustc_hir_typeck/src/lib.rs

+21-9
Original file line numberDiff line numberDiff line change
@@ -53,9 +53,9 @@ use crate::check::check_fn;
5353
use crate::coercion::DynamicCoerceMany;
5454
use crate::gather_locals::GatherLocalsVisitor;
5555
use rustc_data_structures::unord::UnordSet;
56-
use rustc_errors::{struct_span_err, ErrorGuaranteed, MultiSpan};
56+
use rustc_errors::{struct_span_err, DiagnosticId, ErrorGuaranteed, MultiSpan};
5757
use rustc_hir as hir;
58-
use rustc_hir::def::Res;
58+
use rustc_hir::def::{DefKind, Res};
5959
use rustc_hir::intravisit::Visitor;
6060
use rustc_hir::{HirIdMap, Node};
6161
use rustc_hir_analysis::astconv::AstConv;
@@ -433,15 +433,27 @@ fn report_unexpected_variant_res(
433433
res: Res,
434434
qpath: &hir::QPath<'_>,
435435
span: Span,
436+
err_code: &str,
437+
expected: &str,
436438
) -> ErrorGuaranteed {
437-
struct_span_err!(
438-
tcx.sess,
439+
let res_descr = match res {
440+
Res::Def(DefKind::Variant, _) => "struct variant",
441+
_ => res.descr(),
442+
};
443+
let path_str = rustc_hir_pretty::qpath_to_string(qpath);
444+
let mut err = tcx.sess.struct_span_err_with_code(
439445
span,
440-
E0533,
441-
"expected unit struct, unit variant or constant, found {} `{}`",
442-
res.descr(),
443-
rustc_hir_pretty::qpath_to_string(qpath),
444-
)
446+
format!("expected {expected}, found {res_descr} `{path_str}`"),
447+
DiagnosticId::Error(err_code.into()),
448+
);
449+
match res {
450+
Res::Def(DefKind::Fn | DefKind::AssocFn, _) if err_code == "E0164" => {
451+
let patterns_url = "https://doc.rust-lang.org/book/ch18-00-patterns.html";
452+
err.span_label(span, "`fn` calls are not allowed in patterns");
453+
err.help(format!("for more information, visit {patterns_url}"))
454+
}
455+
_ => err.span_label(span, format!("not a {expected}")),
456+
}
445457
.emit()
446458
}
447459

0 commit comments

Comments
 (0)