use syntax::attr::AttrMetaMethods;
use syntax::parse::token::InternedString;
use syntax::util::small_vector::SmallVector;
-use rustc_front::visit;
+use rustc_front::intravisit::Visitor;
use rustc_front::hir;
use log;
foreign_item_map: FnvHashMap<String, Vec<ast::NodeId>>,
}
-impl<'a, 'b, 'v> visit::Visitor<'v> for LocalCrateReader<'a, 'b> {
- fn visit_item(&mut self, a: &hir::Item) {
+impl<'a, 'b, 'hir> Visitor<'hir> for LocalCrateReader<'a, 'b> {
+ fn visit_item(&mut self, a: &'hir hir::Item) {
self.process_item(a);
- visit::walk_item(self, a);
}
}
// etc.
pub fn read_crates(&mut self, krate: &hir::Crate) {
self.process_crate(krate);
- visit::walk_crate(self, krate);
+ krate.visit_all_items(self);
self.creader.inject_allocator_crate();
if log_enabled!(log::INFO) {
use rbml::writer::Encoder;
use rustc_front::hir;
-use rustc_front::visit::Visitor;
-use rustc_front::visit;
+use rustc_front::intravisit::Visitor;
+use rustc_front::intravisit;
use front::map::{LinkedPath, PathElem, PathElems};
use front::map as ast_map;
debug!("(encoding info for module) encoding info for module ID {}", id);
// Encode info about all the module children.
- for item in &md.items {
+ for item_id in &md.item_ids {
rbml_w.wr_tagged_u64(tag_mod_child,
- def_to_u64(ecx.tcx.map.local_def_id(item.id)));
+ def_to_u64(ecx.tcx.map.local_def_id(item_id.id)));
- each_auxiliary_node_id(&**item, |auxiliary_node_id| {
+ let item = ecx.tcx.map.expect_item(item_id.id);
+ each_auxiliary_node_id(item, |auxiliary_node_id| {
rbml_w.wr_tagged_u64(tag_mod_child,
def_to_u64(ecx.tcx.map.local_def_id(auxiliary_node_id)));
true
index: &'a mut CrateIndex<'tcx>,
}
-impl<'a, 'b, 'c, 'tcx, 'v> Visitor<'v> for EncodeVisitor<'a, 'b, 'c, 'tcx> {
- fn visit_expr(&mut self, ex: &hir::Expr) {
- visit::walk_expr(self, ex);
+impl<'a, 'b, 'c, 'tcx> Visitor<'tcx> for EncodeVisitor<'a, 'b, 'c, 'tcx> {
+ fn visit_expr(&mut self, ex: &'tcx hir::Expr) {
+ intravisit::walk_expr(self, ex);
my_visit_expr(ex, self.rbml_w_for_visit_item, self.ecx, self.index);
}
- fn visit_item(&mut self, i: &hir::Item) {
- visit::walk_item(self, i);
+ fn visit_item(&mut self, i: &'tcx hir::Item) {
+ intravisit::walk_item(self, i);
my_visit_item(i, self.rbml_w_for_visit_item, self.ecx, self.index);
}
- fn visit_foreign_item(&mut self, ni: &hir::ForeignItem) {
- visit::walk_foreign_item(self, ni);
+ fn visit_foreign_item(&mut self, ni: &'tcx hir::ForeignItem) {
+ intravisit::walk_foreign_item(self, ni);
my_visit_foreign_item(ni, self.rbml_w_for_visit_item, self.ecx, self.index);
}
}
fn encode_info_for_items<'a, 'tcx>(ecx: &EncodeContext<'a, 'tcx>,
- rbml_w: &mut Encoder,
- krate: &hir::Crate)
+ rbml_w: &mut Encoder)
-> CrateIndex<'tcx> {
+ let krate = ecx.tcx.map.krate();
+
let mut index = CrateIndex {
items: IndexData::new(ecx.tcx.map.num_local_def_ids()),
xrefs: FnvHashMap()
syntax::parse::token::intern(&ecx.link_meta.crate_name),
hir::Public);
- visit::walk_crate(&mut EncodeVisitor {
+ krate.visit_all_items(&mut EncodeVisitor {
index: &mut index,
ecx: ecx,
rbml_w_for_visit_item: &mut *rbml_w,
- }, krate);
+ });
rbml_w.end_tag();
index
}
rbml_w.start_tag(tag_struct_fields);
- visit::walk_crate(&mut StructFieldVisitor { ecx: ecx, rbml_w: rbml_w }, krate);
+ krate.visit_all_items(&mut StructFieldVisitor { ecx: ecx, rbml_w: rbml_w });
rbml_w.end_tag();
}
.push(impl_id);
}
}
- visit::walk_item(self, item);
}
}
tcx: ecx.tcx,
impls: FnvHashMap()
};
- visit::walk_crate(&mut visitor, krate);
+ krate.visit_all_items(&mut visitor);
rbml_w.start_tag(tag_impls);
for (trait_, trait_impls) in visitor.impls {
rbml_w: &mut Encoder) {
rbml_w.start_tag(tag_misc_info);
rbml_w.start_tag(tag_misc_info_crate_items);
- for item in &krate.module.items {
+ for item_id in &krate.module.item_ids {
rbml_w.wr_tagged_u64(tag_mod_child,
- def_to_u64(ecx.tcx.map.local_def_id(item.id)));
+ def_to_u64(ecx.tcx.map.local_def_id(item_id.id)));
- each_auxiliary_node_id(&**item, |auxiliary_node_id| {
+ let item = ecx.tcx.map.expect_item(item_id.id);
+ each_auxiliary_node_id(item, |auxiliary_node_id| {
rbml_w.wr_tagged_u64(tag_mod_child,
def_to_u64(ecx.tcx.map.local_def_id(auxiliary_node_id)));
true
// Encode and index the items.
rbml_w.start_tag(tag_items);
i = rbml_w.writer.seek(SeekFrom::Current(0)).unwrap();
- let index = encode_info_for_items(&ecx, &mut rbml_w, krate);
+ let index = encode_info_for_items(&ecx, &mut rbml_w);
stats.item_bytes = rbml_w.writer.seek(SeekFrom::Current(0)).unwrap() - i;
rbml_w.end_tag();
use rustc_front::util::IdVisitor;
use syntax::ast_util::{IdRange, IdRangeComputingVisitor, IdVisitingOperation};
use syntax::ptr::P;
-use rustc_front::visit::Visitor;
+use rustc_front::intravisit::Visitor;
use self::InlinedItem::*;
/// The data we save and restore about an inlined item or method. This is not
match ii {
// HACK we're not dropping items.
InlinedItemRef::Item(i) => {
- InlinedItem::Item(fold::noop_fold_item(P(i.clone()), &mut fld))
+ InlinedItem::Item(P(fold::noop_fold_item(i.clone(), &mut fld)))
}
InlinedItemRef::TraitItem(d, ti) => {
InlinedItem::TraitItem(d, fold::noop_fold_trait_item(P(ti.clone()), &mut fld))
use syntax::ast;
use syntax::codemap::Span;
use syntax::feature_gate::UnstableFeatures;
-use rustc_front::visit::{self, FnKind, Visitor};
+use rustc_front::intravisit::{self, FnKind, Visitor};
use std::collections::hash_map::Entry;
use std::cmp::Ordering;
}
}
-#[derive(Copy, Clone, Eq, PartialEq)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
enum Mode {
Const,
ConstFn,
let qualif = self.with_mode(mode, |this| {
this.with_euv(Some(fn_id), |euv| euv.walk_fn(fd, b));
- visit::walk_fn(this, fk, fd, b, s);
+ intravisit::walk_fn(this, fk, fd, b, s);
this.qualif
});
impl<'a, 'tcx, 'v> Visitor<'v> for CheckCrateVisitor<'a, 'tcx> {
fn visit_item(&mut self, i: &hir::Item) {
debug!("visit_item(item={})", self.tcx.map.node_to_string(i.id));
+ assert_eq!(self.mode, Mode::Var);
match i.node {
hir::ItemStatic(_, hir::MutImmutable, ref expr) => {
self.check_static_type(&**expr);
}
}
_ => {
- self.with_mode(Mode::Var, |v| visit::walk_item(v, i));
+ intravisit::walk_item(self, i);
}
}
}
if let Some(ref expr) = *default {
self.global_expr(Mode::Const, &*expr);
} else {
- visit::walk_trait_item(self, t);
+ intravisit::walk_trait_item(self, t);
}
}
- _ => self.with_mode(Mode::Var, |v| visit::walk_trait_item(v, t)),
+ _ => self.with_mode(Mode::Var, |v| intravisit::walk_trait_item(v, t)),
}
}
hir::ImplItemKind::Const(_, ref expr) => {
self.global_expr(Mode::Const, &*expr);
}
- _ => self.with_mode(Mode::Var, |v| visit::walk_impl_item(v, i)),
+ _ => self.with_mode(Mode::Var, |v| intravisit::walk_impl_item(v, i)),
}
}
}
}
}
- _ => visit::walk_pat(self, p)
+ _ => intravisit::walk_pat(self, p)
}
}
tail expressions", self.msg());
}
}
- visit::walk_block(self, block);
+ intravisit::walk_block(self, block);
}
fn visit_expr(&mut self, ex: &hir::Expr) {
if let Some(mutbl) = borrow {
self.record_borrow(discr.id, mutbl);
}
- visit::walk_expr(self, ex);
+ intravisit::walk_expr(self, ex);
}
// Division by zero and overflow checking.
hir::ExprBinary(op, _, _) => {
- visit::walk_expr(self, ex);
+ intravisit::walk_expr(self, ex);
let div_or_rem = op.node == hir::BiDiv || op.node == hir::BiRem;
match node_ty.sty {
ty::TyUint(_) | ty::TyInt(_) if div_or_rem => {
_ => {}
}
}
- _ => visit::walk_expr(self, ex)
+ _ => intravisit::walk_expr(self, ex)
}
// Handle borrows on (or inside the autorefs of) this expression.
}
pub fn check_crate(tcx: &ty::ctxt) {
- visit::walk_crate(&mut CheckCrateVisitor {
+ tcx.map.krate().visit_all_items(&mut CheckCrateVisitor {
tcx: tcx,
mode: Mode::Var,
qualif: ConstQualif::NOT_CONST,
rvalue_borrows: NodeMap()
- }, tcx.map.krate());
+ });
tcx.sess.abort_if_errors();
}
use session::Session;
use syntax::codemap::Span;
-use rustc_front::visit::Visitor;
-use rustc_front::visit;
+use rustc_front::intravisit::{self, Visitor};
use rustc_front::hir;
#[derive(Clone, Copy, PartialEq)]
}
pub fn check_crate(sess: &Session, krate: &hir::Crate) {
- visit::walk_crate(&mut CheckLoopVisitor { sess: sess, cx: Normal }, krate)
+ krate.visit_all_items(&mut CheckLoopVisitor { sess: sess, cx: Normal });
}
impl<'a, 'v> Visitor<'v> for CheckLoopVisitor<'a> {
fn visit_item(&mut self, i: &hir::Item) {
- self.with_context(Normal, |v| visit::walk_item(v, i));
+ self.with_context(Normal, |v| intravisit::walk_item(v, i));
}
fn visit_expr(&mut self, e: &hir::Expr) {
}
hir::ExprBreak(_) => self.require_loop("break", e.span),
hir::ExprAgain(_) => self.require_loop("continue", e.span),
- _ => visit::walk_expr(self, e)
+ _ => intravisit::walk_expr(self, e)
}
}
}
use rustc_front::hir;
use rustc_front::hir::Pat;
-use rustc_front::visit::{self, Visitor, FnKind};
+use rustc_front::intravisit::{self, Visitor, FnKind};
use rustc_front::util as front_util;
use rustc_back::slice;
}
pub fn check_crate(tcx: &ty::ctxt) {
- visit::walk_crate(&mut MatchCheckCtxt {
+ tcx.map.krate().visit_all_items(&mut MatchCheckCtxt {
tcx: tcx,
param_env: tcx.empty_parameter_environment(),
- }, tcx.map.krate());
+ });
tcx.sess.abort_if_errors();
}
fn check_expr(cx: &mut MatchCheckCtxt, ex: &hir::Expr) {
- visit::walk_expr(cx, ex);
+ intravisit::walk_expr(cx, ex);
match ex.node {
hir::ExprMatch(ref scrut, ref arms, source) => {
for arm in arms {
}
fn check_local(cx: &mut MatchCheckCtxt, loc: &hir::Local) {
- visit::walk_local(cx, loc);
+ intravisit::walk_local(cx, loc);
let pat = StaticInliner::new(cx.tcx, None).fold_pat(loc.pat.clone());
check_irrefutable(cx, &pat, false);
_ => cx.param_env = ParameterEnvironment::for_item(cx.tcx, fn_id),
}
- visit::walk_fn(cx, kind, decl, body, sp);
+ intravisit::walk_fn(cx, kind, decl, body, sp);
for input in &decl.inputs {
check_irrefutable(cx, &input.pat, true);
hir::PatIdent(_, _, Some(_)) => {
let bindings_were_allowed = self.bindings_allowed;
self.bindings_allowed = false;
- visit::walk_pat(self, pat);
+ intravisit::walk_pat(self, pat);
self.bindings_allowed = bindings_were_allowed;
}
- _ => visit::walk_pat(self, pat),
+ _ => intravisit::walk_pat(self, pat),
}
}
}
use syntax::ast;
use rustc_front::hir;
use syntax::codemap::Span;
-use rustc_front::visit;
+use rustc_front::intravisit;
pub fn check_crate(tcx: &ty::ctxt,
krate: &hir::Crate) {
let mut rvcx = RvalueContext { tcx: tcx };
- visit::walk_crate(&mut rvcx, krate);
+ krate.visit_all_items(&mut rvcx);
}
struct RvalueContext<'a, 'tcx: 'a> {
tcx: &'a ty::ctxt<'tcx>,
}
-impl<'a, 'tcx, 'v> visit::Visitor<'v> for RvalueContext<'a, 'tcx> {
+impl<'a, 'tcx, 'v> intravisit::Visitor<'v> for RvalueContext<'a, 'tcx> {
fn visit_fn(&mut self,
- fk: visit::FnKind<'v>,
+ fk: intravisit::FnKind<'v>,
fd: &'v hir::FnDecl,
b: &'v hir::Block,
s: Span,
let mut euv = euv::ExprUseVisitor::new(&mut delegate, &infcx);
euv.walk_fn(fd, b);
}
- visit::walk_fn(self, fk, fd, b, s)
+ intravisit::walk_fn(self, fk, fd, b, s)
}
}
use syntax::{ast};
use syntax::codemap::Span;
use syntax::feature_gate::{GateIssue, emit_feature_err};
-use rustc_front::visit::Visitor;
-use rustc_front::visit;
+use rustc_front::intravisit::{self, Visitor};
use rustc_front::hir;
use std::cell::RefCell;
}
_ => {}
}
- visit::walk_item(self, it)
+ intravisit::walk_item(self, it)
}
fn visit_trait_item(&mut self, ti: &'ast hir::TraitItem) {
}
_ => {}
}
- visit::walk_trait_item(self, ti)
+ intravisit::walk_trait_item(self, ti)
}
fn visit_impl_item(&mut self, ii: &'ast hir::ImplItem) {
}
_ => {}
}
- visit::walk_impl_item(self, ii)
+ intravisit::walk_impl_item(self, ii)
}
}
ast_map: ast_map,
discriminant_map: RefCell::new(NodeMap()),
};
- visit::walk_crate(&mut visitor, krate);
+ krate.visit_all_items(&mut visitor);
sess.abort_if_errors();
}
impl<'a, 'ast: 'a> Visitor<'ast> for CheckItemRecursionVisitor<'a, 'ast> {
fn visit_item(&mut self, it: &'ast hir::Item) {
- self.with_item_id_pushed(it.id, |v| visit::walk_item(v, it));
+ self.with_item_id_pushed(it.id, |v| intravisit::walk_item(v, it));
}
fn visit_enum_def(&mut self, enum_definition: &'ast hir::EnumDef,
generics: &'ast hir::Generics, item_id: ast::NodeId, _: Span) {
self.populate_enum_discriminants(enum_definition);
- visit::walk_enum_def(self, enum_definition, generics, item_id);
+ intravisit::walk_enum_def(self, enum_definition, generics, item_id);
}
fn visit_variant(&mut self, variant: &'ast hir::Variant,
// If `maybe_expr` is `None`, that's because no discriminant is
// specified that affects this variant. Thus, no risk of recursion.
if let Some(expr) = maybe_expr {
- self.with_item_id_pushed(expr.id, |v| visit::walk_expr(v, expr));
+ self.with_item_id_pushed(expr.id, |v| intravisit::walk_expr(v, expr));
}
}
fn visit_trait_item(&mut self, ti: &'ast hir::TraitItem) {
- self.with_item_id_pushed(ti.id, |v| visit::walk_trait_item(v, ti));
+ self.with_item_id_pushed(ti.id, |v| intravisit::walk_trait_item(v, ti));
}
fn visit_impl_item(&mut self, ii: &'ast hir::ImplItem) {
- self.with_item_id_pushed(ii.id, |v| visit::walk_impl_item(v, ii));
+ self.with_item_id_pushed(ii.id, |v| intravisit::walk_impl_item(v, ii));
}
fn visit_expr(&mut self, e: &'ast hir::Expr) {
},
_ => ()
}
- visit::walk_expr(self, e);
+ intravisit::walk_expr(self, e);
}
}
use syntax::{ast, abi};
use rustc_front::hir::Expr;
use rustc_front::hir;
-use rustc_front::visit::FnKind;
+use rustc_front::intravisit::FnKind;
use syntax::codemap::Span;
use syntax::parse::token::InternedString;
use syntax::ptr::P;
use syntax::print::pprust::PrintState;
use util::nodemap::NodeMap;
use rustc_front::hir;
-use rustc_front::visit;
+use rustc_front::intravisit;
use rustc_front::print::pprust;
index: &'a mut NodeMap<Vec<CFGIndex>>,
}
let mut formals = Formals { entry: entry, index: index };
- visit::walk_fn_decl(&mut formals, decl);
- impl<'a, 'v> visit::Visitor<'v> for Formals<'a> {
+ intravisit::walk_fn_decl(&mut formals, decl);
+ impl<'a, 'v> intravisit::Visitor<'v> for Formals<'a> {
fn visit_pat(&mut self, p: &hir::Pat) {
self.index.entry(p.id).or_insert(vec![]).push(self.entry);
- visit::walk_pat(self, p)
+ intravisit::walk_pat(self, p)
}
}
}
fn pretty_print_to<'b>(&self, wr: Box<io::Write + 'b>,
blk: &hir::Block) -> io::Result<()> {
- let mut ps = pprust::rust_printer_annotated(wr, self);
+ let mut ps = pprust::rust_printer_annotated(wr, self, None);
try!(ps.cbox(pprust::indent_unit));
try!(ps.ibox(0));
try!(ps.print_block(blk));
use syntax::ast;
use syntax::codemap::Span;
use rustc_front::hir;
-use rustc_front::visit;
-use rustc_front::visit::{FnKind, Visitor};
+use rustc_front::intravisit;
+use rustc_front::intravisit::{FnKind, Visitor};
#[derive(Copy, Clone)]
struct UnsafeContext {
self.unsafe_context = UnsafeContext::new(SafeContext)
}
- visit::walk_fn(self, fn_kind, fn_decl, block, span);
+ intravisit::walk_fn(self, fn_kind, fn_decl, block, span);
self.unsafe_context = old_unsafe_context
}
hir::DefaultBlock | hir::PushUnstableBlock | hir:: PopUnstableBlock => {}
}
- visit::walk_block(self, block);
+ intravisit::walk_block(self, block);
self.unsafe_context = old_unsafe_context
}
_ => {}
}
- visit::walk_expr(self, expr);
+ intravisit::walk_expr(self, expr);
}
}
unsafe_context: UnsafeContext::new(SafeContext),
};
- visit::walk_crate(&mut visitor, tcx.map.krate());
+ tcx.map.krate().visit_all_items(&mut visitor);
}
use syntax::abi::RustIntrinsic;
use syntax::ast;
use syntax::codemap::Span;
-use rustc_front::visit::{self, Visitor, FnKind};
+use rustc_front::intravisit::{self, Visitor, FnKind};
use rustc_front::hir;
pub fn check_crate(tcx: &ctxt) {
dummy_sized_ty: tcx.types.isize,
dummy_unsized_ty: tcx.mk_slice(tcx.types.isize),
};
- visit::walk_crate(&mut visitor, tcx.map.krate());
+ tcx.map.krate().visit_all_items(&mut visitor);
}
struct IntrinsicCheckingVisitor<'a, 'tcx: 'a> {
FnKind::ItemFn(..) | FnKind::Method(..) => {
let param_env = ty::ParameterEnvironment::for_item(self.tcx, id);
self.param_envs.push(param_env);
- visit::walk_fn(self, fk, fd, b, s);
+ intravisit::walk_fn(self, fk, fd, b, s);
self.param_envs.pop();
}
FnKind::Closure(..) => {
- visit::walk_fn(self, fk, fd, b, s);
+ intravisit::walk_fn(self, fk, fd, b, s);
}
}
}
}
- visit::walk_expr(self, expr);
+ intravisit::walk_expr(self, expr);
}
}
use syntax::attr::AttrMetaMethods;
use syntax::codemap::{DUMMY_SP, Span};
use syntax::parse::token::InternedString;
-use rustc_front::visit::Visitor;
-use rustc_front::visit;
+use rustc_front::intravisit::Visitor;
use rustc_front::hir;
use std::iter::Enumerate;
self.collect_item(item_index, self.ast_map.local_def_id(item.id), item.span)
}
}
-
- visit::walk_item(self, item);
}
}
}
pub fn collect_local_language_items(&mut self, krate: &hir::Crate) {
- visit::walk_crate(self, krate);
+ krate.visit_all_items(self);
}
pub fn collect_external_language_items(&mut self) {
use rustc_front::hir::Expr;
use rustc_front::hir;
use rustc_front::print::pprust::{expr_to_string, block_to_string};
-use rustc_front::visit::{self, Visitor, FnKind};
+use rustc_front::intravisit::{self, Visitor, FnKind};
/// For use with `propagate_through_loop`.
enum LoopKind<'a> {
}
pub fn check_crate(tcx: &ty::ctxt) {
- visit::walk_crate(&mut IrMaps::new(tcx), tcx.map.krate());
+ tcx.map.krate().visit_all_items(&mut IrMaps::new(tcx));
tcx.sess.abort_if_errors();
}
// gather up the various local variables, significant expressions,
// and so forth:
- visit::walk_fn(&mut fn_maps, fk, decl, body, sp);
+ intravisit::walk_fn(&mut fn_maps, fk, decl, body, sp);
// Special nodes and variables:
// - exit_ln represents the end of the fn, either by return or panic
name: name
}));
});
- visit::walk_local(ir, local);
+ intravisit::walk_local(ir, local);
}
fn visit_arm(ir: &mut IrMaps, arm: &hir::Arm) {
}));
})
}
- visit::walk_arm(ir, arm);
+ intravisit::walk_arm(ir, arm);
}
fn visit_expr(ir: &mut IrMaps, expr: &Expr) {
if let DefLocal(..) = def {
ir.add_live_node_for_node(expr.id, ExprNode(expr.span));
}
- visit::walk_expr(ir, expr);
+ intravisit::walk_expr(ir, expr);
}
hir::ExprClosure(..) => {
// Interesting control flow (for loops can contain labeled
});
ir.set_captures(expr.id, call_caps);
- visit::walk_expr(ir, expr);
+ intravisit::walk_expr(ir, expr);
}
// live nodes required for interesting control flow:
hir::ExprIf(..) | hir::ExprMatch(..) | hir::ExprWhile(..) | hir::ExprLoop(..) => {
ir.add_live_node_for_node(expr.id, ExprNode(expr.span));
- visit::walk_expr(ir, expr);
+ intravisit::walk_expr(ir, expr);
}
hir::ExprBinary(op, _, _) if ::rustc_front::util::lazy_binop(op.node) => {
ir.add_live_node_for_node(expr.id, ExprNode(expr.span));
- visit::walk_expr(ir, expr);
+ intravisit::walk_expr(ir, expr);
}
// otherwise, live nodes are not required:
hir::ExprStruct(..) | hir::ExprRepeat(..) |
hir::ExprInlineAsm(..) | hir::ExprBox(..) |
hir::ExprRange(..) => {
- visit::walk_expr(ir, expr);
+ intravisit::walk_expr(ir, expr);
}
}
}
}
}
- visit::walk_local(this, local);
+ intravisit::walk_local(this, local);
}
fn check_arm(this: &mut Liveness, arm: &hir::Arm) {
this.arm_pats_bindings(arm.pats.first().map(|p| &**p), |this, ln, var, sp, id| {
this.warn_about_unused(sp, id, ln, var);
});
- visit::walk_arm(this, arm);
+ intravisit::walk_arm(this, arm);
}
fn check_expr(this: &mut Liveness, expr: &Expr) {
hir::ExprAssign(ref l, _) => {
this.check_lvalue(&**l);
- visit::walk_expr(this, expr);
+ intravisit::walk_expr(this, expr);
}
hir::ExprAssignOp(_, ref l, _) => {
this.check_lvalue(&**l);
- visit::walk_expr(this, expr);
+ intravisit::walk_expr(this, expr);
}
hir::ExprInlineAsm(ref ia) => {
this.visit_expr(&**out);
}
- visit::walk_expr(this, expr);
+ intravisit::walk_expr(this, expr);
}
// no correctness conditions related to liveness
hir::ExprStruct(..) | hir::ExprRepeat(..) |
hir::ExprClosure(..) | hir::ExprPath(..) | hir::ExprBox(..) |
hir::ExprRange(..) => {
- visit::walk_expr(this, expr);
+ intravisit::walk_expr(this, expr);
}
}
}
_ => {
// For other kinds of lvalues, no checks are required,
// and any embedded expressions are actually rvalues
- visit::walk_expr(self, expr);
+ intravisit::walk_expr(self, expr);
}
}
}
use syntax::ast;
use syntax::attr;
use rustc_front::hir;
-use rustc_front::visit::Visitor;
-use rustc_front::visit;
+use rustc_front::intravisit::Visitor;
+use rustc_front::intravisit;
// Returns true if the given set of generics implies that the item it's
// associated with must be inlined.
}
impl<'a, 'tcx, 'v> Visitor<'v> for ReachableContext<'a, 'tcx> {
-
fn visit_expr(&mut self, expr: &hir::Expr) {
-
match expr.node {
hir::ExprPath(..) => {
let def = match self.tcx.def_map.borrow().get(&expr.id) {
_ => {}
}
- visit::walk_expr(self, expr)
- }
-
- fn visit_item(&mut self, _item: &hir::Item) {
- // Do not recurse into items. These items will be added to the worklist
- // and recursed into manually if necessary.
+ intravisit::walk_expr(self, expr)
}
}
match item.node {
hir::ItemFn(_, _, _, _, _, ref search_block) => {
if item_might_be_inlined(&*item) {
- visit::walk_block(self, &**search_block)
+ intravisit::walk_block(self, &**search_block)
}
}
self.visit_expr(&*expr);
}
hir::MethodTraitItem(_, Some(ref body)) => {
- visit::walk_block(self, body);
+ intravisit::walk_block(self, body);
}
hir::TypeTraitItem(..) => {}
}
hir::ImplItemKind::Method(ref sig, ref body) => {
let did = self.tcx.map.get_parent_did(search_item);
if method_might_be_inlined(self.tcx, sig, impl_item, did) {
- visit::walk_block(self, body)
+ intravisit::walk_block(self, body)
}
}
hir::ImplItemKind::Type(_) => {}
}
}
}
-
- visit::walk_item(self, item);
}
}
exported_items: exported_items,
worklist: &mut reachable_context.worklist,
};
-
- visit::walk_crate(&mut collect_private_impl_items, tcx.map.krate());
+ tcx.map.krate().visit_all_items(&mut collect_private_impl_items);
}
// Step 2: Mark all symbols that the symbols on the worklist touch.
use syntax::ast::{self, NodeId};
use rustc_front::hir;
-use rustc_front::visit::{self, Visitor, FnKind};
+use rustc_front::intravisit::{self, Visitor, FnKind};
use rustc_front::hir::{Block, Item, FnDecl, Arm, Pat, Stmt, Expr, Local};
use rustc_front::util::stmt_id;
{
// This block should be kept approximately in sync with
- // `visit::walk_block`. (We manually walk the block, rather
+ // `intravisit::walk_block`. (We manually walk the block, rather
// than call `walk_block`, in order to maintain precise
// index information.)
visitor.terminating_scopes.insert(expr.id);
}
- visit::walk_arm(visitor, arm);
+ intravisit::walk_arm(visitor, arm);
}
fn resolve_pat(visitor: &mut RegionResolutionVisitor, pat: &hir::Pat) {
_ => { }
}
- visit::walk_pat(visitor, pat);
+ intravisit::walk_pat(visitor, pat);
}
fn resolve_stmt(visitor: &mut RegionResolutionVisitor, stmt: &hir::Stmt) {
let prev_parent = visitor.cx.parent;
visitor.cx.parent = stmt_extent;
- visit::walk_stmt(visitor, stmt);
+ intravisit::walk_stmt(visitor, stmt);
visitor.cx.parent = prev_parent;
}
}
}
- visit::walk_expr(visitor, expr);
+ intravisit::walk_expr(visitor, expr);
visitor.cx = prev_cx;
}
None => { }
}
- visit::walk_local(visitor, local);
+ intravisit::walk_local(visitor, local);
/// True if `pat` match the `P&` nonterminal:
///
var_parent: ROOT_CODE_EXTENT,
parent: ROOT_CODE_EXTENT
};
- visit::walk_item(visitor, item);
+ intravisit::walk_item(visitor, item);
visitor.create_item_scope_if_needed(item.id);
visitor.cx = prev_cx;
visitor.terminating_scopes = prev_ts;
var_parent: fn_decl_scope,
};
- visit::walk_fn_decl(visitor, decl);
- visit::walk_fn_kind(visitor, kind);
+ intravisit::walk_fn_decl(visitor, decl);
+ intravisit::walk_fn_kind(visitor, kind);
// The body of the every fn is a root scope.
visitor.cx = Context {
}
fn visit_impl_item(&mut self, ii: &hir::ImplItem) {
- visit::walk_impl_item(self, ii);
+ intravisit::walk_impl_item(self, ii);
self.create_item_scope_if_needed(ii.id);
}
fn visit_trait_item(&mut self, ti: &hir::TraitItem) {
- visit::walk_trait_item(self, ti);
+ intravisit::walk_trait_item(self, ti);
self.create_item_scope_if_needed(ti.id);
}
},
terminating_scopes: NodeSet()
};
- visit::walk_crate(&mut visitor, krate);
+ krate.visit_all_items(&mut visitor);
}
return maps;
}
use rustc_front::hir;
use rustc_front::print::pprust::lifetime_to_string;
-use rustc_front::visit::{self, Visitor, FnKind};
+use rustc_front::intravisit::{self, Visitor, FnKind};
#[derive(Clone, Copy, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable, Debug)]
pub enum DefRegion {
pub fn krate(sess: &Session, krate: &hir::Crate, def_map: &DefMap) -> NamedRegionMap {
let mut named_region_map = NodeMap();
- visit::walk_crate(&mut LifetimeContext {
+ krate.visit_all_items(&mut LifetimeContext {
sess: sess,
named_region_map: &mut named_region_map,
scope: &ROOT_SCOPE,
def_map: def_map,
trait_ref_hack: false,
labels_in_fn: vec![],
- }, krate);
+ });
sess.abort_if_errors();
named_region_map
}
impl<'a, 'v> Visitor<'v> for LifetimeContext<'a> {
fn visit_item(&mut self, item: &hir::Item) {
- // Items save/restore the set of labels. This way inner items
- // can freely reuse names, be they loop labels or lifetimes.
- let saved = replace(&mut self.labels_in_fn, vec![]);
+ assert!(self.labels_in_fn.is_empty());
// Items always introduce a new root scope
self.with(RootScope, |_, this| {
match item.node {
hir::ItemFn(..) => {
// Fn lifetimes get added in visit_fn below:
- visit::walk_item(this, item);
+ intravisit::walk_item(this, item);
}
hir::ItemExternCrate(_) |
hir::ItemUse(_) |
hir::ItemStatic(..) |
hir::ItemConst(..) => {
// These sorts of items have no lifetime parameters at all.
- visit::walk_item(this, item);
+ intravisit::walk_item(this, item);
}
hir::ItemTy(_, ref generics) |
hir::ItemEnum(_, ref generics) |
let early_scope = EarlyScope(subst::TypeSpace, lifetimes, &ROOT_SCOPE);
this.with(early_scope, |old_scope, this| {
this.check_lifetime_defs(old_scope, lifetimes);
- visit::walk_item(this, item);
+ intravisit::walk_item(this, item);
});
}
}
});
- // Done traversing the item; restore saved set of labels.
- replace(&mut self.labels_in_fn, saved);
+ // Done traversing the item; remove any labels it created
+ self.labels_in_fn.truncate(0);
}
fn visit_foreign_item(&mut self, item: &hir::ForeignItem) {
match item.node {
hir::ForeignItemFn(_, ref generics) => {
this.visit_early_late(subst::FnSpace, generics, |this| {
- visit::walk_foreign_item(this, item);
+ intravisit::walk_foreign_item(this, item);
})
}
hir::ForeignItemStatic(..) => {
- visit::walk_foreign_item(this, item);
+ intravisit::walk_foreign_item(this, item);
}
}
});
// a bare fn has no bounds, so everything
// contained within is scoped within its binder.
this.check_lifetime_defs(old_scope, &c.lifetimes);
- visit::walk_ty(this, ty);
+ intravisit::walk_ty(this, ty);
});
}
hir::TyPath(None, ref path) => {
});
}
_ => {
- visit::walk_ty(self, ty);
+ intravisit::walk_ty(self, ty);
}
}
}
_ => {
- visit::walk_ty(self, ty)
+ intravisit::walk_ty(self, ty)
}
}
}
if let hir::MethodTraitItem(ref sig, None) = trait_item.node {
self.visit_early_late(
subst::FnSpace, &sig.generics,
- |this| visit::walk_trait_item(this, trait_item))
+ |this| intravisit::walk_trait_item(this, trait_item))
} else {
- visit::walk_trait_item(self, trait_item);
+ intravisit::walk_trait_item(self, trait_item);
}
replace(&mut self.labels_in_fn, saved);
fn visit_block(&mut self, b: &hir::Block) {
self.with(BlockScope(region::DestructionScopeData::new(b.id),
self.scope),
- |_, this| visit::walk_block(this, b));
+ |_, this| intravisit::walk_block(this, b));
}
fn visit_lifetime(&mut self, lifetime_ref: &hir::Lifetime) {
for lifetime in &trait_ref.bound_lifetimes {
this.visit_lifetime_def(lifetime);
}
- visit::walk_path(this, &trait_ref.trait_ref.path)
+ intravisit::walk_path(this, &trait_ref.trait_ref.path)
})
} else {
self.visit_trait_ref(&trait_ref.trait_ref)
self.labels_in_fn.push((label, ex.span));
}
- visit::walk_expr(self, ex)
+ intravisit::walk_expr(self, ex)
}
fn visit_item(&mut self, _: &hir::Item) {
}
impl<'a> LifetimeContext<'a> {
- // This is just like visit::walk_fn, except that it extracts the
+ // This is just like intravisit::walk_fn, except that it extracts the
// labels of the function body and swaps them in before visiting
// the function body itself.
fn walk_fn<'b>(&mut self,
_span: Span) {
match fk {
FnKind::ItemFn(_, generics, _, _, _, _) => {
- visit::walk_fn_decl(self, fd);
+ intravisit::walk_fn_decl(self, fd);
self.visit_generics(generics);
}
FnKind::Method(_, sig, _) => {
- visit::walk_fn_decl(self, fd);
+ intravisit::walk_fn_decl(self, fd);
self.visit_generics(&sig.generics);
self.visit_explicit_self(&sig.explicit_self);
}
FnKind::Closure(..) => {
- visit::walk_fn_decl(self, fd);
+ intravisit::walk_fn_decl(self, fd);
}
}
use syntax::ast;
use syntax::codemap::Span;
use syntax::parse::token::InternedString;
-use rustc_front::visit::Visitor;
-use rustc_front::visit;
+use rustc_front::intravisit::Visitor;
+use rustc_front::intravisit;
use rustc_front::hir;
use std::collections::HashSet;
{
let mut cx = Context { sess: sess, items: items };
- visit::walk_crate(&mut cx, krate);
+ krate.visit_all_items(&mut cx);
}
verify(sess, items);
}
None => {}
Some(lang_item) => self.register(&lang_item, i.span),
}
- visit::walk_foreign_item(self, i)
+ intravisit::walk_foreign_item(self, i)
}
}
use syntax::attr;
use syntax::codemap::Span;
use syntax::diagnostic;
-use rustc_front::visit;
-use rustc_front::visit::Visitor;
+use rustc_front::intravisit::Visitor;
use rustc_front::hir;
struct RegistrarFinder {
self.registrars.push((item.id, item.span));
}
}
-
- visit::walk_item(self, item);
}
}
krate: &hir::Crate)
-> Option<ast::NodeId> {
let mut finder = RegistrarFinder { registrars: Vec::new() };
- visit::walk_crate(&mut finder, krate);
+ krate.visit_all_items(&mut finder);
match finder.registrars.len() {
0 => None,
use std::time::Duration;
use rustc_front::hir;
-use rustc_front::visit;
-use rustc_front::visit::Visitor;
+use rustc_front::intravisit;
+use rustc_front::intravisit::Visitor;
// The name of the associated type for `Fn` return types
pub const FN_OUTPUT_NAME: &'static str = "Output";
// Skip inner loops, since a break in the inner loop isn't a
// break inside the outer loop
hir::ExprLoop(..) | hir::ExprWhile(..) => {}
- _ => visit::walk_expr(self, e)
+ _ => intravisit::walk_expr(self, e)
}
}
}
p: p,
flag: false,
};
- visit::walk_block(&mut v, b);
+ intravisit::walk_block(&mut v, b);
return v.flag;
}
impl<'v, P> Visitor<'v> for BlockQueryVisitor<P> where P: FnMut(&hir::Expr) -> bool {
fn visit_expr(&mut self, e: &hir::Expr) {
self.flag |= (self.p)(e);
- visit::walk_expr(self, e)
+ intravisit::walk_expr(self, e)
}
}
p: p,
flag: false,
};
- visit::walk_block(&mut v, &*b);
+ intravisit::walk_block(&mut v, &*b);
return v.flag;
}
use syntax::ast::NodeId;
use rustc_front::hir;
use rustc_front::hir::{Expr, FnDecl, Block, Pat};
-use rustc_front::visit;
-use rustc_front::visit::Visitor;
+use rustc_front::intravisit;
+use rustc_front::intravisit::Visitor;
mod lifetime;
mod restrictions;
}
}
- visit::walk_expr(self, ex);
+ intravisit::walk_expr(self, ex);
}
}
use rustc_front::hir;
use rustc_front::hir::{FnDecl, Block};
-use rustc_front::visit;
-use rustc_front::visit::{Visitor, FnKind};
+use rustc_front::intravisit;
+use rustc_front::intravisit::{Visitor, FnKind};
use rustc_front::util as hir_util;
pub mod check_loans;
if let hir::ConstTraitItem(_, Some(ref expr)) = ti.node {
gather_loans::gather_loans_in_static_initializer(self, &*expr);
}
- visit::walk_trait_item(self, ti);
+ intravisit::walk_trait_item(self, ti);
}
fn visit_impl_item(&mut self, ii: &hir::ImplItem) {
if let hir::ImplItemKind::Const(_, ref expr) = ii.node {
gather_loans::gather_loans_in_static_initializer(self, &*expr);
}
- visit::walk_impl_item(self, ii);
+ intravisit::walk_impl_item(self, ii);
}
}
}
};
- visit::walk_crate(&mut bccx, tcx.map.krate());
+ tcx.map.krate().visit_all_items(&mut bccx);
if tcx.sess.borrowck_stats() {
println!("--- borrowck stats ---");
_ => { }
}
- visit::walk_item(this, item);
+ intravisit::walk_item(this, item);
}
/// Collection of conclusions determined via borrow checker analyses.
decl,
body);
- visit::walk_fn(this, fk, decl, body, sp);
+ intravisit::walk_fn(this, fk, decl, body, sp);
}
fn build_borrowck_dataflow_data<'a, 'tcx>(this: &mut BorrowckCtxt<'a, 'tcx>,
time(time_passes,
"lint checking",
- || lint::check_crate(tcx, krate, &exported_items));
+ || lint::check_crate(tcx, &exported_items));
// The above three passes generate errors w/o aborting
tcx.sess.abort_if_errors();
&mut rdr,
box out,
annotation.pp_ann(),
- true);
+ true,
+ Some(ast_map.krate()));
for node_id in uii.all_matching_node_ids(ast_map) {
let node = ast_map.get(node_id);
try!(pp_state.print_node(&node));
use syntax::codemap::Span;
use rustc_front::hir;
-use rustc_front::visit::FnKind;
+use rustc_front::intravisit::FnKind;
#[derive(PartialEq)]
pub enum MethodLateContext {
use syntax::codemap::{self, Span};
use rustc_front::hir;
-use rustc_front::visit::FnKind;
+use rustc_front::intravisit::FnKind;
use bad_style::{MethodLateContext, method_context};
use syntax::ast::{TyIs, TyUs, TyI8, TyU8, TyI16, TyU16, TyI32, TyU32, TyI64, TyU64};
use rustc_front::hir;
-use rustc_front::visit::{self, Visitor};
+use rustc_front::intravisit::{self, Visitor};
use rustc_front::util::is_shift_binop;
declare_lint! {
"found Rust tuple type in foreign module; \
consider using a struct instead`")
}
- _ => visit::walk_ty(self, ty)
+ _ => intravisit::walk_ty(self, ty)
}
}
}
use rustc_back::slice;
use rustc_front::hir;
-use rustc_front::visit::FnKind;
+use rustc_front::intravisit::FnKind;
declare_lint! {
pub UNUSED_MUT,
use self::rustc::util::common::ErrorReported;
use self::rustc::util::nodemap::NodeMap;
use self::rustc_front::hir;
-use self::rustc_front::visit;
+use self::rustc_front::intravisit::{self, Visitor};
use self::syntax::ast;
use self::syntax::attr::AttrMetaMethods;
use self::syntax::codemap::Span;
tcx: tcx,
map: &mut map,
};
- visit::walk_crate(&mut dump, tcx.map.krate());
+ tcx.map.krate().visit_all_items(&mut dump);
}
map
}
}
-impl<'a, 'tcx> visit::Visitor<'tcx> for OuterDump<'a, 'tcx> {
+impl<'a, 'tcx> Visitor<'tcx> for OuterDump<'a, 'tcx> {
fn visit_item(&mut self, item: &'tcx hir::Item) {
- self.visit_mir(&item.attrs, |c| visit::walk_item(c, item));
- visit::walk_item(self, item);
+ self.visit_mir(&item.attrs, |c| intravisit::walk_item(c, item));
+ intravisit::walk_item(self, item);
}
fn visit_trait_item(&mut self, trait_item: &'tcx hir::TraitItem) {
match trait_item.node {
hir::MethodTraitItem(_, Some(_)) => {
- self.visit_mir(&trait_item.attrs, |c| visit::walk_trait_item(c, trait_item));
+ self.visit_mir(&trait_item.attrs, |c| intravisit::walk_trait_item(c, trait_item));
}
hir::MethodTraitItem(_, None) |
hir::ConstTraitItem(..) |
hir::TypeTraitItem(..) => {}
}
- visit::walk_trait_item(self, trait_item);
+ intravisit::walk_trait_item(self, trait_item);
}
fn visit_impl_item(&mut self, impl_item: &'tcx hir::ImplItem) {
match impl_item.node {
hir::ImplItemKind::Method(..) => {
- self.visit_mir(&impl_item.attrs, |c| visit::walk_impl_item(c, impl_item));
+ self.visit_mir(&impl_item.attrs, |c| intravisit::walk_impl_item(c, impl_item));
}
hir::ImplItemKind::Const(..) | hir::ImplItemKind::Type(..) => {}
}
- visit::walk_impl_item(self, impl_item);
+ intravisit::walk_impl_item(self, impl_item);
}
}
attr: Option<&'a ast::Attribute>,
}
-impl<'a, 'm, 'tcx> visit::Visitor<'tcx> for InnerDump<'a,'m,'tcx> {
- fn visit_item(&mut self, _: &'tcx hir::Item) {
- // ignore nested items; they need their own graphviz annotation
- }
-
+impl<'a, 'm, 'tcx> Visitor<'tcx> for InnerDump<'a,'m,'tcx> {
fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) {
- // ignore nested items; they need their own graphviz annotation
+ // ignore methods; the outer dump will call us for them independently
}
fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) {
- // ignore nested items; they need their own graphviz annotation
+ // ignore methods; the outer dump will call us for them independently
}
fn visit_fn(&mut self,
- fk: visit::FnKind<'tcx>,
+ fk: intravisit::FnKind<'tcx>,
decl: &'tcx hir::FnDecl,
body: &'tcx hir::Block,
span: Span,
id: ast::NodeId) {
let (prefix, implicit_arg_tys) = match fk {
- visit::FnKind::Closure =>
+ intravisit::FnKind::Closure =>
(format!("{}-", id), vec![closure_self_ty(&self.tcx, id, body.id)]),
_ =>
(format!(""), vec![]),
Err(ErrorReported) => {}
}
- visit::walk_fn(self, fk, decl, body, span);
+ intravisit::walk_fn(self, fk, decl, body, span);
}
}
use rustc_front::hir;
use rustc_front::hir::{ViewPathGlob, ViewPathList, ViewPathSimple};
-use rustc_front::visit::{self, Visitor};
+use rustc_front::intravisit::Visitor;
struct UnusedImportCheckVisitor<'a, 'b: 'a, 'tcx: 'b> {
resolver: &'a mut Resolver<'b, 'tcx>,
// because this means that they were generated in some fashion by the
// compiler and we don't need to consider them.
if item.vis == hir::Public || item.span == DUMMY_SP {
- visit::walk_item(self, item);
return;
}
}
_ => {}
}
-
- visit::walk_item(self, item);
}
}
pub fn check_crate(resolver: &mut Resolver, krate: &hir::Crate) {
let mut visitor = UnusedImportCheckVisitor { resolver: resolver };
- visit::walk_crate(&mut visitor, krate);
+ krate.visit_all_items(&mut visitor);
}
/// Retrieve all traits in this crate and any dependent crates.
pub fn all_traits<'a>(ccx: &'a CrateCtxt) -> AllTraits<'a> {
if ccx.all_traits.borrow().is_none() {
- use rustc_front::visit;
+ use rustc_front::intravisit;
let mut traits = vec![];
map: &'a hir_map::Map<'tcx>,
traits: &'a mut AllTraitsVec,
}
- impl<'v, 'a, 'tcx> visit::Visitor<'v> for Visitor<'a, 'tcx> {
+ impl<'v, 'a, 'tcx> intravisit::Visitor<'v> for Visitor<'a, 'tcx> {
fn visit_item(&mut self, i: &'v hir::Item) {
match i.node {
hir::ItemTrait(..) => {
}
_ => {}
}
- visit::walk_item(self, i)
}
}
- visit::walk_crate(&mut Visitor {
+ ccx.tcx.map.krate().visit_all_items(&mut Visitor {
map: &ccx.tcx.map,
traits: &mut traits
- }, ccx.tcx.map.krate());
+ });
// Cross-crate:
let mut external_mods = FnvHashSet();
use syntax::parse::token::{self, InternedString};
use syntax::ptr::P;
-use rustc_front::visit::{self, Visitor};
+use rustc_front::intravisit::{self, Visitor};
use rustc_front::hir;
use rustc_front::hir::Visibility;
use rustc_front::hir::{Item, ItemImpl};
impl<'a, 'tcx> Visitor<'tcx> for CheckItemTypesVisitor<'a, 'tcx> {
fn visit_item(&mut self, i: &'tcx hir::Item) {
check_item_type(self.ccx, i);
- visit::walk_item(self, i);
+ intravisit::walk_item(self, i);
}
fn visit_ty(&mut self, t: &'tcx hir::Ty) {
_ => {}
}
- visit::walk_ty(self, t);
+ intravisit::walk_ty(self, t);
}
}
impl<'a, 'tcx> Visitor<'tcx> for CheckItemBodiesVisitor<'a, 'tcx> {
fn visit_item(&mut self, i: &'tcx hir::Item) {
check_item_body(self.ccx, i);
- visit::walk_item(self, i);
}
}
// comes, we run the new code and issue warnings.
let krate = ccx.tcx.map.krate();
let mut visit = wf::CheckTypeWellFormedVisitor::new(ccx);
- visit::walk_crate(&mut visit, krate);
+ krate.visit_all_items(&mut visit);
// If types are not well-formed, it leads to all manner of errors
// downstream, so stop reporting errors at this point.
pub fn check_wf_new(ccx: &CrateCtxt) {
let krate = ccx.tcx.map.krate();
let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(ccx);
- visit::walk_crate(&mut visit, krate);
+ krate.visit_all_items(&mut visit);
// If types are not well-formed, it leads to all manner of errors
// downstream, so stop reporting errors at this point.
pub fn check_item_types(ccx: &CrateCtxt) {
let krate = ccx.tcx.map.krate();
let mut visit = CheckItemTypesVisitor { ccx: ccx };
- visit::walk_crate(&mut visit, krate);
+ krate.visit_all_items(&mut visit);
ccx.tcx.sess.abort_if_errors();
}
pub fn check_item_bodies(ccx: &CrateCtxt) {
let krate = ccx.tcx.map.krate();
let mut visit = CheckItemBodiesVisitor { ccx: ccx };
- visit::walk_crate(&mut visit, krate);
+ krate.visit_all_items(&mut visit);
ccx.tcx.sess.abort_if_errors();
}
local.pat,
self.fcx.infcx().ty_to_string(
self.fcx.inh.locals.borrow().get(&local.id).unwrap().clone()));
- visit::walk_local(self, local);
+ intravisit::walk_local(self, local);
}
// Add pattern bindings.
var_ty);
}
}
- visit::walk_pat(self, p);
+ intravisit::walk_pat(self, p);
}
fn visit_block(&mut self, b: &'tcx hir::Block) {
// non-obvious: the `blk` variable maps to region lb, so
// we have to keep this up-to-date. This
// is... unfortunate. It'd be nice to not need this.
- visit::walk_block(self, b);
+ intravisit::walk_block(self, b);
}
// Since an expr occurs as part of the type fixed size arrays we
check_expr_with_hint(self.fcx, &**count_expr, self.fcx.tcx().types.usize);
}
hir::TyBareFn(ref function_declaration) => {
- visit::walk_fn_decl_nopat(self, &function_declaration.decl);
+ intravisit::walk_fn_decl_nopat(self, &function_declaration.decl);
walk_list!(self, visit_lifetime_def, &function_declaration.lifetimes);
}
- _ => visit::walk_ty(self, t)
+ _ => intravisit::walk_ty(self, t)
}
}
- // Don't descend into fns and items
- fn visit_fn(&mut self, _: visit::FnKind<'tcx>, _: &'tcx hir::FnDecl,
+ // Don't descend into the bodies of nested closures
+ fn visit_fn(&mut self, _: intravisit::FnKind<'tcx>, _: &'tcx hir::FnDecl,
_: &'tcx hir::Block, _: Span, _: ast::NodeId) { }
- fn visit_item(&mut self, _: &hir::Item) { }
-
}
/// Helper used by check_bare_fn and check_expr_fn. Does the grungy work of checking a function
use std::rc::Rc;
use syntax::ast;
use syntax::codemap::Span;
-use rustc_front::visit;
-use rustc_front::visit::Visitor;
+use rustc_front::intravisit::{self, Visitor};
use rustc_front::hir;
use rustc_front::util as hir_util;
// hierarchy, and in particular the relationships between free
// regions, until regionck, as described in #3238.
- fn visit_fn(&mut self, _fk: visit::FnKind<'v>, fd: &'v hir::FnDecl,
+ fn visit_fn(&mut self, _fk: intravisit::FnKind<'v>, fd: &'v hir::FnDecl,
b: &'v hir::Block, span: Span, id: ast::NodeId) {
self.visit_fn_body(id, fd, b, span)
}
- fn visit_item(&mut self, i: &hir::Item) { visit_item(self, i); }
-
fn visit_expr(&mut self, ex: &hir::Expr) { visit_expr(self, ex); }
//visit_pat: visit_pat, // (..) see above
fn visit_block(&mut self, b: &hir::Block) { visit_block(self, b); }
}
-fn visit_item(_rcx: &mut Rcx, _item: &hir::Item) {
- // Ignore items
-}
-
fn visit_block(rcx: &mut Rcx, b: &hir::Block) {
- visit::walk_block(rcx, b);
+ intravisit::walk_block(rcx, b);
}
fn visit_arm(rcx: &mut Rcx, arm: &hir::Arm) {
constrain_bindings_in_pat(&**p, rcx);
}
- visit::walk_arm(rcx, arm);
+ intravisit::walk_arm(rcx, arm);
}
fn visit_local(rcx: &mut Rcx, l: &hir::Local) {
// see above
constrain_bindings_in_pat(&*l.pat, rcx);
link_local(rcx, l);
- visit::walk_local(rcx, l);
+ intravisit::walk_local(rcx, l);
}
fn constrain_bindings_in_pat(pat: &hir::Pat, rcx: &mut Rcx) {
args.iter().map(|e| &**e), false);
}
- visit::walk_expr(rcx, expr);
+ intravisit::walk_expr(rcx, expr);
}
hir::ExprMethodCall(_, _, ref args) => {
constrain_call(rcx, expr, Some(&*args[0]),
args[1..].iter().map(|e| &**e), false);
- visit::walk_expr(rcx, expr);
+ intravisit::walk_expr(rcx, expr);
}
hir::ExprAssignOp(_, ref lhs, ref rhs) => {
Some(&**rhs).into_iter(), false);
}
- visit::walk_expr(rcx, expr);
+ intravisit::walk_expr(rcx, expr);
}
hir::ExprIndex(ref lhs, ref rhs) if has_method_map => {
constrain_call(rcx, expr, Some(&**lhs),
Some(&**rhs).into_iter(), true);
- visit::walk_expr(rcx, expr);
+ intravisit::walk_expr(rcx, expr);
},
hir::ExprBinary(op, ref lhs, ref rhs) if has_method_map => {
constrain_call(rcx, expr, Some(&**lhs),
Some(&**rhs).into_iter(), implicitly_ref_args);
- visit::walk_expr(rcx, expr);
+ intravisit::walk_expr(rcx, expr);
}
hir::ExprBinary(_, ref lhs, ref rhs) => {
ty,
expr_region);
}
- visit::walk_expr(rcx, expr);
+ intravisit::walk_expr(rcx, expr);
}
hir::ExprUnary(op, ref lhs) if has_method_map => {
constrain_call(rcx, expr, Some(&**lhs),
None::<hir::Expr>.iter(), implicitly_ref_args);
- visit::walk_expr(rcx, expr);
+ intravisit::walk_expr(rcx, expr);
}
hir::ExprUnary(hir::UnDeref, ref base) => {
rcx, expr.span, expr_region, *r_ptr);
}
- visit::walk_expr(rcx, expr);
+ intravisit::walk_expr(rcx, expr);
}
hir::ExprIndex(ref vec_expr, _) => {
let vec_type = rcx.resolve_expr_type_adjusted(&**vec_expr);
constrain_index(rcx, expr, vec_type);
- visit::walk_expr(rcx, expr);
+ intravisit::walk_expr(rcx, expr);
}
hir::ExprCast(ref source, _) => {
// instance. If so, we have to be sure that the type of
// the source obeys the trait's region bound.
constrain_cast(rcx, expr, &**source);
- visit::walk_expr(rcx, expr);
+ intravisit::walk_expr(rcx, expr);
}
hir::ExprAddrOf(m, ref base) => {
// FIXME(#6268) nested method calls requires that this rule change
let ty0 = rcx.resolve_node_type(expr.id);
type_must_outlive(rcx, infer::AddrOf(expr.span), ty0, expr_region);
- visit::walk_expr(rcx, expr);
+ intravisit::walk_expr(rcx, expr);
}
hir::ExprMatch(ref discr, ref arms, _) => {
link_match(rcx, &**discr, &arms[..]);
- visit::walk_expr(rcx, expr);
+ intravisit::walk_expr(rcx, expr);
}
hir::ExprClosure(_, _, ref body) => {
hir::ExprLoop(ref body, _) => {
let repeating_scope = rcx.set_repeating_scope(body.id);
- visit::walk_expr(rcx, expr);
+ intravisit::walk_expr(rcx, expr);
rcx.set_repeating_scope(repeating_scope);
}
}
_ => {
- visit::walk_expr(rcx, expr);
+ intravisit::walk_expr(rcx, expr);
}
}
}
expr: &hir::Expr,
body: &hir::Block) {
let repeating_scope = rcx.set_repeating_scope(body.id);
- visit::walk_expr(rcx, expr);
+ intravisit::walk_expr(rcx, expr);
rcx.set_repeating_scope(repeating_scope);
}
use syntax::ast;
use syntax::codemap::Span;
use rustc_front::hir;
-use rustc_front::visit::{self, Visitor};
+use rustc_front::intravisit::{self, Visitor};
///////////////////////////////////////////////////////////////////////////
// PUBLIC ENTRY POINTS
_ => { }
}
- visit::walk_expr(self, expr);
+ intravisit::walk_expr(self, expr);
}
-
- // Skip all items; they aren't in the same context.
- fn visit_item(&mut self, _: &'v hir::Item) { }
}
impl<'a,'tcx> SeedBorrowKind<'a,'tcx> {
impl<'a, 'tcx, 'v> Visitor<'v> for AdjustBorrowKind<'a, 'tcx> {
fn visit_fn(&mut self,
- fn_kind: visit::FnKind<'v>,
+ fn_kind: intravisit::FnKind<'v>,
decl: &'v hir::FnDecl,
body: &'v hir::Block,
span: Span,
id: ast::NodeId)
{
- visit::walk_fn(self, fn_kind, decl, body, span);
+ intravisit::walk_fn(self, fn_kind, decl, body, span);
self.analyze_closure(id, span, decl, body);
}
-
- // Skip all items; they aren't in the same context.
- fn visit_item(&mut self, _: &'v hir::Item) { }
}
impl<'a,'tcx> euv::Delegate<'tcx> for AdjustBorrowKind<'a,'tcx> {
use syntax::codemap::{DUMMY_SP, Span};
use syntax::parse::token::special_idents;
-use rustc_front::visit::{self, Visitor, FnKind};
+use rustc_front::intravisit::{self, Visitor, FnKind};
use rustc_front::hir;
pub struct CheckTypeWellFormedVisitor<'ccx, 'tcx:'ccx> {
impl<'ccx, 'tcx, 'v> Visitor<'v> for CheckTypeWellFormedVisitor<'ccx, 'tcx> {
fn visit_item(&mut self, i: &hir::Item) {
self.check_item_well_formed(i);
- visit::walk_item(self, i);
+ intravisit::walk_item(self, i);
}
fn visit_fn(&mut self,
}
}
}
- visit::walk_fn(self, fk, fd, b, span)
+ intravisit::walk_fn(self, fk, fd, b, span)
}
fn visit_trait_item(&mut self, trait_item: &'v hir::TraitItem) {
}
}
- visit::walk_trait_item(self, trait_item)
+ intravisit::walk_trait_item(self, trait_item)
}
}
use syntax::codemap::{Span};
use syntax::parse::token::{special_idents};
use syntax::ptr::P;
-use rustc_front::visit;
-use rustc_front::visit::Visitor;
+use rustc_front::intravisit::{self, Visitor};
use rustc_front::hir;
pub struct CheckTypeWellFormedVisitor<'ccx, 'tcx:'ccx> {
fn visit_item(&mut self, i: &hir::Item) {
debug!("visit_item: {:?}", i);
self.check_item_well_formed(i);
- visit::walk_item(self, i);
+ intravisit::walk_item(self, i);
}
fn visit_trait_item(&mut self, trait_item: &'v hir::TraitItem) {
debug!("visit_trait_item: {:?}", trait_item);
self.check_trait_or_impl_item(trait_item.id, trait_item.span);
- visit::walk_trait_item(self, trait_item)
+ intravisit::walk_trait_item(self, trait_item)
}
fn visit_impl_item(&mut self, impl_item: &'v hir::ImplItem) {
debug!("visit_impl_item: {:?}", impl_item);
self.check_trait_or_impl_item(impl_item.id, impl_item.span);
- visit::walk_impl_item(self, impl_item)
+ intravisit::walk_impl_item(self, impl_item)
}
}
use syntax::ast;
use syntax::codemap::{DUMMY_SP, Span};
use rustc_front::print::pprust::pat_to_string;
-use rustc_front::visit;
-use rustc_front::visit::Visitor;
+use rustc_front::intravisit::{self, Visitor};
use rustc_front::util as hir_util;
use rustc_front::hir;
// traffic in node-ids or update tables in the type context etc.
impl<'cx, 'tcx, 'v> Visitor<'v> for WritebackCx<'cx, 'tcx> {
- fn visit_item(&mut self, _: &hir::Item) {
- // Ignore items
- }
-
fn visit_stmt(&mut self, s: &hir::Stmt) {
if self.fcx.writeback_errors.get() {
return;
}
self.visit_node_id(ResolvingExpr(s.span), hir_util::stmt_id(s));
- visit::walk_stmt(self, s);
+ intravisit::walk_stmt(self, s);
}
fn visit_expr(&mut self, e: &hir::Expr) {
}
}
- visit::walk_expr(self, e);
+ intravisit::walk_expr(self, e);
}
fn visit_block(&mut self, b: &hir::Block) {
}
self.visit_node_id(ResolvingExpr(b.span), b.id);
- visit::walk_block(self, b);
+ intravisit::walk_block(self, b);
}
fn visit_pat(&mut self, p: &hir::Pat) {
p.id,
self.tcx().node_id_to_type(p.id));
- visit::walk_pat(self, p);
+ intravisit::walk_pat(self, p);
}
fn visit_local(&mut self, l: &hir::Local) {
let var_ty = self.fcx.local_ty(l.span, l.id);
let var_ty = self.resolve(&var_ty, ResolvingLocal(l.span));
write_ty_to_tcx(self.tcx(), l.id, var_ty);
- visit::walk_local(self, l);
+ intravisit::walk_local(self, l);
}
fn visit_ty(&mut self, t: &hir::Ty) {
write_ty_to_tcx(self.tcx(), count_expr.id, self.tcx().types.usize);
}
hir::TyBareFn(ref function_declaration) => {
- visit::walk_fn_decl_nopat(self, &function_declaration.decl);
+ intravisit::walk_fn_decl_nopat(self, &function_declaration.decl);
walk_list!(self, visit_lifetime_def, &function_declaration.lifetimes);
}
- _ => visit::walk_ty(self, t)
+ _ => intravisit::walk_ty(self, t)
}
}
}
use util::nodemap::{DefIdMap, FnvHashMap};
use rustc::front::map as hir_map;
use rustc::front::map::NodeItem;
-use rustc_front::visit;
+use rustc_front::intravisit;
use rustc_front::hir::{Item, ItemImpl,Crate};
use rustc_front::hir;
cc: &'a CoherenceChecker<'a, 'tcx>
}
-impl<'a, 'tcx, 'v> visit::Visitor<'v> for CoherenceCheckVisitor<'a, 'tcx> {
+impl<'a, 'tcx, 'v> intravisit::Visitor<'v> for CoherenceCheckVisitor<'a, 'tcx> {
fn visit_item(&mut self, item: &Item) {
if let ItemImpl(..) = item.node {
self.cc.check_implementation(item)
}
-
- visit::walk_item(self, item);
}
}
// Check implementations and traits. This populates the tables
// containing the inherent methods and extension methods. It also
// builds up the trait inheritance table.
- let mut visitor = CoherenceCheckVisitor { cc: self };
- visit::walk_crate(&mut visitor, krate);
+ krate.visit_all_items(&mut CoherenceCheckVisitor { cc: self });
// Copy over the inherent impls we gathered up during the walk into
// the tcx.
use middle::ty;
use syntax::ast;
use syntax::codemap::Span;
-use rustc_front::visit;
+use rustc_front::intravisit;
use rustc_front::hir;
use rustc_front::hir::{Item, ItemImpl};
pub fn check(tcx: &ty::ctxt) {
let mut orphan = OrphanChecker { tcx: tcx };
- visit::walk_crate(&mut orphan, tcx.map.krate());
+ tcx.map.krate().visit_all_items(&mut orphan);
}
struct OrphanChecker<'cx, 'tcx:'cx> {
}
}
-impl<'cx, 'tcx,'v> visit::Visitor<'v> for OrphanChecker<'cx, 'tcx> {
+impl<'cx, 'tcx,'v> intravisit::Visitor<'v> for OrphanChecker<'cx, 'tcx> {
fn visit_item(&mut self, item: &hir::Item) {
self.check_item(item);
- visit::walk_item(self, item);
}
}
use syntax::ast;
use syntax::codemap::Span;
use rustc_front::hir;
-use rustc_front::visit;
+use rustc_front::intravisit;
use util::nodemap::DefIdMap;
pub fn check(tcx: &ty::ctxt) {
// this secondary walk specifically checks for some other cases,
// like defaulted traits, for which additional overlap rules exist
- visit::walk_crate(&mut overlap, tcx.map.krate());
+ tcx.map.krate().visit_all_items(&mut overlap);
}
struct OverlapChecker<'cx, 'tcx:'cx> {
}
-impl<'cx, 'tcx,'v> visit::Visitor<'v> for OverlapChecker<'cx, 'tcx> {
+impl<'cx, 'tcx,'v> intravisit::Visitor<'v> for OverlapChecker<'cx, 'tcx> {
fn visit_item(&mut self, item: &'v hir::Item) {
match item.node {
hir::ItemDefaultImpl(_, _) => {
_ => {
}
}
- visit::walk_item(self, item);
}
}
//! crate or pertains to a type defined in this crate.
use middle::ty;
-use rustc_front::visit;
+use rustc_front::intravisit;
use rustc_front::hir;
use rustc_front::hir::{Item, ItemImpl};
pub fn check(tcx: &ty::ctxt) {
let mut orphan = UnsafetyChecker { tcx: tcx };
- visit::walk_crate(&mut orphan, tcx.map.krate());
+ tcx.map.krate().visit_all_items(&mut orphan);
}
struct UnsafetyChecker<'cx, 'tcx:'cx> {
}
}
-impl<'cx, 'tcx,'v> visit::Visitor<'v> for UnsafetyChecker<'cx, 'tcx> {
+impl<'cx, 'tcx,'v> intravisit::Visitor<'v> for UnsafetyChecker<'cx, 'tcx> {
fn visit_item(&mut self, item: &'v hir::Item) {
match item.node {
hir::ItemDefaultImpl(unsafety, _) => {
}
_ => { }
}
-
- visit::walk_item(self, item);
}
}
use syntax::parse::token::special_idents;
use syntax::ptr::P;
use rustc_front::hir;
-use rustc_front::visit;
+use rustc_front::intravisit;
use rustc_front::print::pprust;
///////////////////////////////////////////////////////////////////////////
let ccx = &CrateCtxt { tcx: tcx, stack: RefCell::new(Vec::new()) };
let mut visitor = CollectTraitDefVisitor{ ccx: ccx };
- visit::walk_crate(&mut visitor, ccx.tcx.map.krate());
+ ccx.tcx.map.krate().visit_all_items(&mut visitor);
let mut visitor = CollectItemTypesVisitor{ ccx: ccx };
- visit::walk_crate(&mut visitor, ccx.tcx.map.krate());
+ ccx.tcx.map.krate().visit_all_items(&mut visitor);
}
///////////////////////////////////////////////////////////////////////////
ccx: &'a CrateCtxt<'a, 'tcx>
}
-impl<'a, 'tcx, 'v> visit::Visitor<'v> for CollectTraitDefVisitor<'a, 'tcx> {
+impl<'a, 'tcx, 'v> intravisit::Visitor<'v> for CollectTraitDefVisitor<'a, 'tcx> {
fn visit_item(&mut self, i: &hir::Item) {
match i.node {
hir::ItemTrait(..) => {
}
_ => { }
}
-
- visit::walk_item(self, i);
}
}
ccx: &'a CrateCtxt<'a, 'tcx>
}
-impl<'a, 'tcx, 'v> visit::Visitor<'v> for CollectItemTypesVisitor<'a, 'tcx> {
+impl<'a, 'tcx, 'v> intravisit::Visitor<'v> for CollectItemTypesVisitor<'a, 'tcx> {
fn visit_item(&mut self, i: &hir::Item) {
convert_item(self.ccx, i);
- visit::walk_item(self, i);
+ intravisit::walk_item(self, i);
}
fn visit_foreign_item(&mut self, i: &hir::ForeignItem) {
convert_foreign_item(self.ccx, i);
- visit::walk_foreign_item(self, i);
+ intravisit::walk_foreign_item(self, i);
}
}
use std::rc::Rc;
use syntax::ast;
use rustc_front::hir;
-use rustc_front::visit;
-use rustc_front::visit::Visitor;
+use rustc_front::intravisit::Visitor;
use util::nodemap::NodeMap;
pub fn infer_variance(tcx: &ty::ctxt) {
})
};
- visit::walk_crate(&mut terms_cx, krate);
+ krate.visit_all_items(&mut terms_cx);
terms_cx
}
// constrained to be invariant. See `visit_item` in
// the impl for `ConstraintContext` below.
self.add_inferreds_for_item(item.id, true, generics);
- visit::walk_item(self, item);
}
hir::ItemExternCrate(_) |
hir::ItemMod(..) |
hir::ItemForeignMod(..) |
hir::ItemTy(..) => {
- visit::walk_item(self, item);
}
}
}
bivariant: bivariant,
constraints: Vec::new(),
};
- visit::walk_crate(&mut constraint_cx, krate);
+ krate.visit_all_items(&mut constraint_cx);
constraint_cx
}
hir::ItemDefaultImpl(..) => {
}
}
-
- visit::walk_item(self, item);
}
}
om.vis = vis;
om.stab = self.stability(id);
om.id = id;
- for i in &m.items {
- self.visit_item(&**i, None, &mut om);
+ for i in &m.item_ids {
+ let item = self.cx.map.expect_item(i.id);
+ self.visit_item(item, None, &mut om);
}
om
}
let prev = mem::replace(&mut self.inlining_from_glob, true);
match it.node {
hir::ItemMod(ref m) => {
- for i in &m.items {
- self.visit_item(&**i, None, om);
+ for i in &m.item_ids {
+ let i = self.cx.map.expect_item(i.id);
+ self.visit_item(i, None, om);
}
}
hir::ItemEnum(..) => {}
projects / rust.git / commitdiff