Box EnumKind

bugadani · bugadani · commit f7a6147efc32 · 2021-02-02T22:49:27.000+01:00
diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
@@ -2694,6 +2694,9 @@ pub struct ConstKind(pub Defaultness, pub P<Ty>, pub Option<P<Expr>>);
 #[derive(Clone, Encodable, Decodable, Debug)]
 pub struct StructUnionKind(pub VariantData, pub Generics);
 
+#[derive(Clone, Encodable, Decodable, Debug)]
+pub struct EnumKind(pub EnumDef, pub Generics);
+
 #[derive(Clone, Encodable, Decodable, Debug)]
 pub enum ItemKind {
     /// An `extern crate` item, with the optional *original* crate name if the crate was renamed.
@@ -2733,7 +2736,7 @@ pub enum ItemKind {
     /// An enum definition (`enum`).
     ///
     /// E.g., `enum Foo<A, B> { C<A>, D<B> }`.
-    Enum(EnumDef, Generics),
+    Enum(Box<EnumKind>),
     /// A struct definition (`struct`).
     ///
     /// E.g., `struct Foo<A> { x: A }`.
@@ -2802,7 +2805,7 @@ impl ItemKind {
         match self {
             Self::Fn(box FnKind(_, _, generics, _))
             | Self::TyAlias(box TyAliasKind(_, generics, ..))
-            | Self::Enum(_, generics)
+            | Self::Enum(box EnumKind(_, generics))
             | Self::Struct(box StructUnionKind(_, generics))
             | Self::Union(box StructUnionKind(_, generics))
             | Self::Trait(box TraitKind(_, _, generics, ..))
diff --git a/compiler/rustc_ast/src/mut_visit.rs b/compiler/rustc_ast/src/mut_visit.rs
@@ -926,7 +926,7 @@ pub fn noop_visit_item_kind<T: MutVisitor>(kind: &mut ItemKind, vis: &mut T) {
             visit_bounds(bounds, vis);
             visit_opt(ty, |ty| vis.visit_ty(ty));
         }
-        ItemKind::Enum(EnumDef { variants }, generics) => {
+        ItemKind::Enum(box EnumKind(EnumDef { variants }, generics)) => {
             variants.flat_map_in_place(|variant| vis.flat_map_variant(variant));
             vis.visit_generics(generics);
         }
diff --git a/compiler/rustc_ast/src/token.rs b/compiler/rustc_ast/src/token.rs
@@ -805,7 +805,7 @@ impl Nonterminal {
 
         let name = item.ident.name;
         if name == sym::ProceduralMasqueradeDummyType || name == sym::ProcMacroHack {
-            if let ast::ItemKind::Enum(enum_def, _) = &item.kind {
+            if let ast::ItemKind::Enum(box ast::EnumKind(enum_def, _)) = &item.kind {
                 if let [variant] = &*enum_def.variants {
                     return variant.ident.name == sym::Input;
                 }
diff --git a/compiler/rustc_ast/src/visit.rs b/compiler/rustc_ast/src/visit.rs
@@ -308,7 +308,7 @@ pub fn walk_item<'a, V: Visitor<'a>>(visitor: &mut V, item: &'a Item) {
             walk_list!(visitor, visit_param_bound, bounds);
             walk_list!(visitor, visit_ty, ty);
         }
-        ItemKind::Enum(ref enum_definition, ref generics) => {
+        ItemKind::Enum(box EnumKind(ref enum_definition, ref generics)) => {
             visitor.visit_generics(generics);
             visitor.visit_enum_def(enum_definition, generics, item.id, item.span)
         }
diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
@@ -355,7 +355,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 let generics = self.lower_generics(generics, ImplTraitContext::disallowed());
                 hir::ItemKind::TyAlias(ty, generics)
             }
-            ItemKind::Enum(ref enum_definition, ref generics) => hir::ItemKind::Enum(
+            ItemKind::Enum(box EnumKind(ref enum_definition, ref generics)) => hir::ItemKind::Enum(
                 hir::EnumDef {
                     variants: self.arena.alloc_from_iter(
                         enum_definition.variants.iter().map(|x| self.lower_variant(x)),
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
@@ -500,7 +500,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 match item.kind {
                     ItemKind::Struct(box StructUnionKind(_, ref generics))
                     | ItemKind::Union(box StructUnionKind(_, ref generics))
-                    | ItemKind::Enum(_, ref generics)
+                    | ItemKind::Enum(box EnumKind(_, ref generics))
                     | ItemKind::TyAlias(box TyAliasKind(_, ref generics, ..))
                     | ItemKind::Trait(box TraitKind(_, _, ref generics, ..)) => {
                         let def_id = self.lctx.resolver.local_def_id(item.id);
diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -1019,7 +1019,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
                 self.extern_mod = old_item;
                 return; // Avoid visiting again.
             }
-            ItemKind::Enum(ref def, _) => {
+            ItemKind::Enum(box EnumKind(ref def, _)) => {
                 for variant in &def.variants {
                     self.invalid_visibility(&variant.vis, None);
                     for field in variant.data.fields() {
diff --git a/compiler/rustc_ast_passes/src/feature_gate.rs b/compiler/rustc_ast_passes/src/feature_gate.rs
@@ -345,7 +345,7 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
                 }
             }
 
-            ast::ItemKind::Enum(ast::EnumDef { ref variants, .. }, ..) => {
+            ast::ItemKind::Enum(box ast::EnumKind(ast::EnumDef { ref variants, .. }, ..)) => {
                 for variant in variants {
                     match (&variant.data, &variant.disr_expr) {
                         (ast::VariantData::Unit(..), _) => {}
diff --git a/compiler/rustc_ast_pretty/src/pprust/state.rs b/compiler/rustc_ast_pretty/src/pprust/state.rs
@@ -1179,7 +1179,7 @@ impl<'a> State<'a> {
                 let ty = ty.as_deref();
                 self.print_associated_type(item.ident, generics, bounds, ty, &item.vis, def);
             }
-            ast::ItemKind::Enum(ref enum_definition, ref params) => {
+            ast::ItemKind::Enum(box ast::EnumKind(ref enum_definition, ref params)) => {
                 self.print_enum_def(enum_definition, params, item.ident, item.span, &item.vis);
             }
             ast::ItemKind::Struct(box ast::StructUnionKind(ref struct_def, ref generics)) => {
diff --git a/compiler/rustc_builtin_macros/src/deriving/clone.rs b/compiler/rustc_builtin_macros/src/deriving/clone.rs
@@ -4,7 +4,8 @@ use crate::deriving::path_std;
 
 use rustc_ast::ptr::P;
 use rustc_ast::{
-    self as ast, Expr, GenericArg, Generics, ItemKind, MetaItem, StructUnionKind, VariantData,
+    self as ast, EnumKind, Expr, GenericArg, Generics, ItemKind, MetaItem, StructUnionKind,
+    VariantData,
 };
 use rustc_expand::base::{Annotatable, ExtCtxt};
 use rustc_span::symbol::{kw, sym, Ident, Symbol};
@@ -37,7 +38,7 @@ pub fn expand_deriving_clone(
     match *item {
         Annotatable::Item(ref annitem) => match annitem.kind {
             ItemKind::Struct(box StructUnionKind(_, Generics { ref params, .. }))
-            | ItemKind::Enum(_, Generics { ref params, .. }) => {
+            | ItemKind::Enum(box EnumKind(_, Generics { ref params, .. })) => {
                 let container_id = cx.current_expansion.id.expn_data().parent;
                 if cx.resolver.has_derive_copy(container_id)
                     && !params
diff --git a/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs b/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs
@@ -403,7 +403,7 @@ impl<'a> TraitDef<'a> {
                 });
                 let has_no_type_params = match item.kind {
                     ast::ItemKind::Struct(box ast::StructUnionKind(_, ref generics))
-                    | ast::ItemKind::Enum(_, ref generics)
+                    | ast::ItemKind::Enum(box ast::EnumKind(_, ref generics))
                     | ast::ItemKind::Union(box ast::StructUnionKind(_, ref generics)) => !generics
                         .params
                         .iter()
@@ -426,7 +426,7 @@ impl<'a> TraitDef<'a> {
                         from_scratch,
                         use_temporaries,
                     ),
-                    ast::ItemKind::Enum(ref enum_def, ref generics) => {
+                    ast::ItemKind::Enum(box ast::EnumKind(ref enum_def, ref generics)) => {
                         // We ignore `use_temporaries` here, because
                         // `repr(packed)` enums cause an error later on.
                         //
@@ -1739,7 +1739,7 @@ where
 pub fn is_type_without_fields(item: &Annotatable) -> bool {
     if let Annotatable::Item(ref item) = *item {
         match item.kind {
-            ast::ItemKind::Enum(ref enum_def, _) => {
+            ast::ItemKind::Enum(box ast::EnumKind(ref enum_def, _)) => {
                 enum_def.variants.iter().all(|v| v.data.fields().is_empty())
             }
             ast::ItemKind::Struct(box ast::StructUnionKind(ref variant_data, _)) => {
diff --git a/compiler/rustc_builtin_macros/src/deriving/mod.rs b/compiler/rustc_builtin_macros/src/deriving/mod.rs
@@ -2,7 +2,7 @@
 
 use rustc_ast as ast;
 use rustc_ast::ptr::P;
-use rustc_ast::{ImplKind, ItemKind, MetaItem, StructUnionKind};
+use rustc_ast::{EnumKind, ImplKind, ItemKind, MetaItem, StructUnionKind};
 use rustc_expand::base::{Annotatable, ExpandResult, ExtCtxt, MultiItemModifier};
 use rustc_span::symbol::{sym, Ident, Symbol};
 use rustc_span::Span;
@@ -122,7 +122,7 @@ fn inject_impl_of_structural_trait(
 
     let generics = match item.kind {
         ItemKind::Struct(box StructUnionKind(_, ref generics))
-        | ItemKind::Enum(_, ref generics) => generics,
+        | ItemKind::Enum(box EnumKind(_, ref generics)) => generics,
         // Do not inject `impl Structural for Union`. (`PartialEq` does not
         // support unions, so we will see error downstream.)
         ItemKind::Union(..) => return,
diff --git a/compiler/rustc_expand/src/config.rs b/compiler/rustc_expand/src/config.rs
@@ -459,7 +459,7 @@ impl<'a> StripUnconfigured<'a> {
             | ast::ItemKind::Union(box ast::StructUnionKind(def, _generics)) => {
                 self.configure_variant_data(def)
             }
-            ast::ItemKind::Enum(ast::EnumDef { variants }, _generics) => {
+            ast::ItemKind::Enum(box ast::EnumKind(ast::EnumDef { variants }, _generics)) => {
                 variants.flat_map_in_place(|variant| self.configure(variant));
                 for variant in variants {
                     self.configure_variant_data(&mut variant.data);
diff --git a/compiler/rustc_parse/src/parser/item.rs b/compiler/rustc_parse/src/parser/item.rs
@@ -1094,7 +1094,7 @@ impl<'a> Parser<'a> {
 
         let enum_definition =
             EnumDef { variants: variants.into_iter().filter_map(|v| v).collect() };
-        Ok((id, ItemKind::Enum(enum_definition, generics)))
+        Ok((id, ItemKind::Enum(box EnumKind(enum_definition, generics))))
     }
 
     fn parse_enum_variant(&mut self) -> PResult<'a, Option<Variant>> {
diff --git a/compiler/rustc_resolve/src/build_reduced_graph.rs b/compiler/rustc_resolve/src/build_reduced_graph.rs
@@ -800,7 +800,7 @@ impl<'a, 'b> BuildReducedGraphVisitor<'a, 'b> {
                 self.r.define(parent, ident, TypeNS, (res, vis, sp, expansion));
             }
 
-            ItemKind::Enum(_, _) => {
+            ItemKind::Enum(_) => {
                 let module_kind = ModuleKind::Def(DefKind::Enum, def_id, ident.name);
                 let module = self.r.new_module(
                     parent,
diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs
@@ -945,7 +945,7 @@ impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> {
                 });
             }
 
-            ItemKind::Enum(_, ref generics)
+            ItemKind::Enum(box EnumKind(_, ref generics))
             | ItemKind::Struct(box StructUnionKind(_, ref generics))
             | ItemKind::Union(box StructUnionKind(_, ref generics)) => {
                 self.resolve_adt(item, generics);
diff --git a/src/tools/clippy/clippy_lints/src/enum_variants.rs b/src/tools/clippy/clippy_lints/src/enum_variants.rs
@@ -2,7 +2,7 @@
 
 use crate::utils::{camel_case, is_present_in_source};
 use crate::utils::{span_lint, span_lint_and_help};
-use rustc_ast::ast::{EnumDef, Item, ItemKind, VisibilityKind};
+use rustc_ast::ast::{EnumDef, EnumKind, Item, ItemKind, VisibilityKind};
 use rustc_lint::{EarlyContext, EarlyLintPass, Lint};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
@@ -315,7 +315,7 @@ impl EarlyLintPass for EnumVariantNames {
                 }
             }
         }
-        if let ItemKind::Enum(ref def, _) = item.kind {
+        if let ItemKind::Enum(box EnumKind(ref def, _)) = item.kind {
             let lint = match item.vis.kind {
                 VisibilityKind::Public => PUB_ENUM_VARIANT_NAMES,
                 _ => ENUM_VARIANT_NAMES,
diff --git a/src/tools/clippy/clippy_lints/src/manual_non_exhaustive.rs b/src/tools/clippy/clippy_lints/src/manual_non_exhaustive.rs
@@ -1,7 +1,8 @@
 use crate::utils::{meets_msrv, snippet_opt, span_lint_and_then};
 use if_chain::if_chain;
 use rustc_ast::ast::{
-    Attribute, Item, ItemKind, StructField, StructUnionKind, Variant, VariantData, VisibilityKind,
+    Attribute, EnumKind, Item, ItemKind, StructField, StructUnionKind, Variant, VariantData,
+    VisibilityKind,
 };
 use rustc_attr as attr;
 use rustc_errors::Applicability;
@@ -81,7 +82,7 @@ impl EarlyLintPass for ManualNonExhaustive {
         }
 
         match &item.kind {
-            ItemKind::Enum(def, _) => {
+            ItemKind::Enum(box EnumKind(def, _)) => {
                 check_manual_non_exhaustive_enum(cx, item, &def.variants);
             }
             ItemKind::Struct(box StructUnionKind(variant_data, _)) => {
diff --git a/src/tools/clippy/clippy_lints/src/utils/ast_utils.rs b/src/tools/clippy/clippy_lints/src/utils/ast_utils.rs
@@ -253,8 +253,8 @@ pub fn eq_item_kind(l: &ItemKind, r: &ItemKind) -> bool {
                 && eq_generics(lg, rg)
                 && over(lb, rb, |l, r| eq_generic_bound(l, r))
                 && both(lt, rt, |l, r| eq_ty(l, r))
-        },
-        (Enum(le, lg), Enum(re, rg)) => {
+        }
+        (Enum(box EnumKind(le, lg)), Enum(box EnumKind(re, rg))) => {
             over(&le.variants, &re.variants, |l, r| eq_variant(l, r)) && eq_generics(lg, rg)
         }
         (Struct(box StructUnionKind(lv, lg)), Struct(box StructUnionKind(rv, rg)))

Original file line number	Diff line number	Diff line change
`@@ -926,7 +926,7 @@ pub fn noop_visit_item_kind<T: MutVisitor>(kind: &mut ItemKind, vis: &mut T) {`
`926`	`926`	`visit_bounds(bounds, vis);`
`927`	`927`	`visit_opt(ty, \|ty\| vis.visit_ty(ty));`
`928`	`928`	`}`
`929`		`- ItemKind::Enum(EnumDef { variants }, generics) => {`
	`929`	`+ ItemKind::Enum(box EnumKind(EnumDef { variants }, generics)) => {`
`930`	`930`	`variants.flat_map_in_place(\|variant\| vis.flat_map_variant(variant));`
`931`	`931`	`vis.visit_generics(generics);`
`932`	`932`	`}`
Original file line number	Diff line number	Diff line change
`@@ -805,7 +805,7 @@ impl Nonterminal {`
`805`	`805`
`806`	`806`	`let name = item.ident.name;`
`807`	`807`	`if name == sym::ProceduralMasqueradeDummyType \|\| name == sym::ProcMacroHack {`
`808`		`- if let ast::ItemKind::Enum(enum_def, _) = &item.kind {`
	`808`	`+ if let ast::ItemKind::Enum(box ast::EnumKind(enum_def, _)) = &item.kind {`
`809`	`809`	`if let [variant] = &*enum_def.variants {`
`810`	`810`	`return variant.ident.name == sym::Input;`
`811`	`811`	`}`
Original file line number	Diff line number	Diff line change
`@@ -308,7 +308,7 @@ pub fn walk_item<'a, V: Visitor<'a>>(visitor: &mut V, item: &'a Item) {`
`308`	`308`	`walk_list!(visitor, visit_param_bound, bounds);`
`309`	`309`	`walk_list!(visitor, visit_ty, ty);`
`310`	`310`	`}`
`311`		`- ItemKind::Enum(ref enum_definition, ref generics) => {`
	`311`	`+ ItemKind::Enum(box EnumKind(ref enum_definition, ref generics)) => {`
`312`	`312`	`visitor.visit_generics(generics);`
`313`	`313`	`visitor.visit_enum_def(enum_definition, generics, item.id, item.span)`
`314`	`314`	`}`
Original file line number	Diff line number	Diff line change
`@@ -355,7 +355,7 @@ impl<'hir> LoweringContext<'_, 'hir> {`
`355`	`355`	`let generics = self.lower_generics(generics, ImplTraitContext::disallowed());`
`356`	`356`	`hir::ItemKind::TyAlias(ty, generics)`
`357`	`357`	`}`
`358`		`- ItemKind::Enum(ref enum_definition, ref generics) => hir::ItemKind::Enum(`
	`358`	`+ ItemKind::Enum(box EnumKind(ref enum_definition, ref generics)) => hir::ItemKind::Enum(`
`359`	`359`	`hir::EnumDef {`
`360`	`360`	`variants: self.arena.alloc_from_iter(`
`361`	`361`	`enum_definition.variants.iter().map(\|x\| self.lower_variant(x)),`
Original file line number	Diff line number	Diff line change
`@@ -1019,7 +1019,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {`
`1019`	`1019`	`self.extern_mod = old_item;`
`1020`	`1020`	`return; // Avoid visiting again.`
`1021`	`1021`	`}`
`1022`		`- ItemKind::Enum(ref def, _) => {`
	`1022`	`+ ItemKind::Enum(box EnumKind(ref def, _)) => {`
`1023`	`1023`	`for variant in &def.variants {`
`1024`	`1024`	`self.invalid_visibility(&variant.vis, None);`
`1025`	`1025`	`for field in variant.data.fields() {`
Original file line number	Diff line number	Diff line change
`@@ -345,7 +345,7 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {`
`345`	`345`	`}`
`346`	`346`	`}`
`347`	`347`
`348`		`- ast::ItemKind::Enum(ast::EnumDef { ref variants, .. }, ..) => {`
	`348`	`+ ast::ItemKind::Enum(box ast::EnumKind(ast::EnumDef { ref variants, .. }, ..)) => {`
`349`	`349`	`for variant in variants {`
`350`	`350`	`match (&variant.data, &variant.disr_expr) {`
`351`	`351`	`(ast::VariantData::Unit(..), _) => {}`
Original file line number	Diff line number	Diff line change
`@@ -1179,7 +1179,7 @@ impl<'a> State<'a> {`
`1179`	`1179`	`let ty = ty.as_deref();`
`1180`	`1180`	`self.print_associated_type(item.ident, generics, bounds, ty, &item.vis, def);`
`1181`	`1181`	`}`
`1182`		`- ast::ItemKind::Enum(ref enum_definition, ref params) => {`
	`1182`	`+ ast::ItemKind::Enum(box ast::EnumKind(ref enum_definition, ref params)) => {`
`1183`	`1183`	`self.print_enum_def(enum_definition, params, item.ident, item.span, &item.vis);`
`1184`	`1184`	`}`
`1185`	`1185`	`ast::ItemKind::Struct(box ast::StructUnionKind(ref struct_def, ref generics)) => {`