Remove now redundant NodeId from Variant

src/librustc/front/map/collector.rs

@@ -134,7 +134,7 @@ fn visit_item(&mut self, i: &'ast Item) {
             ItemEnum(ref enum_definition, _) => {
                 for v in &enum_definition.variants {
                     let variant_def_index =
-                        self.insert_def(v.node.id,
+                        self.insert_def(v.node.def.id,
                                         NodeVariant(&**v),
                                         DefPathData::EnumVariant(v.node.name));
 

src/librustc/lint/context.rs

@@ -665,10 +665,10 @@ fn visit_struct_def(&mut self,
                         s: &hir::StructDef,
                         name: ast::Name,
                         g: &hir::Generics,
-                        id: ast::NodeId) {
-        run_lints!(self, check_struct_def, late_passes, s, name, g, id);
+                        item_id: ast::NodeId) {
+        run_lints!(self, check_struct_def, late_passes, s, name, g, item_id);
         hir_visit::walk_struct_def(self, s);
-        run_lints!(self, check_struct_def_post, late_passes, s, name, g, id);
+        run_lints!(self, check_struct_def_post, late_passes, s, name, g, item_id);
     }
 
     fn visit_struct_field(&mut self, s: &hir::StructField) {
@@ -678,10 +678,10 @@ fn visit_struct_field(&mut self, s: &hir::StructField) {
         })
     }
 
-    fn visit_variant(&mut self, v: &hir::Variant, g: &hir::Generics) {
+    fn visit_variant(&mut self, v: &hir::Variant, g: &hir::Generics, item_id: ast::NodeId) {
         self.with_lint_attrs(&v.node.attrs, |cx| {
             run_lints!(cx, check_variant, late_passes, v, g);
-            hir_visit::walk_variant(cx, v, g);
+            hir_visit::walk_variant(cx, v, g, item_id);
             run_lints!(cx, check_variant_post, late_passes, v, g);
         })
     }
@@ -814,10 +814,10 @@ fn visit_struct_def(&mut self,
                         s: &ast::StructDef,
                         ident: ast::Ident,
                         g: &ast::Generics,
-                        id: ast::NodeId) {
-        run_lints!(self, check_struct_def, early_passes, s, ident, g, id);
+                        item_id: ast::NodeId) {
+        run_lints!(self, check_struct_def, early_passes, s, ident, g, item_id);
         ast_visit::walk_struct_def(self, s);
-        run_lints!(self, check_struct_def_post, early_passes, s, ident, g, id);
+        run_lints!(self, check_struct_def_post, early_passes, s, ident, g, item_id);
     }
 
     fn visit_struct_field(&mut self, s: &ast::StructField) {
@@ -827,10 +827,10 @@ fn visit_struct_field(&mut self, s: &ast::StructField) {
         })
     }
 
-    fn visit_variant(&mut self, v: &ast::Variant, g: &ast::Generics) {
+    fn visit_variant(&mut self, v: &ast::Variant, g: &ast::Generics, item_id: ast::NodeId) {
         self.with_lint_attrs(&v.node.attrs, |cx| {
             run_lints!(cx, check_variant, early_passes, v, g);
-            ast_visit::walk_variant(cx, v, g);
+            ast_visit::walk_variant(cx, v, g, item_id);
             run_lints!(cx, check_variant_post, early_passes, v, g);
         })
     }

src/librustc/metadata/encoder.rs

@@ -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.id));
+            encode_variant_id(rbml_w, ecx.tcx.map.local_def_id(v.node.def.id));
         }
         encode_inlined_item(ecx, rbml_w, InlinedItemRef::Item(item));
         encode_path(rbml_w, path);

src/librustc/middle/check_static_recursion.rs

@@ -54,7 +54,7 @@ fn visit_item(&mut self, it: &'ast hir::Item) {
                         let mut recursion_visitor =
                             CheckItemRecursionVisitor::new(self, &variant.span);
                         recursion_visitor.populate_enum_discriminants(enum_def);
-                        recursion_visitor.visit_variant(variant, generics);
+                        recursion_visitor.visit_variant(variant, generics, it.id);
                     }
                 }
             }
@@ -168,7 +168,7 @@ fn populate_enum_discriminants(&self, enum_definition: &'ast hir::EnumDef) {
         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.id) => {
+            Some(variant) if discriminant_map.contains_key(&variant.node.def.id) => {
                 return;
             }
             _ => {}
@@ -177,7 +177,7 @@ fn populate_enum_discriminants(&self, enum_definition: &'ast hir::EnumDef) {
         // 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.id);
+            variant_stack.push(variant.node.def.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 {
@@ -201,14 +201,14 @@ fn visit_item(&mut self, it: &'ast hir::Item) {
     }
 
     fn visit_enum_def(&mut self, enum_definition: &'ast hir::EnumDef,
-                      generics: &'ast hir::Generics) {
+                      generics: &'ast hir::Generics, item_id: ast::NodeId) {
         self.populate_enum_discriminants(enum_definition);
-        visit::walk_enum_def(self, enum_definition, generics);
+        visit::walk_enum_def(self, enum_definition, generics, item_id);
     }
 
     fn visit_variant(&mut self, variant: &'ast hir::Variant,
-                     _: &'ast hir::Generics) {
-        let variant_id = variant.node.id;
+                     _: &'ast hir::Generics, _: ast::NodeId) {
+        let variant_id = variant.node.def.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`
@@ -269,9 +269,10 @@ fn visit_expr(&mut self, e: &'ast hir::Expr) {
                                 self.ast_map.expect_item(enum_node_id).node
                             {
                                 self.populate_enum_discriminants(enum_def);
+                                let enum_id = self.ast_map.as_local_node_id(enum_id).unwrap();
                                 let variant_id = self.ast_map.as_local_node_id(variant_id).unwrap();
                                 let variant = self.ast_map.expect_variant(variant_id);
-                                self.visit_variant(variant, generics);
+                                self.visit_variant(variant, generics, enum_id);
                             } else {
                                 self.sess.span_bug(e.span,
                                                    "`check_static_recursion` found \

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.id == id {
+            if variant.node.def.id == id {
                 return variant.node.disr_expr.as_ref().map(|e| &**e);
             }
         }

src/librustc/middle/dead.rs

@@ -339,7 +339,7 @@ fn visit_item(&mut self, item: &hir::Item) {
         }
         match item.node {
             hir::ItemEnum(ref enum_def, _) if allow_dead_code => {
-                self.worklist.extend(enum_def.variants.iter().map(|variant| variant.node.id));
+                self.worklist.extend(enum_def.variants.iter().map(|variant| variant.node.def.id));
             }
             hir::ItemTrait(_, _, _, ref trait_items) => {
                 for trait_item in trait_items {
@@ -466,7 +466,7 @@ fn should_warn_about_field(&mut self, node: &hir::StructField_) -> bool {
     }
 
     fn should_warn_about_variant(&mut self, variant: &hir::Variant_) -> bool {
-        !self.symbol_is_live(variant.id, None)
+        !self.symbol_is_live(variant.def.id, None)
             && !has_allow_dead_code_or_lang_attr(&variant.attrs)
     }
 
@@ -542,7 +542,7 @@ fn visit_item(&mut self, item: &hir::Item) {
                 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.id, variant.span,
+                            self.warn_dead_code(variant.node.def.id, variant.span,
                                                 variant.node.name, "variant");
                         }
                     }

src/librustc/middle/stability.rs

@@ -207,9 +207,9 @@ fn visit_impl_item(&mut self, ii: &hir::ImplItem) {
                       |v| visit::walk_impl_item(v, ii), true);
     }
 
-    fn visit_variant(&mut self, var: &Variant, g: &'v Generics) {
-        self.annotate(var.node.id, true, &var.node.attrs, var.span,
-                      |v| visit::walk_variant(v, var, g), true)
+    fn visit_variant(&mut self, var: &Variant, g: &'v Generics, item_id: NodeId) {
+        self.annotate(var.node.def.id, true, &var.node.attrs, var.span,
+                      |v| visit::walk_variant(v, var, g, item_id), true)
     }
 
     fn visit_struct_field(&mut self, s: &StructField) {

src/librustc_back/svh.rs

@@ -301,18 +301,17 @@ fn saw_stmt(node: &Stmt_) -> SawStmtComponent {
     }
 
     impl<'a, 'v> Visitor<'v> for StrictVersionHashVisitor<'a> {
-        fn visit_struct_def(&mut self, s: &StructDef, name: Name,
-                            g: &Generics, _: NodeId) {
+        fn visit_struct_def(&mut self, s: &StructDef, name: Name, g: &Generics, _: NodeId) {
             SawStructDef(name.as_str()).hash(self.st);
             visit::walk_generics(self, g);
             visit::walk_struct_def(self, s)
         }
 
-        fn visit_variant(&mut self, v: &Variant, g: &Generics) {
+        fn visit_variant(&mut self, v: &Variant, g: &Generics, item_id: NodeId) {
             SawVariant.hash(self.st);
             // walk_variant does not call walk_generics, so do it here.
             visit::walk_generics(self, g);
-            visit::walk_variant(self, v, g)
+            visit::walk_variant(self, v, g, item_id)
         }
 
         // All of the remaining methods just record (in the hash

src/librustc_front/fold.rs

@@ -435,9 +435,8 @@ pub fn noop_fold_foreign_mod<T: Folder>(ForeignMod { abi, items }: ForeignMod,
 }
 
 pub fn noop_fold_variant<T: Folder>(v: P<Variant>, fld: &mut T) -> P<Variant> {
-    v.map(|Spanned {node: Variant_ {id, name, attrs, def, disr_expr}, span}| Spanned {
+    v.map(|Spanned {node: Variant_ {name, attrs, def, disr_expr}, span}| Spanned {
         node: Variant_ {
-            id: fld.new_id(id),
             name: name,
             attrs: fold_attrs(attrs, fld),
             def: fld.fold_struct_def(def),

src/librustc_front/hir.rs

@@ -1030,7 +1030,6 @@ pub struct Variant_ {
     pub name: Name,
     pub attrs: Vec<Attribute>,
     pub def: P<StructDef>,
-    pub id: NodeId,
     /// Explicit discriminant, eg `Foo = 1`
     pub disr_expr: Option<P<Expr>>,
 }

src/librustc_front/lowering.rs

@@ -264,7 +264,6 @@ pub fn lower_foreign_mod(_lctx: &LoweringContext, fm: &ForeignMod) -> hir::Forei
 pub fn lower_variant(_lctx: &LoweringContext, v: &Variant) -> P<hir::Variant> {
     P(Spanned {
         node: hir::Variant_ {
-            id: v.node.id,
             name: v.node.name.name,
             attrs: v.node.attrs.clone(),
             def: lower_struct_def(_lctx, &v.node.def),

src/librustc_front/util.rs

@@ -194,11 +194,6 @@ fn visit_item(&mut self, item: &Item) {
                     }
                 }
             }
-            ItemEnum(ref enum_definition, _) => {
-                for variant in &enum_definition.variants {
-                    self.operation.visit_id(variant.node.id)
-                }
-            }
             _ => {}
         }
 
@@ -290,8 +285,7 @@ fn visit_struct_def(&mut self,
                         struct_def: &StructDef,
                         _: Name,
                         _: &hir::Generics,
-                        id: NodeId) {
-        self.operation.visit_id(id);
+                        _: NodeId) {
         self.operation.visit_id(struct_def.id);
         visit::walk_struct_def(self, struct_def);
     }

src/librustc_front/visit.rs

@@ -118,14 +118,13 @@ fn visit_struct_def(&mut self, s: &'v StructDef, _: Name, _: &'v Generics, _: No
     fn visit_struct_field(&mut self, s: &'v StructField) {
         walk_struct_field(self, s)
     }
-    fn visit_enum_def(&mut self, enum_definition: &'v EnumDef, generics: &'v Generics) {
-        walk_enum_def(self, enum_definition, generics)
+    fn visit_enum_def(&mut self, enum_definition: &'v EnumDef,
+                      generics: &'v Generics, item_id: NodeId) {
+        walk_enum_def(self, enum_definition, generics, item_id)
     }
-
-    fn visit_variant(&mut self, v: &'v Variant, g: &'v Generics) {
-        walk_variant(self, v, g)
+    fn visit_variant(&mut self, v: &'v Variant, g: &'v Generics, item_id: NodeId) {
+        walk_variant(self, v, g, item_id)
     }
-
     fn visit_lifetime(&mut self, lifetime: &'v Lifetime) {
         walk_lifetime(self, lifetime)
     }
@@ -293,7 +292,7 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) {
         }
         ItemEnum(ref enum_definition, ref type_parameters) => {
             visitor.visit_generics(type_parameters);
-            visitor.visit_enum_def(enum_definition, type_parameters)
+            visitor.visit_enum_def(enum_definition, type_parameters, item.id)
         }
         ItemDefaultImpl(_, ref trait_ref) => {
             visitor.visit_trait_ref(trait_ref)
@@ -310,7 +309,7 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) {
         }
         ItemStruct(ref struct_definition, ref generics) => {
             visitor.visit_generics(generics);
-            visitor.visit_struct_def(struct_definition, item.name, generics, item.id)
+            visitor.visit_struct_def(struct_definition, item.name, generics, item.id);
         }
         ItemTrait(_, ref generics, ref bounds, ref methods) => {
             visitor.visit_generics(generics);
@@ -323,17 +322,19 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) {
 
 pub fn walk_enum_def<'v, V: Visitor<'v>>(visitor: &mut V,
                                          enum_definition: &'v EnumDef,
-                                         generics: &'v Generics) {
+                                         generics: &'v Generics,
+                                         item_id: NodeId) {
     for variant in &enum_definition.variants {
-        visitor.visit_variant(variant, generics);
+        visitor.visit_variant(variant, generics, item_id);
     }
 }
 
 pub fn walk_variant<'v, V: Visitor<'v>>(visitor: &mut V,
                                         variant: &'v Variant,
-                                        generics: &'v Generics) {
+                                        generics: &'v Generics,
+                                        item_id: NodeId) {
     visitor.visit_name(variant.span, variant.node.name);
-    visitor.visit_struct_def(&variant.node.def, variant.node.name, generics, variant.node.id);
+    visitor.visit_struct_def(&variant.node.def, variant.node.name, generics, item_id);
     walk_list!(visitor, visit_expr, &variant.node.disr_expr);
     walk_list!(visitor, visit_attribute, &variant.node.attrs);
 }

src/librustc_lint/builtin.rs

@@ -428,14 +428,14 @@ fn exit_lint_attrs(&mut self, _: &LateContext, _: &[ast::Attribute]) {
     }
 
     fn check_struct_def(&mut self, _: &LateContext, _: &hir::StructDef,
-                        _: ast::Name, _: &hir::Generics, id: ast::NodeId) {
-        self.struct_def_stack.push(id);
+                        _: ast::Name, _: &hir::Generics, item_id: ast::NodeId) {
+        self.struct_def_stack.push(item_id);
     }
 
     fn check_struct_def_post(&mut self, _: &LateContext, _: &hir::StructDef,
-                             _: ast::Name, _: &hir::Generics, id: ast::NodeId) {
+                             _: ast::Name, _: &hir::Generics, item_id: ast::NodeId) {
         let popped = self.struct_def_stack.pop().expect("empty struct_def_stack");
-        assert!(popped == id);
+        assert!(popped == item_id);
     }
 
     fn check_crate(&mut self, cx: &LateContext, krate: &hir::Crate) {
@@ -527,7 +527,7 @@ fn check_struct_field(&mut self, cx: &LateContext, sf: &hir::StructField) {
     }
 
     fn check_variant(&mut self, cx: &LateContext, v: &hir::Variant, _: &hir::Generics) {
-        self.check_missing_docs_attrs(cx, Some(v.node.id), &v.node.attrs, v.span, "a variant");
+        self.check_missing_docs_attrs(cx, Some(v.node.def.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 @@ fn visit_item(&mut self, item: &hir::Item) {
                     // The parent is considered the enclosing enum because the
                     // enum will dictate the privacy visibility of this variant
                     // instead.
-                    self.parents.insert(variant.node.id, item.id);
+                    self.parents.insert(variant.node.def.id, item.id);
                 }
             }
 
@@ -129,11 +129,11 @@ fn visit_impl_item(&mut self, ii: &'v hir::ImplItem) {
     }
 
     fn visit_struct_def(&mut self, s: &hir::StructDef, _: ast::Name,
-                        _: &'v hir::Generics, n: ast::NodeId) {
+                        _: &'v hir::Generics, item_id: ast::NodeId) {
         // Struct constructors are parented to their struct definitions because
         // they essentially are the struct definitions.
         if s.kind != hir::VariantKind::Dict {
-            self.parents.insert(s.id, n);
+            self.parents.insert(s.id, item_id);
         }
 
         // While we have the id of the struct definition, go ahead and parent
@@ -233,8 +233,8 @@ fn visit_item(&mut self, item: &hir::Item) {
             // 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.id);
-                    self.public_items.insert(variant.node.id);
+                    self.exported_items.insert(variant.node.def.id);
+                    self.public_items.insert(variant.node.def.id);
                 }
             }
 
@@ -1430,10 +1430,10 @@ fn visit_ty(&mut self, t: &hir::Ty) {
         visit::walk_ty(self, t)
     }
 
-    fn visit_variant(&mut self, v: &hir::Variant, g: &hir::Generics) {
-        if self.exported_items.contains(&v.node.id) {
+    fn visit_variant(&mut self, v: &hir::Variant, g: &hir::Generics, item_id: ast::NodeId) {
+        if self.exported_items.contains(&v.node.def.id) {
             self.in_variant = true;
-            visit::walk_variant(self, v, g);
+            visit::walk_variant(self, v, g, item_id);
             self.in_variant = false;
         }
     }

src/librustc_resolve/build_reduced_graph.rs

@@ -590,7 +590,7 @@ fn build_reduced_graph_for_variant(&mut self,
         let is_exported = match variant.node.def.kind {
             hir::VariantKind::Dict => {
                 // 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.id);
+                let variant_def_id = self.ast_map.local_def_id(variant.node.def.id);
                 self.structs.insert(variant_def_id, Vec::new());
                 true
             }
@@ -603,10 +603,10 @@ fn build_reduced_graph_for_variant(&mut self,
         // 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.id), is_exported),
+                                      self.ast_map.local_def_id(variant.node.def.id), is_exported),
                            variant.span, DefModifiers::PUBLIC | DefModifiers::IMPORTABLE);
         child.define_type(DefVariant(item_id,
-                                     self.ast_map.local_def_id(variant.node.id), is_exported),
+                                     self.ast_map.local_def_id(variant.node.def.id), is_exported),
                           variant.span, DefModifiers::PUBLIC | DefModifiers::IMPORTABLE);
     }
 

src/librustc_resolve/lib.rs

@@ -491,7 +491,7 @@ fn visit_poly_trait_ref(&mut self,
         }
         visit::walk_poly_trait_ref(self, tref, m);
     }
-    fn visit_variant(&mut self, variant: &hir::Variant, generics: &Generics) {
+    fn visit_variant(&mut self, variant: &hir::Variant, generics: &Generics, item_id: ast::NodeId) {
         execute_callback!(hir_map::Node::NodeVariant(variant), self);
         if let Some(ref dis_expr) = variant.node.disr_expr {
             // resolve the discriminator expr as a constant
@@ -501,7 +501,7 @@ fn visit_variant(&mut self, variant: &hir::Variant, generics: &Generics) {
         }
 
         // `visit::walk_variant` without the discriminant expression.
-        self.visit_struct_def(&variant.node.def, variant.node.name, generics, variant.node.id);
+        self.visit_struct_def(&variant.node.def, variant.node.name, generics, item_id);
     }
     fn visit_foreign_item(&mut self, foreign_item: &hir::ForeignItem) {
         execute_callback!(hir_map::Node::NodeForeignItem(foreign_item), self);

src/librustc_trans/save/dump_csv.rs

@@ -503,7 +503,7 @@ fn process_enum(&mut self,
 
             self.fmt.struct_variant_str(variant.span,
                                         self.span.span_for_first_ident(variant.span),
-                                        variant.node.id,
+                                        variant.node.def.id,
                                         variant.node.def.id,
                                         &qualname,
                                         &enum_data.qualname,
@@ -511,7 +511,7 @@ fn process_enum(&mut self,
                                         enum_data.id);
 
             for field in &variant.node.def.fields {
-                self.process_struct_field_def(field, variant.node.id);
+                self.process_struct_field_def(field, variant.node.def.id);
                 self.visit_ty(&*field.node.ty);
             }
         }

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.id; }
-                        ccx.external().borrow_mut().insert(ty_v.did, Some(ast_v.node.id));
+                        if ty_v.did == fn_id { my_id = ast_v.node.def.id; }
+                        ccx.external().borrow_mut().insert(ty_v.did, Some(ast_v.node.def.id));
                     }
                 }
                 hir::ItemStruct(ref struct_def, _) => {

src/librustc_typeck/collect.rs

@@ -1075,7 +1075,7 @@ fn convert_enum_variant_types<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>,
         // an item.
         convert_variant_ctor(
             ccx.tcx,
-            variant.node.id,
+            variant.node.def.id,
             ty_variant,
             scheme.clone(),
             predicates.clone()
@@ -1206,7 +1206,7 @@ fn convert_enum_variant<'tcx>(tcx: &ty::ctxt<'tcx>,
                                   disr: ty::Disr)
                                   -> ty::VariantDefData<'tcx, 'tcx>
     {
-        let did = tcx.map.local_def_id(v.node.id);
+        let did = tcx.map.local_def_id(v.node.def.id);
         let name = v.node.name;
         convert_struct_variant(tcx, did, name, disr, &v.node.def)
     }

src/librustdoc/clean/mod.rs

@@ -1853,7 +1853,7 @@ fn clean(&self, cx: &DocContext) -> Item {
             source: self.whence.clean(cx),
             visibility: None,
             stability: self.stab.clean(cx),
-            def_id: cx.map.local_def_id(self.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/doctree.rs

@@ -120,7 +120,6 @@ pub struct Variant {
     pub name: Name,
     pub attrs: Vec<ast::Attribute>,
     pub def: P<hir::StructDef>,
-    pub id: ast::NodeId,
     pub stab: Option<attr::Stability>,
     pub whence: Span,
 }

src/librustdoc/visit_ast.rs

@@ -111,8 +111,7 @@ pub fn visit_enum_def(&mut self, it: &hir::Item,
             variants: def.variants.iter().map(|v| Variant {
                 name: v.node.name,
                 attrs: v.node.attrs.clone(),
-                stab: self.stability(v.node.id),
-                id: v.node.id,
+                stab: self.stability(v.node.def.id),
                 def: v.node.def.clone(),
                 whence: v.span,
             }).collect(),

src/libsyntax/ast.rs

@@ -1586,7 +1586,6 @@ pub struct Variant_ {
     pub name: Ident,
     pub attrs: Vec<Attribute>,
     pub def: P<StructDef>,
-    pub id: NodeId,
     /// Explicit discriminant, eg `Foo = 1`
     pub disr_expr: Option<P<Expr>>,
 }

src/libsyntax/ast_util.rs

@@ -360,11 +360,6 @@ fn visit_item(&mut self, item: &Item) {
                     }
                 }
             }
-            ItemEnum(ref enum_definition, _) => {
-                for variant in &enum_definition.variants {
-                    self.operation.visit_id(variant.node.id)
-                }
-            }
             _ => {}
         }
 
@@ -461,8 +456,7 @@ fn visit_struct_def(&mut self,
                         struct_def: &StructDef,
                         _: ast::Ident,
                         _: &ast::Generics,
-                        id: NodeId) {
-        self.operation.visit_id(id);
+                        _: NodeId) {
         self.operation.visit_id(struct_def.id);
         visit::walk_struct_def(self, struct_def);
     }

src/libsyntax/config.rs

@@ -140,11 +140,10 @@ fn fold_item_underscore<F>(cx: &mut Context<F>, item: ast::Item_) -> ast::Item_
                 if !(cx.in_cfg)(&v.node.attrs) {
                     None
                 } else {
-                    Some(v.map(|Spanned {node: ast::Variant_ {id, name, attrs, def,
+                    Some(v.map(|Spanned {node: ast::Variant_ {name, attrs, def,
                                                               disr_expr}, span}| {
                         Spanned {
                             node: ast::Variant_ {
-                                id: id,
                                 name: name,
                                 attrs: attrs,
                                 def: fold_struct(cx, def),

src/libsyntax/ext/build.rs

@@ -1011,7 +1011,6 @@ fn variant(&self, span: Span, name: Ident, tys: Vec<P<ast::Ty>> ) -> ast::Varian
                    def: P(ast::StructDef { fields: fields,
                                            id: ast::DUMMY_NODE_ID,
                                            kind: kind }),
-                   id: ast::DUMMY_NODE_ID,
                    disr_expr: None,
                })
     }

src/libsyntax/fold.rs

@@ -450,9 +450,8 @@ pub fn noop_fold_foreign_mod<T: Folder>(ForeignMod {abi, items}: ForeignMod,
 }
 
 pub fn noop_fold_variant<T: Folder>(v: P<Variant>, fld: &mut T) -> P<Variant> {
-    v.map(|Spanned {node: Variant_ {id, name, attrs, def, disr_expr}, span}| Spanned {
+    v.map(|Spanned {node: Variant_ {name, attrs, def, disr_expr}, span}| Spanned {
         node: Variant_ {
-            id: fld.new_id(id),
             name: name,
             attrs: fold_attrs(attrs, fld),
             def: fld.fold_struct_def(def),

src/libsyntax/parse/parser.rs

@@ -5176,7 +5176,6 @@ fn parse_enum_def(&mut self, _generics: &ast::Generics) -> PResult<EnumDef> {
                 name: ident,
                 attrs: variant_attrs,
                 def: struct_def,
-                id: ast::DUMMY_NODE_ID,
                 disr_expr: disr_expr,
             };
             variants.push(P(spanned(vlo, self.last_span.hi, vr)));

src/libsyntax/print/pprust.rs

@@ -3122,7 +3122,6 @@ fn test_variant_to_string() {
             def: P(ast::StructDef { fields: Vec::new(),
                                     id: ast::DUMMY_NODE_ID,
                                     kind: ast::VariantKind::Unit }),
-            id: 0,
             disr_expr: None,
         });
 

src/libsyntax/visit.rs

@@ -85,12 +85,12 @@ fn visit_struct_def(&mut self, s: &'v StructDef, _: Ident, _: &'v Generics, _: N
     }
     fn visit_struct_field(&mut self, s: &'v StructField) { walk_struct_field(self, s) }
     fn visit_enum_def(&mut self, enum_definition: &'v EnumDef,
-                      generics: &'v Generics) {
-        walk_enum_def(self, enum_definition, generics)
+                      generics: &'v Generics, item_id: NodeId) {
+        walk_enum_def(self, enum_definition, generics, item_id)
+    }
+    fn visit_variant(&mut self, v: &'v Variant, g: &'v Generics, item_id: NodeId) {
+        walk_variant(self, v, g, item_id)
     }
-
-    fn visit_variant(&mut self, v: &'v Variant, g: &'v Generics) { walk_variant(self, v, g) }
-
     fn visit_lifetime(&mut self, lifetime: &'v Lifetime) {
         walk_lifetime(self, lifetime)
     }
@@ -271,7 +271,7 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) {
         }
         ItemEnum(ref enum_definition, ref type_parameters) => {
             visitor.visit_generics(type_parameters);
-            visitor.visit_enum_def(enum_definition, type_parameters)
+            visitor.visit_enum_def(enum_definition, type_parameters, item.id)
         }
         ItemDefaultImpl(_, ref trait_ref) => {
             visitor.visit_trait_ref(trait_ref)
@@ -288,10 +288,7 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) {
         }
         ItemStruct(ref struct_definition, ref generics) => {
             visitor.visit_generics(generics);
-            visitor.visit_struct_def(struct_definition,
-                                     item.ident,
-                                     generics,
-                                     item.id)
+            visitor.visit_struct_def(struct_definition, item.ident, generics, item.id);
         }
         ItemTrait(_, ref generics, ref bounds, ref methods) => {
             visitor.visit_generics(generics);
@@ -305,17 +302,19 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) {
 
 pub fn walk_enum_def<'v, V: Visitor<'v>>(visitor: &mut V,
                                          enum_definition: &'v EnumDef,
-                                         generics: &'v Generics) {
+                                         generics: &'v Generics,
+                                         item_id: NodeId) {
     for variant in &enum_definition.variants {
-        visitor.visit_variant(variant, generics);
+        visitor.visit_variant(variant, generics, item_id);
     }
 }
 
 pub fn walk_variant<'v, V: Visitor<'v>>(visitor: &mut V,
                                         variant: &'v Variant,
-                                        generics: &'v Generics) {
+                                        generics: &'v Generics,
+                                        item_id: NodeId) {
     visitor.visit_ident(variant.span, variant.node.name);
-    visitor.visit_struct_def(&variant.node.def, variant.node.name, generics, variant.node.id);
+    visitor.visit_struct_def(&variant.node.def, variant.node.name, generics, item_id);
     walk_list!(visitor, visit_expr, &variant.node.disr_expr);
     walk_list!(visitor, visit_attribute, &variant.node.attrs);
 }