// except according to those terms.
use hir::map::definitions::*;
-use hir::def_id::{CRATE_DEF_INDEX, DefIndex};
+use hir::def_id::{CRATE_DEF_INDEX, DefIndex, DefIndexAddressSpace};
use syntax::ast::*;
use syntax::ext::hygiene::Mark;
use syntax::visit;
use syntax::symbol::{Symbol, keywords};
+use hir::map::{ITEM_LIKE_SPACE, REGULAR_SPACE};
+
/// Creates def ids for nodes in the AST.
pub struct DefCollector<'a> {
definitions: &'a mut Definitions,
}
}
- pub fn collect_root(&mut self) {
- let root = self.create_def_with_parent(None, CRATE_NODE_ID, DefPathData::CrateRoot);
+ pub fn collect_root(&mut self, crate_name: &str, crate_disambiguator: &str) {
+ let root = self.definitions.create_root_def(crate_name,
+ crate_disambiguator);
assert_eq!(root, CRATE_DEF_INDEX);
self.parent_def = Some(root);
}
- fn create_def(&mut self, node_id: NodeId, data: DefPathData) -> DefIndex {
- let parent_def = self.parent_def;
+ fn create_def(&mut self,
+ node_id: NodeId,
+ data: DefPathData,
+ address_space: DefIndexAddressSpace)
+ -> DefIndex {
+ let parent_def = self.parent_def.unwrap();
debug!("create_def(node_id={:?}, data={:?}, parent_def={:?})", node_id, data, parent_def);
- self.definitions.create_def_with_parent(parent_def, node_id, data)
- }
-
- fn create_def_with_parent(&mut self,
- parent: Option<DefIndex>,
- node_id: NodeId,
- data: DefPathData)
- -> DefIndex {
- self.definitions.create_def_with_parent(parent, node_id, data)
+ self.definitions.create_def_with_parent(parent_def, node_id, data, address_space)
}
pub fn with_parent<F: FnOnce(&mut Self)>(&mut self, parent_def: DefIndex, f: F) {
_ => {}
}
- self.create_def(expr.id, DefPathData::Initializer);
+ self.create_def(expr.id, DefPathData::Initializer, REGULAR_SPACE);
}
fn visit_macro_invoc(&mut self, id: NodeId, const_expr: bool) {
if let Some(ref mut visit) = self.visit_macro_invoc {
visit(MacroInvocationData {
- mark: Mark::from_placeholder_id(id),
+ mark: id.placeholder_to_mark(),
const_expr: const_expr,
def_index: self.parent_def.unwrap(),
})
ViewPathSimple(..) => {}
ViewPathList(_, ref imports) => {
for import in imports {
- self.create_def(import.node.id, DefPathData::Misc);
+ self.create_def(import.node.id,
+ DefPathData::Misc,
+ ITEM_LIKE_SPACE);
}
}
}
DefPathData::Misc
}
};
- let def = self.create_def(i.id, def_data);
+ let def = self.create_def(i.id, def_data, ITEM_LIKE_SPACE);
self.with_parent(def, |this| {
match i.node {
for v in &enum_definition.variants {
let variant_def_index =
this.create_def(v.node.data.id(),
- DefPathData::EnumVariant(v.node.name.name.as_str()));
+ DefPathData::EnumVariant(v.node.name.name.as_str()),
+ REGULAR_SPACE);
this.with_parent(variant_def_index, |this| {
for (index, field) in v.node.data.fields().iter().enumerate() {
let name = field.ident.map(|ident| ident.name)
.unwrap_or_else(|| Symbol::intern(&index.to_string()));
- this.create_def(field.id, DefPathData::Field(name.as_str()));
+ this.create_def(field.id,
+ DefPathData::Field(name.as_str()),
+ REGULAR_SPACE);
}
if let Some(ref expr) = v.node.disr_expr {
// If this is a tuple-like struct, register the constructor.
if !struct_def.is_struct() {
this.create_def(struct_def.id(),
- DefPathData::StructCtor);
+ DefPathData::StructCtor,
+ REGULAR_SPACE);
}
for (index, field) in struct_def.fields().iter().enumerate() {
let name = field.ident.map(|ident| ident.name.as_str())
.unwrap_or(Symbol::intern(&index.to_string()).as_str());
- this.create_def(field.id, DefPathData::Field(name));
+ this.create_def(field.id, DefPathData::Field(name), REGULAR_SPACE);
}
}
_ => {}
fn visit_foreign_item(&mut self, foreign_item: &'a ForeignItem) {
let def = self.create_def(foreign_item.id,
- DefPathData::ValueNs(foreign_item.ident.name.as_str()));
+ DefPathData::ValueNs(foreign_item.ident.name.as_str()),
+ REGULAR_SPACE);
self.with_parent(def, |this| {
visit::walk_foreign_item(this, foreign_item);
fn visit_generics(&mut self, generics: &'a Generics) {
for ty_param in generics.ty_params.iter() {
- self.create_def(ty_param.id, DefPathData::TypeParam(ty_param.ident.name.as_str()));
+ self.create_def(ty_param.id,
+ DefPathData::TypeParam(ty_param.ident.name.as_str()),
+ REGULAR_SPACE);
}
visit::walk_generics(self, generics);
TraitItemKind::Macro(..) => return self.visit_macro_invoc(ti.id, false),
};
- let def = self.create_def(ti.id, def_data);
+ let def = self.create_def(ti.id, def_data, ITEM_LIKE_SPACE);
self.with_parent(def, |this| {
if let TraitItemKind::Const(_, Some(ref expr)) = ti.node {
this.visit_const_expr(expr);
ImplItemKind::Macro(..) => return self.visit_macro_invoc(ii.id, false),
};
- let def = self.create_def(ii.id, def_data);
+ let def = self.create_def(ii.id, def_data, ITEM_LIKE_SPACE);
self.with_parent(def, |this| {
if let ImplItemKind::Const(_, ref expr) = ii.node {
this.visit_const_expr(expr);
match pat.node {
PatKind::Mac(..) => return self.visit_macro_invoc(pat.id, false),
PatKind::Ident(_, id, _) => {
- let def = self.create_def(pat.id, DefPathData::Binding(id.node.name.as_str()));
+ let def = self.create_def(pat.id,
+ DefPathData::Binding(id.node.name.as_str()),
+ REGULAR_SPACE);
self.parent_def = Some(def);
}
_ => {}
ExprKind::Mac(..) => return self.visit_macro_invoc(expr.id, false),
ExprKind::Repeat(_, ref count) => self.visit_const_expr(count),
ExprKind::Closure(..) => {
- let def = self.create_def(expr.id, DefPathData::ClosureExpr);
+ let def = self.create_def(expr.id,
+ DefPathData::ClosureExpr,
+ REGULAR_SPACE);
self.parent_def = Some(def);
}
_ => {}
TyKind::Mac(..) => return self.visit_macro_invoc(ty.id, false),
TyKind::Array(_, ref length) => self.visit_const_expr(length),
TyKind::ImplTrait(..) => {
- self.create_def(ty.id, DefPathData::ImplTrait);
+ self.create_def(ty.id, DefPathData::ImplTrait, REGULAR_SPACE);
}
TyKind::Typeof(ref expr) => self.visit_const_expr(expr),
_ => {}
}
fn visit_lifetime_def(&mut self, def: &'a LifetimeDef) {
- self.create_def(def.lifetime.id, DefPathData::LifetimeDef(def.lifetime.name.as_str()));
+ self.create_def(def.lifetime.id,
+ DefPathData::LifetimeDef(def.lifetime.name.as_str()),
+ REGULAR_SPACE);
}
fn visit_stmt(&mut self, stmt: &'a Stmt) {