use rustc::util::lev_distance::lev_distance;
use syntax::ast;
-use syntax::ast::{Ident, Name, NodeId, CrateNum, TyIs, TyI8, TyI16, TyI32, TyI64};
+use syntax::ast::{CRATE_NODE_ID, Ident, Name, NodeId, CrateNum, TyIs, TyI8, TyI16, TyI32, TyI64};
use syntax::ast::{TyUs, TyU8, TyU16, TyU32, TyU64, TyF64, TyF32};
use syntax::attr::AttrMetaMethods;
use syntax::ext::mtwt;
}
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
}
// `visit::walk_variant` without the discriminant expression.
- match variant.node.kind {
- hir::TupleVariantKind(ref variant_arguments) => {
- for variant_argument in variant_arguments {
- self.visit_ty(&*variant_argument.ty);
- }
- }
- hir::StructVariantKind(ref struct_definition) => {
- self.visit_struct_def(&**struct_definition,
- variant.node.name,
- generics,
- variant.node.id);
- }
- }
+ self.visit_variant_data(&variant.node.data, variant.node.name,
+ generics, item_id, variant.span);
}
fn visit_foreign_item(&mut self, foreign_item: &hir::ForeignItem) {
execute_callback!(hir_map::Node::NodeForeignItem(foreign_item), self);
make_glob_map: MakeGlobMap) -> Resolver<'a, 'tcx> {
let graph_root = NameBindings::new();
+ let root_def_id = ast_map.local_def_id(CRATE_NODE_ID);
graph_root.define_module(NoParentLink,
- Some(DefId { krate: 0, node: 0 }),
+ Some(root_def_id),
NormalModuleKind,
false,
true,
}
fn get_trait_name(&self, did: DefId) -> Name {
- if did.is_local() {
- self.ast_map.expect_item(did.node).name
+ if let Some(node_id) = self.ast_map.as_local_node_id(did) {
+ self.ast_map.expect_item(node_id).name
} else {
csearch::get_trait_name(&self.session.cstore, did)
}
self.session.span_bug(span,
&format!("unexpected {:?} in bindings", def))
}
- DefLocal(node_id) => {
+ DefLocal(_, node_id) => {
for rib in ribs {
match rib.kind {
NormalRibKind => {
}
ClosureRibKind(function_id) => {
let prev_def = def;
+ let node_def_id = self.ast_map.local_def_id(node_id);
let mut seen = self.freevars_seen.borrow_mut();
let seen = seen.entry(function_id).or_insert_with(|| NodeMap());
if let Some(&index) = seen.get(&node_id) {
- def = DefUpvar(node_id, index, function_id);
+ def = DefUpvar(node_def_id, node_id, index, function_id);
continue;
}
let mut freevars = self.freevars.borrow_mut();
let depth = vec.len();
vec.push(Freevar { def: prev_def, span: span });
- def = DefUpvar(node_id, depth, function_id);
+ def = DefUpvar(node_def_id, node_id, depth, function_id);
seen.insert(node_id, depth);
}
ItemRibKind | MethodRibKind => {
TypeSpace,
ItemRibKind),
|this| {
- this.with_self_rib(DefSelfTy(Some(DefId::local(item.id)), None), |this| {
+ let local_def_id = this.ast_map.local_def_id(item.id);
+ this.with_self_rib(DefSelfTy(Some(local_def_id), None), |this| {
this.visit_generics(generics);
- visit::walk_ty_param_bounds_helper(this, bounds);
+ walk_list!(this, visit_ty_param_bound, bounds);
for trait_item in trait_items {
match trait_item.node {
function_type_rib.bindings.insert(name,
DlDef(DefTyParam(space,
index as u32,
- DefId::local(type_parameter.id),
+ self.ast_map.local_def_id(type_parameter.id),
name)));
}
self.type_ribs.push(function_type_rib);
fn resolve_local(&mut self, local: &Local) {
// Resolve the type.
- visit::walk_ty_opt(self, &local.ty);
+ walk_list!(self, visit_ty, &local.ty);
// Resolve the initializer.
- visit::walk_expr_opt(self, &local.init);
+ walk_list!(self, visit_expr, &local.init);
// Resolve the pattern.
self.resolve_pattern(&*local.pat,
// pat_idents are variants
self.check_consistent_bindings(arm);
- visit::walk_expr_opt(self, &arm.guard);
+ walk_list!(self, visit_expr, &arm.guard);
self.visit_expr(&*arm.body);
if !self.resolved {
debug!("(resolving pattern) binding `{}`",
renamed);
- let def = DefLocal(pattern.id);
+ let def_id = self.ast_map.local_def_id(pattern.id);
+ let def = DefLocal(def_id, pattern.id);
// Record the definition so that later passes
// will be able to distinguish variants from
}
fn is_static_method(this: &Resolver, did: DefId) -> bool {
- if did.is_local() {
- let sig = match this.ast_map.get(did.node) {
+ if let Some(node_id) = this.ast_map.as_local_node_id(did) {
+ let sig = match this.ast_map.get(node_id) {
hir_map::NodeTraitItem(trait_item) => match trait_item.node {
hir::MethodTraitItem(ref sig, _) => sig,
_ => return false
false // Stop advancing
});
- if method_scope && special_names::self_ == path_name {
+ if method_scope && special_names::self_.as_str() == &path_name[..] {
resolve_error(
self,
expr.span,
fn add_trait_info(found_traits: &mut Vec<DefId>,
trait_def_id: DefId,
name: Name) {
- debug!("(adding trait info) found trait {}:{} for method '{}'",
- trait_def_id.krate,
- trait_def_id.node,
+ debug!("(adding trait info) found trait {:?} for method '{}'",
+ trait_def_id,
name);
found_traits.push(trait_def_id);
}