XXX: redoing Enum

Author: nnethercote

compiler/rustc_ast/src/ast.rs

@@ -2440,10 +2440,6 @@ pub struct ForeignMod {
     pub items: Vec<P<ForeignItem>>,
 }
 
-#[derive(Clone, Encodable, Decodable, Debug)]
-pub struct EnumDef {
-    pub variants: Vec<Variant>,
-}
 /// Enum variant.
 #[derive(Clone, Encodable, Decodable, Debug)]
 pub struct Variant {
@@ -2808,6 +2804,12 @@ pub struct Fn {
     pub body: Option<P<Block>>,
 }
 
+#[derive(Clone, Encodable, Decodable, Debug)]
+pub struct Enum {
+    pub variants: Vec<Variant>,
+    pub generics: Generics,
+}
+
 #[derive(Clone, Encodable, Decodable, Debug)]
 pub enum ItemKind {
     /// An `extern crate` item, with the optional *original* crate name if the crate was renamed.
@@ -2849,7 +2851,7 @@ pub enum ItemKind {
     /// An enum definition (`enum`).
     ///
     /// E.g., `enum Foo<A, B> { C<A>, D<B> }`.
-    Enum(EnumDef, Box<Generics>),
+    Enum(Box<Enum>),
     /// A struct definition (`struct`).
     ///
     /// E.g., `struct Foo<A> { x: A }`.
@@ -2915,7 +2917,7 @@ impl ItemKind {
         match self {
             Self::Fn(box Fn { generics, .. })
             | Self::TyAlias(box TyAlias { generics, .. })
-            | Self::Enum(_, box generics)
+            | Self::Enum(box Enum { generics, .. })
             | Self::Struct(_, box generics)
             | Self::Union(_, box generics)
             | Self::Trait(box Trait { generics, .. })

compiler/rustc_ast/src/mut_visit.rs

@@ -1048,7 +1048,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 Enum { variants, generics }) => {
             variants.flat_map_in_place(|variant| vis.flat_map_variant(variant));
             vis.visit_generics(generics);
         }

compiler/rustc_ast/src/visit.rs

@@ -177,9 +177,6 @@ pub trait Visitor<'ast>: Sized {
     fn visit_field_def(&mut self, s: &'ast FieldDef) {
         walk_field_def(self, s)
     }
-    fn visit_enum_def(&mut self, enum_definition: &'ast EnumDef) {
-        walk_enum_def(self, enum_definition)
-    }
     fn visit_variant(&mut self, v: &'ast Variant) {
         walk_variant(self, v)
     }
@@ -326,9 +323,9 @@ pub fn walk_item<'a, V: Visitor<'a>>(visitor: &mut V, item: &'a Item) {
             walk_list!(visitor, visit_param_bound, bounds, BoundKind::Bound);
             walk_list!(visitor, visit_ty, ty);
         }
-        ItemKind::Enum(ref enum_definition, ref generics) => {
+        ItemKind::Enum(box Enum { ref variants, ref generics }) => {
             visitor.visit_generics(generics);
-            visitor.visit_enum_def(enum_definition)
+            walk_list!(visitor, visit_variant, variants);
         }
         ItemKind::Impl(box Impl {
             defaultness: _,
@@ -371,10 +368,6 @@ pub fn walk_item<'a, V: Visitor<'a>>(visitor: &mut V, item: &'a Item) {
     walk_list!(visitor, visit_attribute, &item.attrs);
 }
 
-pub fn walk_enum_def<'a, V: Visitor<'a>>(visitor: &mut V, enum_definition: &'a EnumDef) {
-    walk_list!(visitor, visit_variant, &enum_definition.variants);
-}
-
 pub fn walk_variant<'a, V: Visitor<'a>>(visitor: &mut V, variant: &'a Variant)
 where
     V: Visitor<'a>,

compiler/rustc_ast_lowering/src/item.rs

@@ -324,15 +324,13 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 );
                 hir::ItemKind::TyAlias(ty, generics)
             }
-            ItemKind::Enum(ref enum_definition, ref generics) => {
+            ItemKind::Enum(box Enum { ref variants, ref generics }) => {
                 let (generics, variants) = self.lower_generics(
                     generics,
                     id,
                     ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
                     |this| {
-                        this.arena.alloc_from_iter(
-                            enum_definition.variants.iter().map(|x| this.lower_variant(x)),
-                        )
+                        this.arena.alloc_from_iter(variants.iter().map(|x| this.lower_variant(x)))
                     },
                 );
                 hir::ItemKind::Enum(hir::EnumDef { variants }, generics)

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -1250,8 +1250,8 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
                 self.extern_mod = old_item;
                 return; // Avoid visiting again.
             }
-            ItemKind::Enum(ref def, _) => {
-                for variant in &def.variants {
+            ItemKind::Enum(box Enum { ref variants, .. }) => {
+                for variant in variants {
                     self.invalid_visibility(&variant.vis, None);
                     for field in variant.data.fields() {
                         self.invalid_visibility(&field.vis, None);
@@ -1547,10 +1547,6 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
         self.with_banned_assoc_ty_bound(|this| visit::walk_struct_def(this, s))
     }
 
-    fn visit_enum_def(&mut self, enum_definition: &'a EnumDef) {
-        self.with_banned_assoc_ty_bound(|this| visit::walk_enum_def(this, enum_definition))
-    }
-
     fn visit_fn(&mut self, fk: FnKind<'a>, span: Span, id: NodeId) {
         // Only associated `fn`s can have `self` parameters.
         let self_semantic = match fk.ctxt() {

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -465,7 +465,7 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
                 }
             }
 
-            ast::ItemKind::Enum(ast::EnumDef { ref variants, .. }, ..) => {
+            ast::ItemKind::Enum(box ast::Enum { ref variants, .. }) => {
                 for variant in variants {
                     match (&variant.data, &variant.disr_expr) {
                         (ast::VariantData::Unit(..), _) => {}

compiler/rustc_ast_passes/src/node_count.rs

@@ -91,10 +91,6 @@ impl<'ast> Visitor<'ast> for NodeCounter {
         self.count += 1;
         walk_field_def(self, s)
     }
-    fn visit_enum_def(&mut self, enum_definition: &EnumDef) {
-        self.count += 1;
-        walk_enum_def(self, enum_definition)
-    }
     fn visit_variant(&mut self, v: &Variant) {
         self.count += 1;
         walk_variant(self, v)

compiler/rustc_ast_pretty/src/pprust/state/item.rs

@@ -240,8 +240,8 @@ impl<'a> State<'a> {
                     defaultness,
                 );
             }
-            ast::ItemKind::Enum(ref enum_definition, ref params) => {
-                self.print_enum_def(enum_definition, params, item.ident, item.span, &item.vis);
+            ast::ItemKind::Enum(box ast::Enum { ref variants, ref generics }) => {
+                self.print_enum(variants, generics, item.ident, item.span, &item.vis);
             }
             ast::ItemKind::Struct(ref struct_def, ref generics) => {
                 self.head(visibility_qualified(&item.vis, "struct"));
@@ -377,9 +377,9 @@ impl<'a> State<'a> {
         self.ann.post(self, AnnNode::Item(item))
     }
 
-    fn print_enum_def(
+    fn print_enum(
         &mut self,
-        enum_definition: &ast::EnumDef,
+        variants: &[ast::Variant],
         generics: &ast::Generics,
         ident: Ident,
         span: rustc_span::Span,
@@ -390,7 +390,7 @@ impl<'a> State<'a> {
         self.print_generic_params(&generics.params);
         self.print_where_clause(&generics.where_clause);
         self.space();
-        self.print_variants(&enum_definition.variants, span)
+        self.print_variants(variants, span)
     }
 
     fn print_variants(&mut self, variants: &[ast::Variant], span: rustc_span::Span) {

compiler/rustc_builtin_macros/src/deriving/clone.rs

@@ -2,7 +2,7 @@ use crate::deriving::generic::ty::*;
 use crate::deriving::generic::*;
 use crate::deriving::path_std;
 
-use rustc_ast::{self as ast, Generics, ItemKind, MetaItem, VariantData};
+use rustc_ast::{self as ast, Enum, Generics, ItemKind, MetaItem, VariantData};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_expand::base::{Annotatable, ExtCtxt};
 use rustc_span::symbol::{kw, sym, Ident};
@@ -34,7 +34,7 @@ pub fn expand_deriving_clone(
     match *item {
         Annotatable::Item(ref annitem) => match annitem.kind {
             ItemKind::Struct(_, box Generics { ref params, .. })
-            | ItemKind::Enum(_, box Generics { ref params, .. }) => {
+            | ItemKind::Enum(box Enum { variants: _, generics: Generics { ref params, .. } }) => {
                 let container_id = cx.current_expansion.id.expn_data().parent.expect_local();
                 let has_derive_copy = cx.resolver.has_derive_copy(container_id);
                 if has_derive_copy
@@ -137,8 +137,8 @@ fn cs_clone_simple(
             StaticStruct(vdata, ..) => {
                 process_variant(vdata);
             }
-            StaticEnum(enum_def, ..) => {
-                for variant in &enum_def.variants {
+            StaticEnum(variants, ..) => {
+                for variant in variants {
                     process_variant(&variant.data);
                 }
             }

compiler/rustc_builtin_macros/src/deriving/cmp/eq.rs

@@ -79,8 +79,8 @@ fn cs_total_eq_assert(
         StaticStruct(vdata, ..) => {
             process_variant(vdata);
         }
-        StaticEnum(enum_def, ..) => {
-            for variant in &enum_def.variants {
+        StaticEnum(variants, ..) => {
+            for variant in variants {
                 process_variant(&variant.data);
             }
         }