user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Remove now redundant NodeId from Variant

Browse source
This commit is contained in:
Vadim Petrochenkov 2015-10-02 16:14:20 +03:00
parent 495566ee61
commit 877c35e8a2
31 changed files with 88 additions and 111 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/librustc/front/map/collector.rs
View file

@ -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.id,
self.insert_def(v.node.def.id,
NodeVariant(&**v),
DefPathData::EnumVariant(v.node.name));

20
src/librustc/lint/context.rs
View file

@ -665,10 +665,10 @@ impl<'a, 'tcx, 'v> hir_visit::Visitor<'v> for LateContext<'a, 'tcx> {
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 @@ impl<'a, 'tcx, 'v> hir_visit::Visitor<'v> for LateContext<'a, 'tcx> {
})
}
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 @@ impl<'a, 'v> ast_visit::Visitor<'v> for EarlyContext<'a> {
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 @@ impl<'a, 'v> ast_visit::Visitor<'v> for EarlyContext<'a> {
})
}
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);
})
}

2
src/librustc/metadata/encoder.rs
View file

@ -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);

17
src/librustc/middle/check_static_recursion.rs
View file

@ -54,7 +54,7 @@ impl<'a, 'ast: 'a> Visitor<'ast> for CheckCrateVisitor<'a, 'ast> {
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 @@ 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.id) => {
Some(variant) if discriminant_map.contains_key(&variant.node.def.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.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 @@ impl<'a, 'ast: 'a> Visitor<'ast> for CheckItemRecursionVisitor<'a, 'ast> {
}
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 @@ impl<'a, 'ast: 'a> Visitor<'ast> for CheckItemRecursionVisitor<'a, 'ast> {
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 \

2
src/librustc/middle/const_eval.rs
View file

@ -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);
}
}

6
src/librustc/middle/dead.rs
View file

@ -339,7 +339,7 @@ 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.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 @@ impl<'a, 'tcx> DeadVisitor<'a, 'tcx> {
}
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 @@ 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.id, variant.span,
self.warn_dead_code(variant.node.def.id, variant.span,
variant.node.name, "variant");
}
}

6
src/librustc/middle/stability.rs
View file

@ -207,9 +207,9 @@ impl<'a, 'tcx, 'v> Visitor<'v> for Annotator<'a, 'tcx> {
|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) {

7
src/librustc_back/svh.rs
View file

@ -301,18 +301,17 @@ mod svh_visitor {
}
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

3
src/librustc_front/fold.rs
View file

@ -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),

1
src/librustc_front/hir.rs
View file

@ -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>>,
}

1
src/librustc_front/lowering.rs
View file

@ -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),

8
src/librustc_front/util.rs
View file

@ -194,11 +194,6 @@ impl<'a, 'v, O: ast_util::IdVisitingOperation> Visitor<'v> for IdVisitor<'a, O>
}
}
}
ItemEnum(ref enum_definition, _) => {
for variant in &enum_definition.variants {
self.operation.visit_id(variant.node.id)
}
}
_ => {}
}
@ -290,8 +285,7 @@ impl<'a, 'v, O: ast_util::IdVisitingOperation> Visitor<'v> for IdVisitor<'a, O>
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);
}

25
src/librustc_front/visit.rs
View file

@ -118,14 +118,13 @@ pub trait Visitor<'v> : Sized {
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);
}

10
src/librustc_lint/builtin.rs
View file

@ -428,14 +428,14 @@ impl LateLintPass for MissingDoc {
}
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 @@ 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.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;
}

16
src/librustc_privacy/lib.rs
View file

@ -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.id, item.id);
self.parents.insert(variant.node.def.id, item.id);
}
}
@ -129,11 +129,11 @@ impl<'v> Visitor<'v> for ParentVisitor {
}
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 @@ 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.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 @@ impl<'a, 'tcx, 'v> Visitor<'v> for VisiblePrivateTypesVisitor<'a, 'tcx> {
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;
}
}

6
src/librustc_resolve/build_reduced_graph.rs
View file

@ -590,7 +590,7 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> {
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 @@ 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.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);
}

4
src/librustc_resolve/lib.rs
View file

@ -491,7 +491,7 @@ impl<'a, 'v, 'tcx> Visitor<'v> for Resolver<'a, 'tcx> {
}
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 @@ impl<'a, 'v, 'tcx> Visitor<'v> for Resolver<'a, 'tcx> {
}
// `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);

4
src/librustc_trans/save/dump_csv.rs
View file

@ -503,7 +503,7 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> {
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 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> {
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);
}
}

4
src/librustc_trans/trans/inline.rs
View file

@ -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, _) => {

4
src/librustc_typeck/collect.rs
View file

@ -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_def<'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)
}

2
src/librustdoc/clean/mod.rs
View file

@ -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.id),
def_id: cx.map.local_def_id(self.def.id),
inner: VariantItem(Variant {
kind: struct_def_to_variant_kind(&self.def, cx),
}),

1
src/librustdoc/doctree.rs
View file

@ -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,
}

3
src/librustdoc/visit_ast.rs
View file

@ -111,8 +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.id),
id: v.node.id,
stab: self.stability(v.node.def.id),
def: v.node.def.clone(),
whence: v.span,
}).collect(),

1
src/libsyntax/ast.rs
View file

@ -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>>,
}

8
src/libsyntax/ast_util.rs
View file

@ -360,11 +360,6 @@ impl<'a, 'v, O: IdVisitingOperation> Visitor<'v> for IdVisitor<'a, O> {
}
}
}
ItemEnum(ref enum_definition, _) => {
for variant in &enum_definition.variants {
self.operation.visit_id(variant.node.id)
}
}
_ => {}
}
@ -461,8 +456,7 @@ impl<'a, 'v, O: IdVisitingOperation> Visitor<'v> for IdVisitor<'a, O> {
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);
}

3
src/libsyntax/config.rs
View file

@ -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),

1
src/libsyntax/ext/build.rs
View file

@ -1011,7 +1011,6 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
def: P(ast::StructDef { fields: fields,
id: ast::DUMMY_NODE_ID,
kind: kind }),
id: ast::DUMMY_NODE_ID,
disr_expr: None,
})
}

3
src/libsyntax/fold.rs
View file

@ -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),

1
src/libsyntax/parse/parser.rs
View file

@ -5176,7 +5176,6 @@ impl<'a> Parser<'a> {
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)));

1
src/libsyntax/print/pprust.rs
View file

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

27
src/libsyntax/visit.rs
View file

@ -85,12 +85,12 @@ pub trait Visitor<'v> : Sized {
}
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);
}