use middle::def_id::DefId;
use syntax::abi;
-use syntax::ast::{Name, NodeId, Ident, CRATE_NODE_ID, DUMMY_NODE_ID};
+use syntax::ast::{self, Name, NodeId, CRATE_NODE_ID, DUMMY_NODE_ID};
use syntax::codemap::{Span, Spanned};
use syntax::parse::token;
NodeItem(item) => {
match item.node {
ItemMod(_) | ItemForeignMod(_) => {
- PathMod(item.ident.name)
+ PathMod(item.name)
}
- _ => PathName(item.ident.name)
+ _ => PathName(item.name)
}
}
- NodeForeignItem(i) => PathName(i.ident.name),
- NodeImplItem(ii) => PathName(ii.ident.name),
- NodeTraitItem(ti) => PathName(ti.ident.name),
- NodeVariant(v) => PathName(v.node.name.name),
+ NodeForeignItem(i) => PathName(i.name),
+ NodeImplItem(ii) => PathName(ii.name),
+ NodeTraitItem(ti) => PathName(ti.name),
+ NodeVariant(v) => PathName(v.node.name),
NodeLifetime(lt) => PathName(lt.name),
_ => panic!("no path elem for {:?}", node)
}
self.with_path(id, |path| path_to_string(path))
}
- fn path_to_str_with_ident(&self, id: NodeId, i: Ident) -> String {
+ fn path_to_str_with_name(&self, id: NodeId, name: Name) -> String {
self.with_path(id, |path| {
- path_to_string(path.chain(Some(PathName(i.name))))
+ path_to_string(path.chain(Some(PathName(name))))
})
}
/// Given a node ID, get a list of of attributes associated with the AST
/// corresponding to the Node ID
- pub fn attrs(&self, id: NodeId) -> &'ast [Attribute] {
+ pub fn attrs(&self, id: NodeId) -> &'ast [ast::Attribute] {
let attrs = match self.find(id) {
Some(NodeItem(i)) => Some(&i.attrs[..]),
Some(NodeForeignItem(fi)) => Some(&fi.attrs[..]),
match map.find(id) {
None => return None,
Some(NodeItem(item)) if item_is_mod(&*item) =>
- return Some((id, item.ident.name)),
+ return Some((id, item.name)),
_ => {}
}
let parent = map.get_parent(id);
impl<T:Named> Named for Spanned<T> { fn name(&self) -> Name { self.node.name() } }
-impl Named for Item { fn name(&self) -> Name { self.ident.name } }
-impl Named for ForeignItem { fn name(&self) -> Name { self.ident.name } }
-impl Named for Variant_ { fn name(&self) -> Name { self.name.name } }
-impl Named for TraitItem { fn name(&self) -> Name { self.ident.name } }
-impl Named for ImplItem { fn name(&self) -> Name { self.ident.name } }
+impl Named for Item { fn name(&self) -> Name { self.name } }
+impl Named for ForeignItem { fn name(&self) -> Name { self.name } }
+impl Named for Variant_ { fn name(&self) -> Name { self.name } }
+impl Named for TraitItem { fn name(&self) -> Name { self.name } }
+impl Named for ImplItem { fn name(&self) -> Name { self.name } }
pub trait FoldOps {
fn new_id(&self, id: NodeId) -> NodeId {
self.parent_node = parent_node;
}
- fn visit_lifetime_ref(&mut self, lifetime: &'ast Lifetime) {
+ fn visit_lifetime(&mut self, lifetime: &'ast Lifetime) {
self.insert(lifetime.id, NodeLifetime(lifetime));
}
fn visit_lifetime_def(&mut self, def: &'ast LifetimeDef) {
- self.visit_lifetime_ref(&def.lifetime);
+ self.visit_lifetime(&def.lifetime);
}
}
match map.find(id) {
Some(NodeItem(item)) => {
- let path_str = map.path_to_str_with_ident(id, item.ident);
+ let path_str = map.path_to_str_with_name(id, item.name);
let item_str = match item.node {
ItemExternCrate(..) => "extern crate",
ItemUse(..) => "use",
format!("{} {}{}", item_str, path_str, id_str)
}
Some(NodeForeignItem(item)) => {
- let path_str = map.path_to_str_with_ident(id, item.ident);
+ let path_str = map.path_to_str_with_name(id, item.name);
format!("foreign item {}{}", path_str, id_str)
}
Some(NodeImplItem(ii)) => {
match ii.node {
ConstImplItem(..) => {
format!("assoc const {} in {}{}",
- ii.ident,
+ ii.name,
map.path_to_string(id),
id_str)
}
MethodImplItem(..) => {
format!("method {} in {}{}",
- ii.ident,
+ ii.name,
map.path_to_string(id), id_str)
}
TypeImplItem(_) => {
format!("assoc type {} in {}{}",
- ii.ident,
+ ii.name,
map.path_to_string(id),
id_str)
}
format!("{} {} in {}{}",
kind,
- ti.ident,
+ ti.name,
map.path_to_string(id),
id_str)
}