Merge VariantData and VariantData_

src/librustc/front/map/collector.rs

@@ -134,7 +134,7 @@ impl<'ast> Visitor<'ast> for NodeCollector<'ast> {
             ItemEnum(ref enum_definition, _) => {
                 for v in &enum_definition.variants {
                     let variant_def_index =
-                        self.insert_def(v.node.data.id,
+                        self.insert_def(v.node.data.id(),
                                         NodeVariant(&**v),
                                         DefPathData::EnumVariant(v.node.name));
 
@@ -151,7 +151,7 @@ impl<'ast> Visitor<'ast> for NodeCollector<'ast> {
             ItemStruct(ref struct_def, _) => {
                 // If this is a tuple-like struct, register the constructor.
                 if !struct_def.is_struct() {
-                    self.insert_def(struct_def.id,
+                    self.insert_def(struct_def.id(),
                                     NodeStructCtor(&**struct_def),
                                     DefPathData::StructCtor);
                 }

src/librustc/metadata/encoder.rs

@@ -382,7 +382,7 @@ fn each_auxiliary_node_id<F>(item: &hir::Item, callback: F) -> bool where
         hir::ItemStruct(ref struct_def, _) => {
             // If this is a newtype struct, return the constructor.
             if struct_def.is_tuple() {
-                continue_ = callback(struct_def.id);
+                continue_ = callback(struct_def.id());
             }
         }
         _ => {}
@@ -1019,7 +1019,7 @@ fn encode_info_for_item<'a, 'tcx>(ecx: &EncodeContext<'a, 'tcx>,
         encode_attributes(rbml_w, &item.attrs);
         encode_repr_attrs(rbml_w, ecx, &item.attrs);
         for v in &enum_definition.variants {
-            encode_variant_id(rbml_w, ecx.tcx.map.local_def_id(v.node.data.id));
+            encode_variant_id(rbml_w, ecx.tcx.map.local_def_id(v.node.data.id()));
         }
         encode_inlined_item(ecx, rbml_w, InlinedItemRef::Item(item));
         encode_path(rbml_w, path);
@@ -1069,7 +1069,7 @@ fn encode_info_for_item<'a, 'tcx>(ecx: &EncodeContext<'a, 'tcx>,
         encode_inherent_implementations(ecx, rbml_w, def_id);
 
         if !struct_def.is_struct() {
-            let ctor_did = ecx.tcx.map.local_def_id(struct_def.id);
+            let ctor_did = ecx.tcx.map.local_def_id(struct_def.id());
             rbml_w.wr_tagged_u64(tag_items_data_item_struct_ctor,
                                  def_to_u64(ctor_did));
         }
@@ -1082,7 +1082,7 @@ fn encode_info_for_item<'a, 'tcx>(ecx: &EncodeContext<'a, 'tcx>,
 
         // If this is a tuple-like struct, encode the type of the constructor.
         if !struct_def.is_struct() {
-            encode_info_for_struct_ctor(ecx, rbml_w, item.name, struct_def.id, index, item.id);
+            encode_info_for_struct_ctor(ecx, rbml_w, item.name, struct_def.id(), index, item.id);
         }
       }
       hir::ItemDefaultImpl(unsafety, _) => {

src/librustc/middle/astencode.rs

@@ -1315,8 +1315,8 @@ fn copy_item_types(dcx: &DecodeContext, ii: &InlinedItem, orig_did: DefId) {
                     def.variants.iter().zip(orig_def.variants.iter())
                 {
                     debug!("astencode: copying variant {:?} => {:?}",
-                           orig_variant.did, i_variant.node.data.id);
+                           orig_variant.did, i_variant.node.data.id());
-                    copy_item_type(dcx, i_variant.node.data.id, orig_variant.did);
+                    copy_item_type(dcx, i_variant.node.data.id(), orig_variant.did);
                 }
             }
             hir::ItemStruct(ref def, _) => {
@@ -1324,8 +1324,8 @@ fn copy_item_types(dcx: &DecodeContext, ii: &InlinedItem, orig_did: DefId) {
                     let ctor_did = dcx.tcx.lookup_adt_def(orig_did)
                         .struct_variant().did;
                     debug!("astencode: copying ctor {:?} => {:?}", ctor_did,
-                           def.id);
+                           def.id());
-                    copy_item_type(dcx, def.id, ctor_did);
+                    copy_item_type(dcx, def.id(), ctor_did);
                 }
             }
             _ => {}

src/librustc/middle/check_static_recursion.rs

@@ -168,7 +168,7 @@ impl<'a, 'ast: 'a> CheckItemRecursionVisitor<'a, 'ast> {
         let mut discriminant_map = self.discriminant_map.borrow_mut();
         match enum_definition.variants.first() {
             None => { return; }
-            Some(variant) if discriminant_map.contains_key(&variant.node.data.id) => {
+            Some(variant) if discriminant_map.contains_key(&variant.node.data.id()) => {
                 return;
             }
             _ => {}
@@ -177,7 +177,7 @@ impl<'a, 'ast: 'a> CheckItemRecursionVisitor<'a, 'ast> {
         // Go through all the variants.
         let mut variant_stack: Vec<ast::NodeId> = Vec::new();
         for variant in enum_definition.variants.iter().rev() {
-            variant_stack.push(variant.node.data.id);
+            variant_stack.push(variant.node.data.id());
             // When we find an expression, every variant currently on the stack
             // is affected by that expression.
             if let Some(ref expr) = variant.node.disr_expr {
@@ -208,7 +208,7 @@ impl<'a, 'ast: 'a> Visitor<'ast> for CheckItemRecursionVisitor<'a, 'ast> {
 
     fn visit_variant(&mut self, variant: &'ast hir::Variant,
                      _: &'ast hir::Generics, _: ast::NodeId) {
-        let variant_id = variant.node.data.id;
+        let variant_id = variant.node.data.id();
         let maybe_expr;
         if let Some(get_expr) = self.discriminant_map.borrow().get(&variant_id) {
             // This is necessary because we need to let the `discriminant_map`

src/librustc/middle/const_eval.rs

@@ -63,7 +63,7 @@ fn lookup_variant_by_id<'a>(tcx: &'a ty::ctxt,
     fn variant_expr<'a>(variants: &'a [P<hir::Variant>], id: ast::NodeId)
                         -> Option<&'a Expr> {
         for variant in variants {
-            if variant.node.data.id == id {
+            if variant.node.data.id() == id {
                 return variant.node.disr_expr.as_ref().map(|e| &**e);
             }
         }

src/librustc/middle/dead.rs

@@ -339,7 +339,8 @@ impl<'v> Visitor<'v> for LifeSeeder {
         }
         match item.node {
             hir::ItemEnum(ref enum_def, _) if allow_dead_code => {
-                self.worklist.extend(enum_def.variants.iter().map(|variant| variant.node.data.id));
+                self.worklist.extend(enum_def.variants.iter()
+                                                      .map(|variant| variant.node.data.id()));
             }
             hir::ItemTrait(_, _, _, ref trait_items) => {
                 for trait_item in trait_items {
@@ -427,7 +428,7 @@ fn find_live(tcx: &ty::ctxt,
 fn get_struct_ctor_id(item: &hir::Item) -> Option<ast::NodeId> {
     match item.node {
         hir::ItemStruct(ref struct_def, _) if !struct_def.is_struct() => {
-            Some(struct_def.id)
+            Some(struct_def.id())
         }
         _ => None
     }
@@ -466,7 +467,7 @@ impl<'a, 'tcx> DeadVisitor<'a, 'tcx> {
     }
 
     fn should_warn_about_variant(&mut self, variant: &hir::Variant_) -> bool {
-        !self.symbol_is_live(variant.data.id, None)
+        !self.symbol_is_live(variant.data.id(), None)
             && !has_allow_dead_code_or_lang_attr(&variant.attrs)
     }
 
@@ -542,7 +543,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for DeadVisitor<'a, 'tcx> {
                 hir::ItemEnum(ref enum_def, _) => {
                     for variant in &enum_def.variants {
                         if self.should_warn_about_variant(&variant.node) {
-                            self.warn_dead_code(variant.node.data.id, variant.span,
+                            self.warn_dead_code(variant.node.data.id(), variant.span,
                                                 variant.node.name, "variant");
                         }
                     }

src/librustc/middle/stability.rs

@@ -186,7 +186,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for Annotator<'a, 'tcx> {
 
         if let hir::ItemStruct(ref sd, _) = i.node {
             if !sd.is_struct() {
-                self.annotate(sd.id, true, &i.attrs, i.span, |_| {}, true)
+                self.annotate(sd.id(), true, &i.attrs, i.span, |_| {}, true)
             }
         }
     }
@@ -208,7 +208,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for Annotator<'a, 'tcx> {
     }
 
     fn visit_variant(&mut self, var: &Variant, g: &'v Generics, item_id: NodeId) {
-        self.annotate(var.node.data.id, true, &var.node.attrs, var.span,
+        self.annotate(var.node.data.id(), true, &var.node.attrs, var.span,
                       |v| visit::walk_variant(v, var, g, item_id), true)
     }
 

src/librustc_front/fold.rs

@@ -694,18 +694,15 @@ pub fn noop_fold_where_predicate<T: Folder>(pred: WherePredicate, fld: &mut T) -
 }
 
 pub fn noop_fold_struct_def<T: Folder>(struct_def: P<VariantData>, fld: &mut T) -> P<VariantData> {
-    struct_def.map(|VariantData { data_, id }| {
+    struct_def.map(|vdata| {
-        VariantData {
+        match vdata {
-            data_: match data_ {
+            VariantData::Struct(fields, id) => {
-                VariantData_::Struct(fields) => {
+                VariantData::Struct(fields.move_map(|f| fld.fold_struct_field(f)), fld.new_id(id))
-                    VariantData_::Struct(fields.move_map(|f| fld.fold_struct_field(f)))
+            }
-                }
+            VariantData::Tuple(fields, id) => {
-                VariantData_::Tuple(fields) => {
+                VariantData::Tuple(fields.move_map(|f| fld.fold_struct_field(f)), fld.new_id(id))
-                    VariantData_::Tuple(fields.move_map(|f| fld.fold_struct_field(f)))
+            }
-                }
+            VariantData::Unit(id) => VariantData::Unit(fld.new_id(id))
-                VariantData_::Unit => VariantData_::Unit
-            },
-            id: fld.new_id(id),
         }
     })
 }

src/librustc_front/hir.rs

@@ -1162,18 +1162,10 @@ impl StructFieldKind {
 }
 
 #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
-pub enum VariantData_ {
+pub enum VariantData {
-    Struct(Vec<StructField>),
+    Struct(Vec<StructField>, NodeId),
-    Tuple(Vec<StructField>),
+    Tuple(Vec<StructField>, NodeId),
-    Unit,
+    Unit(NodeId),
-}
-
-#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
-pub struct VariantData {
-    pub data_: VariantData_,
-    /// ID of the constructor. This is only used for tuple- or enum-like
-    /// structs.
-    pub id: NodeId,
 }
 
 pub type FieldIter<'a> = iter::FlatMap<option::IntoIter<&'a Vec<StructField>>,
@@ -1183,19 +1175,24 @@ pub type FieldIter<'a> = iter::FlatMap<option::IntoIter<&'a Vec<StructField>>,
 impl VariantData {
     pub fn fields(&self) -> FieldIter {
         fn vec_iter<T>(v: &Vec<T>) -> slice::Iter<T> { v.iter() }
-        match self.data_ {
+        match *self {
-            VariantData_::Struct(ref fields) | VariantData_::Tuple(ref fields) => Some(fields),
+            VariantData::Struct(ref fields, _) | VariantData::Tuple(ref fields, _) => Some(fields),
             _ => None,
         }.into_iter().flat_map(vec_iter)
     }
+    pub fn id(&self) -> NodeId {
+        match *self {
+            VariantData::Struct(_, id) | VariantData::Tuple(_, id) | VariantData::Unit(id) => id
+        }
+    }
     pub fn is_struct(&self) -> bool {
-        if let VariantData_::Struct(..) = self.data_ { true } else { false }
+        if let VariantData::Struct(..) = *self { true } else { false }
     }
     pub fn is_tuple(&self) -> bool {
-        if let VariantData_::Tuple(..) = self.data_ { true } else { false }
+        if let VariantData::Tuple(..) = *self { true } else { false }
     }
     pub fn is_unit(&self) -> bool {
-        if let VariantData_::Unit = self.data_ { true } else { false }
+        if let VariantData::Unit(..) = *self { true } else { false }
     }
 }
 

src/librustc_front/lowering.rs

@@ -499,19 +499,16 @@ pub fn lower_where_predicate(_lctx: &LoweringContext,
 }
 
 pub fn lower_struct_def(_lctx: &LoweringContext, sd: &VariantData) -> P<hir::VariantData> {
-    P(hir::VariantData {
+    P(match *sd {
-        id: sd.id,
+        VariantData::Struct(ref fields, id) => {
-        data_: match sd.data_ {
+            hir::VariantData::Struct(fields.iter()
-            VariantData_::Struct(ref fields) => {
+                                           .map(|f| lower_struct_field(_lctx, f)).collect(), id)
-                hir::VariantData_::Struct(fields.iter()
-                                                .map(|f| lower_struct_field(_lctx, f)).collect())
-            }
-            VariantData_::Tuple(ref fields) => {
-                hir::VariantData_::Tuple(fields.iter()
-                                               .map(|f| lower_struct_field(_lctx, f)).collect())
-            }
-            VariantData_::Unit => hir::VariantData_::Unit
         }
+        VariantData::Tuple(ref fields, id) => {
+            hir::VariantData::Tuple(fields.iter()
+                                          .map(|f| lower_struct_field(_lctx, f)).collect(), id)
+        }
+        VariantData::Unit(id) => hir::VariantData::Unit(id)
     })
 }
 

src/librustc_front/util.rs

@@ -287,7 +287,7 @@ impl<'a, 'v, O: ast_util::IdVisitingOperation> Visitor<'v> for IdVisitor<'a, O>
                         _: &hir::Generics,
                         _: NodeId,
                         _: Span) {
-        self.operation.visit_id(struct_def.id);
+        self.operation.visit_id(struct_def.id());
         visit::walk_struct_def(self, struct_def);
     }
 

src/librustc_lint/builtin.rs

@@ -527,7 +527,8 @@ impl LateLintPass for MissingDoc {
     }
 
     fn check_variant(&mut self, cx: &LateContext, v: &hir::Variant, _: &hir::Generics) {
-        self.check_missing_docs_attrs(cx, Some(v.node.data.id), &v.node.attrs, v.span, "a variant");
+        self.check_missing_docs_attrs(cx, Some(v.node.data.id()),
+                                      &v.node.attrs, v.span, "a variant");
         assert!(!self.in_variant);
         self.in_variant = true;
     }

src/librustc_privacy/lib.rs

@@ -82,7 +82,7 @@ impl<'v> Visitor<'v> for ParentVisitor {
                     // The parent is considered the enclosing enum because the
                     // enum will dictate the privacy visibility of this variant
                     // instead.
-                    self.parents.insert(variant.node.data.id, item.id);
+                    self.parents.insert(variant.node.data.id(), item.id);
                 }
             }
 
@@ -133,7 +133,7 @@ impl<'v> Visitor<'v> for ParentVisitor {
         // Struct constructors are parented to their struct definitions because
         // they essentially are the struct definitions.
         if !s.is_struct() {
-            self.parents.insert(s.id, item_id);
+            self.parents.insert(s.id(), item_id);
         }
 
         // While we have the id of the struct definition, go ahead and parent
@@ -233,8 +233,8 @@ impl<'a, 'tcx, 'v> Visitor<'v> for EmbargoVisitor<'a, 'tcx> {
             // public all variants are public unless they're explicitly priv
             hir::ItemEnum(ref def, _) if public_first => {
                 for variant in &def.variants {
-                    self.exported_items.insert(variant.node.data.id);
+                    self.exported_items.insert(variant.node.data.id());
-                    self.public_items.insert(variant.node.data.id);
+                    self.public_items.insert(variant.node.data.id());
                 }
             }
 
@@ -320,7 +320,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for EmbargoVisitor<'a, 'tcx> {
             // Struct constructors are public if the struct is all public.
             hir::ItemStruct(ref def, _) if public_first => {
                 if !def.is_struct() {
-                    self.exported_items.insert(def.id);
+                    self.exported_items.insert(def.id());
                 }
                 // fields can be public or private, so lets check
                 for field in def.fields() {
@@ -1431,7 +1431,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for VisiblePrivateTypesVisitor<'a, 'tcx> {
     }
 
     fn visit_variant(&mut self, v: &hir::Variant, g: &hir::Generics, item_id: ast::NodeId) {
-        if self.exported_items.contains(&v.node.data.id) {
+        if self.exported_items.contains(&v.node.data.id()) {
             self.in_variant = true;
             visit::walk_variant(self, v, g, item_id);
             self.in_variant = false;

src/librustc_resolve/build_reduced_graph.rs

@@ -495,7 +495,7 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> {
                 let (forbid, ctor_id) = if struct_def.is_struct() {
                     (ForbidDuplicateTypesAndModules, None)
                 } else {
-                    (ForbidDuplicateTypesAndValues, Some(struct_def.id))
+                    (ForbidDuplicateTypesAndValues, Some(struct_def.id()))
                 };
 
                 let name_bindings = self.add_child(name, parent, forbid, sp);
@@ -590,7 +590,7 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> {
         let name = variant.node.name;
         let is_exported = if variant.node.data.is_struct() {
             // Not adding fields for variants as they are not accessed with a self receiver
-            let variant_def_id = self.ast_map.local_def_id(variant.node.data.id);
+            let variant_def_id = self.ast_map.local_def_id(variant.node.data.id());
             self.structs.insert(variant_def_id, Vec::new());
             true
         } else {
@@ -603,10 +603,12 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> {
         // variants are always treated as importable to allow them to be glob
         // used
         child.define_value(DefVariant(item_id,
-                                      self.ast_map.local_def_id(variant.node.data.id), is_exported),
+                                      self.ast_map.local_def_id(variant.node.data.id()),
+                                      is_exported),
                            variant.span, DefModifiers::PUBLIC | DefModifiers::IMPORTABLE);
         child.define_type(DefVariant(item_id,
-                                     self.ast_map.local_def_id(variant.node.data.id), is_exported),
+                                     self.ast_map.local_def_id(variant.node.data.id()),
+                                     is_exported),
                           variant.span, DefModifiers::PUBLIC | DefModifiers::IMPORTABLE);
     }
 

src/librustc_trans/save/dump_csv.rs

@@ -467,7 +467,7 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> {
         self.fmt.struct_str(item.span,
                             sub_span,
                             item.id,
-                            def.id,
+                            def.id(),
                             &qualname,
                             self.cur_scope,
                             &val);
@@ -503,15 +503,15 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> {
 
             self.fmt.struct_variant_str(variant.span,
                                         self.span.span_for_first_ident(variant.span),
-                                        variant.node.data.id,
+                                        variant.node.data.id(),
-                                        variant.node.data.id,
+                                        variant.node.data.id(),
                                         &qualname,
                                         &enum_data.qualname,
                                         &val,
                                         enum_data.id);
 
             for field in variant.node.data.fields() {
-                self.process_struct_field_def(field, variant.node.data.id);
+                self.process_struct_field_def(field, variant.node.data.id());
                 self.visit_ty(&*field.node.ty);
             }
         }

src/librustc_trans/trans/base.rs

@@ -2458,7 +2458,7 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef {
                 ccx.sess().bug("attempt to register a constructor of \
                                   a non-tuple-like struct")
             } else {
-                struct_def.id
+                struct_def.id()
             };
             let parent = ccx.tcx().map.get_parent(id);
             let struct_item = ccx.tcx().map.expect_item(parent);

src/librustc_trans/trans/inline.rs

@@ -110,8 +110,8 @@ fn instantiate_inline(ccx: &CrateContext, fn_id: DefId)
                     let ty_vs = &ccx.tcx().lookup_adt_def(parent_id).variants;
                     assert_eq!(ast_vs.len(), ty_vs.len());
                     for (ast_v, ty_v) in ast_vs.iter().zip(ty_vs.iter()) {
-                        if ty_v.did == fn_id { my_id = ast_v.node.data.id; }
+                        if ty_v.did == fn_id { my_id = ast_v.node.data.id(); }
-                        ccx.external().borrow_mut().insert(ty_v.did, Some(ast_v.node.data.id));
+                        ccx.external().borrow_mut().insert(ty_v.did, Some(ast_v.node.data.id()));
                     }
                 }
                 hir::ItemStruct(ref struct_def, _) => {
@@ -119,8 +119,8 @@ fn instantiate_inline(ccx: &CrateContext, fn_id: DefId)
                         ccx.sess().bug("instantiate_inline: called on a \
                                                                  non-tuple struct")
                     } else {
-                        ccx.external().borrow_mut().insert(fn_id, Some(struct_def.id));
+                        ccx.external().borrow_mut().insert(fn_id, Some(struct_def.id()));
-                        my_id = struct_def.id;
+                        my_id = struct_def.id();
                     }
                 }
                 _ => ccx.sess().bug("instantiate_inline: item has a \

src/librustc_trans/trans/monomorphize.rs

@@ -250,7 +250,7 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
                 panic!("ast-mapped struct didn't have a ctor id")
             }
             base::trans_tuple_struct(ccx,
-                                     struct_def.id,
+                                     struct_def.id(),
                                      psubsts,
                                      d);
             d

src/librustc_typeck/collect.rs

@@ -1015,7 +1015,7 @@ fn convert_item(ccx: &CrateCtxt, it: &hir::Item) {
             }
 
             if !struct_def.is_struct() {
-                convert_variant_ctor(tcx, struct_def.id, variant, scheme, predicates);
+                convert_variant_ctor(tcx, struct_def.id(), variant, scheme, predicates);
             }
         },
         hir::ItemTy(_, ref generics) => {
@@ -1075,7 +1075,7 @@ fn convert_enum_variant_types<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>,
         // an item.
         convert_variant_ctor(
             ccx.tcx,
-            variant.node.data.id,
+            variant.node.data.id(),
             ty_variant,
             scheme.clone(),
             predicates.clone()
@@ -1126,7 +1126,7 @@ fn convert_struct_def<'tcx>(tcx: &ty::ctxt<'tcx>,
 
     let did = tcx.map.local_def_id(it.id);
     let ctor_id = if !def.is_struct() {
-        tcx.map.local_def_id(def.id)
+        tcx.map.local_def_id(def.id())
     } else {
         did
     };
@@ -1209,7 +1209,7 @@ fn convert_enum_def<'tcx>(tcx: &ty::ctxt<'tcx>,
                                   disr: ty::Disr)
                                   -> ty::VariantDefData<'tcx, 'tcx>
     {
-        let did = tcx.map.local_def_id(v.node.data.id);
+        let did = tcx.map.local_def_id(v.node.data.id());
         let name = v.node.name;
         convert_struct_variant(tcx, did, name, disr, &v.node.data)
     }

src/librustdoc/clean/mod.rs

@@ -1853,7 +1853,7 @@ impl Clean<Item> for doctree::Variant {
             source: self.whence.clean(cx),
             visibility: None,
             stability: self.stab.clean(cx),
-            def_id: cx.map.local_def_id(self.def.id),
+            def_id: cx.map.local_def_id(self.def.id()),
             inner: VariantItem(Variant {
                 kind: struct_def_to_variant_kind(&self.def, cx),
             }),

src/librustdoc/visit_ast.rs

@@ -111,7 +111,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
             variants: def.variants.iter().map(|v| Variant {
                 name: v.node.name,
                 attrs: v.node.attrs.clone(),
-                stab: self.stability(v.node.data.id),
+                stab: self.stability(v.node.data.id()),
                 def: v.node.data.clone(),
                 whence: v.span,
             }).collect(),

src/libsyntax/ast.rs

@@ -1742,18 +1742,10 @@ impl StructFieldKind {
 }
 
 #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
-pub enum VariantData_ {
+pub enum VariantData {
-    Struct(Vec<StructField>),
+    Struct(Vec<StructField>, NodeId),
-    Tuple(Vec<StructField>),
+    Tuple(Vec<StructField>, NodeId),
-    Unit,
+    Unit(NodeId),
-}
-
-#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
-pub struct VariantData {
-    pub data_: VariantData_,
-    /// ID of the constructor. This is only used for tuple- or enum-like
-    /// structs.
-    pub id: NodeId,
 }
 
 pub type FieldIter<'a> = iter::FlatMap<option::IntoIter<&'a Vec<StructField>>,
@@ -1763,19 +1755,24 @@ pub type FieldIter<'a> = iter::FlatMap<option::IntoIter<&'a Vec<StructField>>,
 impl VariantData {
     pub fn fields(&self) -> FieldIter {
         fn vec_iter<T>(v: &Vec<T>) -> slice::Iter<T> { v.iter() }
-        match self.data_ {
+        match *self {
-            VariantData_::Struct(ref fields) | VariantData_::Tuple(ref fields) => Some(fields),
+            VariantData::Struct(ref fields, _) | VariantData::Tuple(ref fields, _) => Some(fields),
             _ => None,
         }.into_iter().flat_map(vec_iter)
     }
+    pub fn id(&self) -> NodeId {
+        match *self {
+            VariantData::Struct(_, id) | VariantData::Tuple(_, id) | VariantData::Unit(id) => id
+        }
+    }
     pub fn is_struct(&self) -> bool {
-        if let VariantData_::Struct(..) = self.data_ { true } else { false }
+        if let VariantData::Struct(..) = *self { true } else { false }
     }
     pub fn is_tuple(&self) -> bool {
-        if let VariantData_::Tuple(..) = self.data_ { true } else { false }
+        if let VariantData::Tuple(..) = *self { true } else { false }
     }
     pub fn is_unit(&self) -> bool {
-        if let VariantData_::Unit = self.data_ { true } else { false }
+        if let VariantData::Unit(..) = *self { true } else { false }
     }
 }
 

src/libsyntax/ast_util.rs

@@ -458,7 +458,7 @@ impl<'a, 'v, O: IdVisitingOperation> Visitor<'v> for IdVisitor<'a, O> {
                         _: &ast::Generics,
                         _: NodeId,
                         _: Span) {
-        self.operation.visit_id(struct_def.id);
+        self.operation.visit_id(struct_def.id());
         visit::walk_struct_def(self, struct_def);
     }
 

src/libsyntax/config.rs

@@ -167,22 +167,19 @@ fn fold_item_underscore<F>(cx: &mut Context<F>, item: ast::Item_) -> ast::Item_
 fn fold_struct<F>(cx: &mut Context<F>, def: P<ast::VariantData>) -> P<ast::VariantData> where
     F: FnMut(&[ast::Attribute]) -> bool
 {
-    def.map(|ast::VariantData { data_, id }| {
+    def.map(|vdata| {
-        ast::VariantData {
+        match vdata {
-            data_: match data_ {
+            ast::VariantData::Struct(fields, id) => {
-                ast::VariantData_::Struct(fields) => {
+                ast::VariantData::Struct(fields.into_iter().filter(|m| {
-                    ast::VariantData_::Struct(fields.into_iter().filter(|m| {
+                    (cx.in_cfg)(&m.node.attrs)
-                        (cx.in_cfg)(&m.node.attrs)
+                }).collect(), id)
-                    }).collect())
+            }
-                }
+            ast::VariantData::Tuple(fields, id) => {
-                ast::VariantData_::Tuple(fields) => {
+                ast::VariantData::Tuple(fields.into_iter().filter(|m| {
-                    ast::VariantData_::Tuple(fields.into_iter().filter(|m| {
+                    (cx.in_cfg)(&m.node.attrs)
-                        (cx.in_cfg)(&m.node.attrs)
+                }).collect(), id)
-                    }).collect())
+            }
-                }
+            ast::VariantData::Unit(id) => ast::VariantData::Unit(id)
-                ast::VariantData_::Unit => ast::VariantData_::Unit
-            },
-            id: id,
         }
     })
 }

src/libsyntax/ext/build.rs

@@ -1002,18 +1002,17 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
             }}
         }).collect();
 
-        let data_ = if fields.is_empty() {
+        let vdata = if fields.is_empty() {
-            ast::VariantData_::Unit
+            ast::VariantData::Unit(ast::DUMMY_NODE_ID)
         } else {
-            ast::VariantData_::Tuple(fields)
+            ast::VariantData::Tuple(fields, ast::DUMMY_NODE_ID)
         };
 
         respan(span,
                ast::Variant_ {
                    name: name,
                    attrs: Vec::new(),
-                   data: P(ast::VariantData { data_: data_,
+                   data: P(vdata),
-                                           id: ast::DUMMY_NODE_ID}),
                    disr_expr: None,
                })
     }

src/libsyntax/fold.rs

@@ -815,17 +815,18 @@ pub fn noop_fold_where_predicate<T: Folder>(
 }
 
 pub fn noop_fold_struct_def<T: Folder>(struct_def: P<VariantData>, fld: &mut T) -> P<VariantData> {
-    struct_def.map(|VariantData { data_, id }| VariantData {
+    struct_def.map(|vdata| {
-        data_: match data_ {
+        match vdata {
-            ast::VariantData_::Struct(fields) => {
+            ast::VariantData::Struct(fields, id) => {
-                ast::VariantData_::Struct(fields.move_map(|f| fld.fold_struct_field(f)))
+                ast::VariantData::Struct(fields.move_map(|f| fld.fold_struct_field(f)),
+                                         fld.new_id(id))
             }
-            ast::VariantData_::Tuple(fields) => {
+            ast::VariantData::Tuple(fields, id) => {
-                ast::VariantData_::Tuple(fields.move_map(|f| fld.fold_struct_field(f)))
+                ast::VariantData::Tuple(fields.move_map(|f| fld.fold_struct_field(f)),
+                                        fld.new_id(id))
             }
-            ast::VariantData_::Unit => ast::VariantData_::Unit
+            ast::VariantData::Unit(id) => ast::VariantData::Unit(fld.new_id(id))
-        },
+        }
-        id: fld.new_id(id),
     })
 }
 

src/libsyntax/parse/parser.rs

@@ -45,7 +45,7 @@ use ast::{PatRegion, PatStruct, PatTup, PatVec, PatWild, PatWildMulti};
 use ast::PatWildSingle;
 use ast::{PolyTraitRef, QSelf};
 use ast::{Return, BiShl, BiShr, Stmt, StmtDecl};
-use ast::{StmtExpr, StmtSemi, StmtMac, VariantData, StructField, VariantData_};
+use ast::{StmtExpr, StmtSemi, StmtMac, VariantData, StructField};
 use ast::{BiSub, StrStyle};
 use ast::{SelfExplicit, SelfRegion, SelfStatic, SelfValue};
 use ast::{Delimited, SequenceRepetition, TokenTree, TraitItem, TraitRef};
@@ -4640,24 +4640,25 @@ impl<'a> Parser<'a> {
         // Otherwise if we look ahead and see a paren we parse a tuple-style
         // struct.
 
-        let data_ = if self.token.is_keyword(keywords::Where) {
+        let vdata = if self.token.is_keyword(keywords::Where) {
             generics.where_clause = try!(self.parse_where_clause());
             if try!(self.eat(&token::Semi)) {
                 // If we see a: `struct Foo<T> where T: Copy;` style decl.
-                VariantData_::Unit
+                VariantData::Unit(ast::DUMMY_NODE_ID)
             } else {
                 // If we see: `struct Foo<T> where T: Copy { ... }`
-                VariantData_::Struct(try!(self.parse_record_struct_body()))
+                VariantData::Struct(try!(self.parse_record_struct_body()), ast::DUMMY_NODE_ID)
             }
         // No `where` so: `struct Foo<T>;`
         } else if try!(self.eat(&token::Semi) ){
-            VariantData_::Unit
+            VariantData::Unit(ast::DUMMY_NODE_ID)
         // Record-style struct definition
         } else if self.token == token::OpenDelim(token::Brace) {
-            VariantData_::Struct(try!(self.parse_record_struct_body()))
+            VariantData::Struct(try!(self.parse_record_struct_body()), ast::DUMMY_NODE_ID)
         // Tuple-style struct definition with optional where-clause.
         } else if self.token == token::OpenDelim(token::Paren) {
-            VariantData_::Tuple(try!(self.parse_tuple_struct_body(&mut generics)))
+            VariantData::Tuple(try!(self.parse_tuple_struct_body(&mut generics)),
+                               ast::DUMMY_NODE_ID)
         } else {
             let token_str = self.this_token_to_string();
             return Err(self.fatal(&format!("expected `where`, `{{`, `(`, or `;` after struct \
@@ -4665,11 +4666,8 @@ impl<'a> Parser<'a> {
         };
 
         Ok((class_name,
-         ItemStruct(P(ast::VariantData {
+            ItemStruct(P(vdata), generics),
-             data_: data_,
+            None))
-             id: ast::DUMMY_NODE_ID,
-         }), generics),
-         None))
     }
 
     pub fn parse_record_struct_body(&mut self) -> PResult<Vec<StructField>> {
@@ -5107,10 +5105,7 @@ impl<'a> Parser<'a> {
         }
         try!(self.bump());
 
-        Ok(P(VariantData {
+        Ok(P(VariantData::Struct(fields, ast::DUMMY_NODE_ID)))
-            data_: VariantData_::Struct(fields),
-            id: ast::DUMMY_NODE_ID,
-        }))
     }
 
     /// Parse the part of an "enum" decl following the '{'
@@ -5146,16 +5141,13 @@ impl<'a> Parser<'a> {
                         id: ast::DUMMY_NODE_ID,
                     }});
                 }
-                struct_def = P(VariantData { data_: ast::VariantData_::Tuple(fields),
+                struct_def = P(ast::VariantData::Tuple(fields, ast::DUMMY_NODE_ID));
-                                           id: ast::DUMMY_NODE_ID});
             } else if try!(self.eat(&token::Eq) ){
                 disr_expr = Some(try!(self.parse_expr_nopanic()));
                 any_disr = disr_expr.as_ref().map(|expr| expr.span);
-                struct_def = P(VariantData { data_: ast::VariantData_::Unit,
+                struct_def = P(ast::VariantData::Unit(ast::DUMMY_NODE_ID));
-                                           id: ast::DUMMY_NODE_ID});
             } else {
-                struct_def = P(VariantData { data_: ast::VariantData_::Unit,
+                struct_def = P(ast::VariantData::Unit(ast::DUMMY_NODE_ID));
-                                           id: ast::DUMMY_NODE_ID});
             }
 
             let vr = ast::Variant_ {

src/libsyntax/print/pprust.rs

@@ -3131,8 +3131,7 @@ mod tests {
             name: ident,
             attrs: Vec::new(),
             // making this up as I go.... ?
-            data: P(ast::VariantData { data_: ast::VariantData_::Unit,
+            data: P(ast::VariantData::Unit(ast::DUMMY_NODE_ID)),
-                                    id: ast::DUMMY_NODE_ID}),
             disr_expr: None,
         });