}
}
-impl<'a> Visitor for Context<'a> {
+impl<'a, 'v> Visitor<'v> for Context<'a> {
fn visit_ident(&mut self, sp: Span, id: ast::Ident) {
if !token::get_ident(id).get().is_ascii() {
self.gate_feature("non_ascii_idents", sp,
}
fn visit_fn(&mut self,
- fn_kind: &visit::FnKind,
- fn_decl: &ast::FnDecl,
- block: &ast::Block,
+ fn_kind: visit::FnKind<'v>,
+ fn_decl: &'v ast::FnDecl,
+ block: &'v ast::Block,
span: Span,
_: NodeId) {
- match *fn_kind {
- visit::FkItemFn(_, _, _, ref abi) if *abi == RustIntrinsic => {
+ match fn_kind {
+ visit::FkItemFn(_, _, _, abi) if abi == RustIntrinsic => {
self.gate_feature("intrinsics",
span,
"intrinsics are subject to change")
sess: &'a Session
}
-impl<'a> Visitor for ShowSpanVisitor<'a> {
+impl<'a, 'v> Visitor<'v> for ShowSpanVisitor<'a> {
fn visit_expr(&mut self, e: &ast::Expr) {
self.sess.span_note(e.span, "expression");
visit::walk_expr(self, e);
}
}
-impl<'a, 'tcx> Visitor for CTypesVisitor<'a, 'tcx> {
+impl<'a, 'tcx, 'v> Visitor<'v> for CTypesVisitor<'a, 'tcx> {
fn visit_ty(&mut self, ty: &ast::Ty) {
match ty.node {
ast::TyPath(_, _, id) => self.check_def(ty.span, ty.id, id),
cx: &'a Context<'a, 'tcx>
}
-impl<'a, 'tcx> Visitor for RawPtrDerivingVisitor<'a, 'tcx> {
+impl<'a, 'tcx, 'v> Visitor<'v> for RawPtrDerivingVisitor<'a, 'tcx> {
fn visit_ty(&mut self, ty: &ast::Ty) {
static MSG: &'static str = "use of `#[deriving]` with a raw pointer";
match ty.node {
}
fn check_fn(&mut self, cx: &Context,
- fk: &visit::FnKind, _: &ast::FnDecl,
+ fk: visit::FnKind, _: &ast::FnDecl,
_: &ast::Block, span: Span, _: ast::NodeId) {
- match *fk {
+ match fk {
visit::FkMethod(ident, _, m) => match method_context(cx, m) {
PlainImpl
=> self.check_snake_case(cx, "method", ident, span),
}
fn check_fn(&mut self, cx: &Context,
- _: &visit::FnKind, decl: &ast::FnDecl,
+ _: visit::FnKind, decl: &ast::FnDecl,
_: &ast::Block, _: Span, _: ast::NodeId) {
for a in decl.inputs.iter() {
self.check_unused_mut_pat(cx, &[a.pat]);
}
fn check_fn(&mut self, cx: &Context,
- fk: &visit::FnKind, _: &ast::FnDecl,
+ fk: visit::FnKind, _: &ast::FnDecl,
_: &ast::Block, _: Span, _: ast::NodeId) {
- match *fk {
+ match fk {
visit::FkMethod(_, _, m) => {
// If the method is an impl for a trait, don't doc.
if method_context(cx, m) == TraitImpl { return; }
}
}
-impl<'a, 'tcx> Visitor for Context<'a, 'tcx> {
+impl<'a, 'tcx, 'v> Visitor<'v> for Context<'a, 'tcx> {
fn visit_item(&mut self, it: &ast::Item) {
self.with_lint_attrs(it.attrs.as_slice(), |cx| {
run_lints!(cx, check_item, it);
visit::walk_stmt(self, s);
}
- fn visit_fn(&mut self, fk: &FnKind, decl: &ast::FnDecl,
- body: &ast::Block, span: Span, id: ast::NodeId) {
- match *fk {
+ fn visit_fn(&mut self, fk: FnKind<'v>, decl: &'v ast::FnDecl,
+ body: &'v ast::Block, span: Span, id: ast::NodeId) {
+ match fk {
visit::FkMethod(_, _, m) => {
self.with_lint_attrs(m.attrs.as_slice(), |cx| {
run_lints!(cx, check_fn, fk, decl, body, span, id);
fn check_ty(&mut self, _: &Context, _: &ast::Ty) { }
fn check_generics(&mut self, _: &Context, _: &ast::Generics) { }
fn check_fn(&mut self, _: &Context,
- _: &FnKind, _: &ast::FnDecl, _: &ast::Block, _: Span, _: ast::NodeId) { }
+ _: FnKind, _: &ast::FnDecl, _: &ast::Block, _: Span, _: ast::NodeId) { }
fn check_ty_method(&mut self, _: &Context, _: &ast::TypeMethod) { }
fn check_trait_method(&mut self, _: &Context, _: &ast::TraitItem) { }
fn check_struct_def(&mut self, _: &Context,
warn_if_multiple_versions(sess.diagnostic(), &sess.cstore)
}
-impl<'a> visit::Visitor for Env<'a> {
+impl<'a, 'v> visit::Visitor<'v> for Env<'a> {
fn visit_view_item(&mut self, a: &ast::ViewItem) {
visit_view_item(self, a);
visit::walk_view_item(self, a);
index: &'a mut Vec<entry<i64>>,
}
-impl<'a,'b> visit::Visitor for EncodeVisitor<'a,'b> {
+impl<'a, 'b, 'v> Visitor<'v> for EncodeVisitor<'a, 'b> {
fn visit_expr(&mut self, ex: &Expr) {
visit::walk_expr(self, ex);
my_visit_expr(ex);
rbml_w: &'a mut Encoder<'b>,
}
- impl<'a, 'b> Visitor for StructFieldVisitor<'a, 'b> {
+ impl<'a, 'b, 'v> Visitor<'v> for StructFieldVisitor<'a, 'b> {
fn visit_struct_field(&mut self, field: &ast::StructField) {
self.rbml_w.start_tag(tag_struct_field);
self.rbml_w.wr_tagged_u32(tag_struct_field_id, field.node.id);
rbml_w: &'a mut Encoder<'c>,
}
-impl<'a, 'b, 'c, 'tcx> Visitor for ImplVisitor<'a, 'b, 'c, 'tcx> {
+impl<'a, 'b, 'c, 'tcx, 'v> Visitor<'v> for ImplVisitor<'a, 'b, 'c, 'tcx> {
fn visit_item(&mut self, item: &Item) {
match item.node {
ItemImpl(_, Some(ref trait_ref), _, _) => {
bccx: &'a BorrowckCtxt<'a, 'tcx>
}
-impl<'a, 'tcx> Visitor for StaticInitializerCtxt<'a, 'tcx> {
+impl<'a, 'tcx, 'v> Visitor<'v> for StaticInitializerCtxt<'a, 'tcx> {
fn visit_expr(&mut self, ex: &Expr) {
match ex.node {
ast::ExprAddrOf(mutbl, ref base) => {
pub type LoanDataFlow<'a, 'tcx> = DataFlowContext<'a, 'tcx, LoanDataFlowOperator>;
-impl<'a, 'tcx> Visitor for BorrowckCtxt<'a, 'tcx> {
- fn visit_fn(&mut self, fk: &FnKind, fd: &FnDecl,
- b: &Block, s: Span, n: NodeId) {
+impl<'a, 'tcx, 'v> Visitor<'v> for BorrowckCtxt<'a, 'tcx> {
+ fn visit_fn(&mut self, fk: FnKind<'v>, fd: &'v FnDecl,
+ b: &'v Block, s: Span, n: NodeId) {
borrowck_fn(self, fk, fd, b, s, n);
}
}
fn borrowck_fn(this: &mut BorrowckCtxt,
- fk: &FnKind,
+ fk: FnKind,
decl: &ast::FnDecl,
body: &ast::Block,
sp: Span,
}
fn build_borrowck_dataflow_data<'a, 'tcx>(this: &mut BorrowckCtxt<'a, 'tcx>,
- fk: &FnKind,
+ fk: FnKind,
decl: &ast::FnDecl,
cfg: &cfg::CFG,
body: &ast::Block,
let p = input.fn_parts;
let dataflow_data = build_borrowck_dataflow_data(&mut bccx,
- &p.kind,
+ p.kind,
&*p.decl,
input.cfg,
&*p.body,
}
}
-impl<'a, 'tcx> Visitor for CheckCrateVisitor<'a, 'tcx> {
+impl<'a, 'tcx, 'v> Visitor<'v> for CheckCrateVisitor<'a, 'tcx> {
fn visit_item(&mut self, i: &Item) {
check_item(self, i);
}
visitor.visit_item(it);
}
-impl<'a> Visitor for CheckItemRecursionVisitor<'a> {
+impl<'a, 'v> Visitor<'v> for CheckItemRecursionVisitor<'a> {
fn visit_item(&mut self, it: &Item) {
if self.idstack.iter().any(|x| x == &(it.id)) {
self.sess.span_fatal(self.root_it.span, "recursive constant");
visit::walk_crate(&mut CheckLoopVisitor { sess: sess, cx: Normal }, krate)
}
-impl<'a> Visitor for CheckLoopVisitor<'a> {
+impl<'a, 'v> Visitor<'v> for CheckLoopVisitor<'a> {
fn visit_item(&mut self, i: &ast::Item) {
self.with_context(Normal, |v| visit::walk_item(v, i));
}
LeaveOutWitness
}
-impl<'a, 'tcx> Visitor for MatchCheckCtxt<'a, 'tcx> {
+impl<'a, 'tcx, 'v> Visitor<'v> for MatchCheckCtxt<'a, 'tcx> {
fn visit_expr(&mut self, ex: &Expr) {
check_expr(self, ex);
}
fn visit_local(&mut self, l: &Local) {
check_local(self, l);
}
- fn visit_fn(&mut self, fk: &FnKind, fd: &FnDecl, b: &Block, s: Span, _: NodeId) {
+ fn visit_fn(&mut self, fk: FnKind<'v>, fd: &'v FnDecl,
+ b: &'v Block, s: Span, _: NodeId) {
check_fn(self, fk, fd, b, s);
}
}
}
fn check_fn(cx: &mut MatchCheckCtxt,
- kind: &FnKind,
+ kind: FnKind,
decl: &FnDecl,
body: &Block,
sp: Span) {
bindings_allowed: bool
}
-impl<'a, 'b, 'tcx> Visitor for AtBindingPatternVisitor<'a, 'b, 'tcx> {
+impl<'a, 'b, 'tcx, 'v> Visitor<'v> for AtBindingPatternVisitor<'a, 'b, 'tcx> {
fn visit_pat(&mut self, pat: &Pat) {
if !self.bindings_allowed && pat_is_binding(&self.cx.tcx.def_map, pat) {
self.cx.tcx.sess.span_err(pat.span,
tcx: &'a ty::ctxt<'tcx>
}
-impl<'a, 'tcx> visit::Visitor for RvalueContext<'a, 'tcx> {
+impl<'a, 'tcx, 'v> visit::Visitor<'v> for RvalueContext<'a, 'tcx> {
fn visit_fn(&mut self,
- _: &visit::FnKind,
- fd: &ast::FnDecl,
- b: &ast::Block,
+ _: visit::FnKind<'v>,
+ fd: &'v ast::FnDecl,
+ b: &'v ast::Block,
_: Span,
_: ast::NodeId) {
let mut euv = euv::ExprUseVisitor::new(self, self.tcx);
}
}
-impl<'a, 'tcx> Visitor for CheckStaticVisitor<'a, 'tcx> {
+impl<'a, 'tcx, 'v> Visitor<'v> for CheckStaticVisitor<'a, 'tcx> {
fn visit_item(&mut self, i: &ast::Item) {
debug!("visit_item(item={})", pprust::item_to_string(i));
match i.node {
}
-impl<'a, 'tcx> Visitor for ConstEvalVisitor<'a, 'tcx> {
+impl<'a, 'tcx, 'v> Visitor<'v> for ConstEvalVisitor<'a, 'tcx> {
fn visit_ty(&mut self, t: &Ty) {
match t.node {
TyFixedLengthVec(_, expr) => {
}
let mut formals = Formals { entry: entry, index: index };
visit::walk_fn_decl(&mut formals, decl);
- impl<'a> visit::Visitor for Formals<'a> {
+ impl<'a, 'v> visit::Visitor<'v> for Formals<'a> {
fn visit_pat(&mut self, p: &ast::Pat) {
self.index.insert(p.id, self.entry);
visit::walk_pat(self, p)
}
}
-impl<'a, 'tcx> Visitor for MarkSymbolVisitor<'a, 'tcx> {
+impl<'a, 'tcx, 'v> Visitor<'v> for MarkSymbolVisitor<'a, 'tcx> {
fn visit_struct_def(&mut self, def: &ast::StructDef, _: ast::Ident,
_: &ast::Generics, _: ast::NodeId) {
worklist: Vec<ast::NodeId> ,
}
-impl Visitor for LifeSeeder {
+impl<'v> Visitor<'v> for LifeSeeder {
fn visit_item(&mut self, item: &ast::Item) {
if has_allow_dead_code_or_lang_attr(item.attrs.as_slice()) {
self.worklist.push(item.id);
visit::walk_item(self, item);
}
- fn visit_fn(&mut self, fk: &visit::FnKind,
- _: &ast::FnDecl, block: &ast::Block,
+ fn visit_fn(&mut self, fk: visit::FnKind<'v>,
+ _: &'v ast::FnDecl, block: &'v ast::Block,
_: codemap::Span, id: ast::NodeId) {
// Check for method here because methods are not ast::Item
- match *fk {
+ match fk {
visit::FkMethod(_, _, method) => {
if has_allow_dead_code_or_lang_attr(method.attrs.as_slice()) {
self.worklist.push(id);
}
}
-impl<'a, 'tcx> Visitor for DeadVisitor<'a, 'tcx> {
+impl<'a, 'tcx, 'v> Visitor<'v> for DeadVisitor<'a, 'tcx> {
fn visit_item(&mut self, item: &ast::Item) {
let ctor_id = get_struct_ctor_id(item);
if !self.symbol_is_live(item.id, ctor_id) && should_warn(item) {
visit::walk_foreign_item(self, fi);
}
- fn visit_fn(&mut self, fk: &visit::FnKind,
- _: &ast::FnDecl, block: &ast::Block,
+ fn visit_fn(&mut self, fk: visit::FnKind<'v>,
+ _: &'v ast::FnDecl, block: &'v ast::Block,
span: codemap::Span, id: ast::NodeId) {
// Have to warn method here because methods are not ast::Item
- match *fk {
- visit::FkMethod(..) => {
- let ident = visit::name_of_fn(fk);
+ match fk {
+ visit::FkMethod(name, _, _) => {
if !self.symbol_is_live(id, None) {
- self.warn_dead_code(id, span, ident);
+ self.warn_dead_code(id, span, name);
}
}
_ => ()
}
}
-impl<'a, 'tcx> Visitor for EffectCheckVisitor<'a, 'tcx> {
- fn visit_fn(&mut self, fn_kind: &visit::FnKind, fn_decl: &ast::FnDecl,
- block: &ast::Block, span: Span, _: ast::NodeId) {
+impl<'a, 'tcx, 'v> Visitor<'v> for EffectCheckVisitor<'a, 'tcx> {
+ fn visit_fn(&mut self, fn_kind: visit::FnKind<'v>, fn_decl: &'v ast::FnDecl,
+ block: &'v ast::Block, span: Span, _: ast::NodeId) {
- let (is_item_fn, is_unsafe_fn) = match *fn_kind {
+ let (is_item_fn, is_unsafe_fn) = match fn_kind {
visit::FkItemFn(_, _, fn_style, _) =>
(true, fn_style == ast::UnsafeFn),
visit::FkMethod(_, _, method) =>
non_main_fns: Vec<(NodeId, Span)> ,
}
-impl<'a> Visitor for EntryContext<'a> {
+impl<'a, 'v> Visitor<'v> for EntryContext<'a> {
fn visit_item(&mut self, item: &Item) {
find_item(item, self);
}
depth: uint
}
-impl<'a> Visitor for CollectFreevarsVisitor<'a> {
+impl<'a, 'v> Visitor<'v> for CollectFreevarsVisitor<'a> {
fn visit_item(&mut self, _: &ast::Item) {
// ignore_item
}
capture_mode_map: CaptureModeMap,
}
-impl<'a> Visitor for AnnotateFreevarsVisitor<'a> {
- fn visit_fn(&mut self, fk: &visit::FnKind, fd: &ast::FnDecl,
- blk: &ast::Block, s: Span, nid: ast::NodeId) {
+impl<'a, 'v> Visitor<'v> for AnnotateFreevarsVisitor<'a> {
+ fn visit_fn(&mut self, fk: visit::FnKind<'v>, fd: &'v ast::FnDecl,
+ blk: &'v ast::Block, s: Span, nid: ast::NodeId) {
let vars = collect_freevars(self.def_map,
blk,
&mut self.capture_mode_map);
}
}
-impl<'a, 'tcx> Visitor for IntrinsicCheckingVisitor<'a, 'tcx> {
+impl<'a, 'tcx, 'v> Visitor<'v> for IntrinsicCheckingVisitor<'a, 'tcx> {
fn visit_expr(&mut self, expr: &ast::Expr) {
match expr.node {
ast::ExprPath(..) => {
parameter_environments: Vec<ParameterEnvironment>,
}
-impl<'a, 'tcx> Visitor for Context<'a, 'tcx> {
+impl<'a, 'tcx, 'v> Visitor<'v> for Context<'a, 'tcx> {
fn visit_expr(&mut self, ex: &Expr) {
check_expr(self, ex);
}
- fn visit_fn(&mut self, fk: &visit::FnKind, fd: &FnDecl,
- b: &Block, s: Span, n: NodeId) {
+ fn visit_fn(&mut self, fk: visit::FnKind, fd: &'v FnDecl,
+ b: &'v Block, s: Span, n: NodeId) {
check_fn(self, fk, fd, b, s, n);
}
// to the copy/move kind bounds. Then recursively check the function body.
fn check_fn(
cx: &mut Context,
- fk: &visit::FnKind,
+ fk: visit::FnKind,
decl: &FnDecl,
body: &Block,
sp: Span,
});
});
- match *fk {
+ match fk {
visit::FkFnBlock(..) => {
let ty = ty::node_id_to_type(cx.tcx, fn_id);
check_bounds_on_structs_or_enums_in_type_if_possible(cx, sp, ty);
item_refs: HashMap<&'static str, uint>,
}
-impl<'a> Visitor for LanguageItemCollector<'a> {
+impl<'a, 'v> Visitor<'v> for LanguageItemCollector<'a> {
fn visit_item(&mut self, item: &ast::Item) {
match extract(item.attrs.as_slice()) {
Some(value) => {
}
}
-impl<'a, 'tcx> Visitor for IrMaps<'a, 'tcx> {
- fn visit_fn(&mut self, fk: &FnKind, fd: &FnDecl, b: &Block, s: Span, n: NodeId) {
+impl<'a, 'tcx, 'v> Visitor<'v> for IrMaps<'a, 'tcx> {
+ fn visit_fn(&mut self, fk: FnKind<'v>, fd: &'v FnDecl,
+ b: &'v Block, s: Span, n: NodeId) {
visit_fn(self, fk, fd, b, s, n);
}
fn visit_local(&mut self, l: &Local) { visit_local(self, l); }
}
}
-impl<'a, 'tcx> Visitor for Liveness<'a, 'tcx> {
- fn visit_fn(&mut self, fk: &FnKind, fd: &FnDecl, b: &Block, s: Span, n: NodeId) {
+impl<'a, 'tcx, 'v> Visitor<'v> for Liveness<'a, 'tcx> {
+ fn visit_fn(&mut self, fk: FnKind<'v>, fd: &'v FnDecl, b: &'v Block, s: Span, n: NodeId) {
check_fn(self, fk, fd, b, s, n);
}
fn visit_local(&mut self, l: &Local) {
}
fn visit_fn(ir: &mut IrMaps,
- fk: &FnKind,
+ fk: FnKind,
decl: &FnDecl,
body: &Block,
sp: Span,
}
fn check_fn(_v: &Liveness,
- _fk: &FnKind,
+ _fk: FnKind,
_decl: &FnDecl,
_body: &Block,
_sp: Span,
fn check_ret(&self,
id: NodeId,
sp: Span,
- _fk: &FnKind,
+ _fk: FnKind,
entry_ln: LiveNode,
body: &Block) {
if self.live_on_entry(entry_ln, self.s.no_ret_var).is_some() {
curparent: ast::NodeId,
}
-impl Visitor for ParentVisitor {
+impl<'v> Visitor<'v> for ParentVisitor {
fn visit_item(&mut self, item: &ast::Item) {
self.parents.insert(item.id, self.curparent);
visit::walk_foreign_item(self, a);
}
- fn visit_fn(&mut self, a: &visit::FnKind, b: &ast::FnDecl,
- c: &ast::Block, d: Span, id: ast::NodeId) {
+ fn visit_fn(&mut self, a: visit::FnKind<'v>, b: &'v ast::FnDecl,
+ c: &'v ast::Block, d: Span, id: ast::NodeId) {
// We already took care of some trait methods above, otherwise things
// like impl methods and pub trait methods are parented to the
// containing module, not the containing trait.
}
fn visit_struct_def(&mut self, s: &ast::StructDef, _: ast::Ident,
- _: &ast::Generics, n: ast::NodeId) {
+ _: &'v ast::Generics, n: ast::NodeId) {
// Struct constructors are parented to their struct definitions because
// they essentially are the struct definitions.
match s.ctor_id {
}
}
-impl<'a, 'tcx> Visitor for EmbargoVisitor<'a, 'tcx> {
+impl<'a, 'tcx, 'v> Visitor<'v> for EmbargoVisitor<'a, 'tcx> {
fn visit_item(&mut self, item: &ast::Item) {
let orig_all_pub = self.prev_public;
self.prev_public = orig_all_pub && item.vis == ast::Public;
}
}
-impl<'a, 'tcx> Visitor for PrivacyVisitor<'a, 'tcx> {
+impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> {
fn visit_item(&mut self, item: &ast::Item) {
let orig_curitem = replace(&mut self.curitem, item.id);
visit::walk_item(self, item);
in_fn: bool,
}
-impl<'a, 'tcx> Visitor for SanePrivacyVisitor<'a, 'tcx> {
+impl<'a, 'tcx, 'v> Visitor<'v> for SanePrivacyVisitor<'a, 'tcx> {
fn visit_item(&mut self, item: &ast::Item) {
if self.in_fn {
self.check_all_inherited(item);
self.in_fn = orig_in_fn;
}
- fn visit_fn(&mut self, fk: &visit::FnKind, fd: &ast::FnDecl,
- b: &ast::Block, s: Span, _: ast::NodeId) {
+ fn visit_fn(&mut self, fk: visit::FnKind<'v>, fd: &'v ast::FnDecl,
+ b: &'v ast::Block, s: Span, _: ast::NodeId) {
// This catches both functions and methods
let orig_in_fn = replace(&mut self.in_fn, true);
visit::walk_fn(self, fk, fd, b, s);
}
}
-impl<'a, 'b, 'tcx> Visitor for CheckTypeForPrivatenessVisitor<'a, 'b, 'tcx> {
+impl<'a, 'b, 'tcx, 'v> Visitor<'v> for CheckTypeForPrivatenessVisitor<'a, 'b, 'tcx> {
fn visit_ty(&mut self, ty: &ast::Ty) {
match ty.node {
ast::TyPath(_, _, path_id) => {
fn visit_expr(&mut self, _: &ast::Expr) {}
}
-impl<'a, 'tcx> Visitor for VisiblePrivateTypesVisitor<'a, 'tcx> {
+impl<'a, 'tcx, 'v> Visitor<'v> for VisiblePrivateTypesVisitor<'a, 'tcx> {
fn visit_item(&mut self, item: &ast::Item) {
match item.node {
// contents of a private mod can be reexported, so we need
}
}
- fn visit_fn(&mut self, fk: &visit::FnKind, fd: &ast::FnDecl,
- b: &ast::Block, s: Span, id: ast::NodeId) {
+ fn visit_fn(&mut self, fk: visit::FnKind<'v>, fd: &'v ast::FnDecl,
+ b: &'v ast::Block, s: Span, id: ast::NodeId) {
// needs special handling for methods.
if self.exported_items.contains(&id) {
visit::walk_fn(self, fk, fd, b, s);
any_library: bool,
}
-impl<'a, 'tcx> Visitor for ReachableContext<'a, 'tcx> {
+impl<'a, 'tcx, 'v> Visitor<'v> for ReachableContext<'a, 'tcx> {
fn visit_expr(&mut self, expr: &ast::Expr) {
}
fn resolve_fn(visitor: &mut RegionResolutionVisitor,
- fk: &FnKind,
+ fk: FnKind,
decl: &ast::FnDecl,
body: &ast::Block,
sp: Span,
// The body of the fn itself is either a root scope (top-level fn)
// or it continues with the inherited scope (closures).
- match *fk {
+ match fk {
visit::FkItemFn(..) | visit::FkMethod(..) => {
visitor.cx = Context { parent: None, var_parent: None };
visitor.visit_block(body);
}
}
-impl<'a> Visitor for RegionResolutionVisitor<'a> {
+impl<'a, 'v> Visitor<'v> for RegionResolutionVisitor<'a> {
fn visit_block(&mut self, b: &Block) {
resolve_block(self, b);
resolve_item(self, i);
}
- fn visit_fn(&mut self, fk: &FnKind, fd: &FnDecl,
- b: &Block, s: Span, n: NodeId) {
+ fn visit_fn(&mut self, fk: FnKind<'v>, fd: &'v FnDecl,
+ b: &'v Block, s: Span, n: NodeId) {
resolve_fn(self, fk, fd, b, s, n);
}
fn visit_arm(&mut self, a: &Arm) {
ImportNameDefinition(Def, LastPrivate) //< The name identifies an import.
}
-impl<'a> Visitor for Resolver<'a> {
+impl<'a, 'v> Visitor<'v> for Resolver<'a> {
fn visit_item(&mut self, item: &Item) {
self.resolve_item(item);
}
parent: ReducedGraphParent
}
-impl<'a, 'b> Visitor for BuildReducedGraphVisitor<'a, 'b> {
+impl<'a, 'b, 'v> Visitor<'v> for BuildReducedGraphVisitor<'a, 'b> {
fn visit_item(&mut self, item: &Item) {
let p = self.resolver.build_reduced_graph_for_item(item, self.parent.clone());
resolver: &'a mut Resolver<'b>
}
-impl<'a, 'b> Visitor for UnusedImportCheckVisitor<'a, 'b> {
+impl<'a, 'b, 'v> Visitor<'v> for UnusedImportCheckVisitor<'a, 'b> {
fn visit_view_item(&mut self, vi: &ViewItem) {
self.resolver.check_for_item_unused_imports(vi);
visit::walk_view_item(self, vi);
// pat_idents are variants
self.check_consistent_bindings(arm);
- visit::walk_expr_opt(self, arm.guard);
+ visit::walk_expr_opt(self, &arm.guard);
self.resolve_expr(&*arm.body);
self.value_ribs.borrow_mut().pop();
named_region_map
}
-impl<'a> Visitor for LifetimeContext<'a> {
+impl<'a, 'v> Visitor<'v> for LifetimeContext<'a> {
fn visit_item(&mut self, item: &ast::Item) {
let lifetimes = match item.node {
ast::ItemFn(..) | // fn lifetimes get added in visit_fn below
});
}
- fn visit_fn(&mut self, fk: &visit::FnKind, fd: &ast::FnDecl,
- b: &ast::Block, s: Span, n: ast::NodeId) {
- match *fk {
+ fn visit_fn(&mut self, fk: visit::FnKind<'v>, fd: &'v ast::FnDecl,
+ b: &'v ast::Block, s: Span, n: ast::NodeId) {
+ match fk {
visit::FkItemFn(_, generics, _, _) |
visit::FkMethod(_, generics, _) => {
self.visit_fn_decl(n, generics, |v| visit::walk_fn(v, fk, fd, b, s))
late_bound: &'a mut Vec<ast::Name>,
}
- impl<'a> Visitor for FreeLifetimeCollector<'a> {
+ impl<'a, 'v> Visitor<'v> for FreeLifetimeCollector<'a> {
fn visit_lifetime_ref(&mut self, lifetime_ref: &ast::Lifetime) {
shuffle(self.early_bound, self.late_bound,
lifetime_ref.name);
ex: &ast::Expr,
path: &ast::Path,
fields: &Vec<ast::Field>,
- base: Option<Gc<ast::Expr>>) {
+ base:
&Option<Gc<ast::Expr>>) {
if generated_code(path.span) {
return
}
}
}
-impl<'l, 'tcx> Visitor for DxrVisitor<'l, 'tcx> {
- fn visit_item(&mut self, item:&ast::Item) {
+impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> {
+ fn visit_item(&mut self, item: &ast::Item) {
if generated_code(item.span) {
return
}
// We don't actually index functions here, that is done in visit_item/ItemFn.
// Here we just visit methods.
fn visit_fn(&mut self,
- fk: &visit::FnKind,
- fd: &ast::FnDecl,
- b: &ast::Block,
+ fk: visit::FnKind<'v>,
+ fd: &'v ast::FnDecl,
+ b: &'v ast::Block,
s: Span,
_: NodeId) {
if generated_code(s) {
return;
}
- match *fk {
+ match fk {
visit::FkMethod(_, _, method) => self.process_method(method),
_ => visit::walk_fn(self, fk, fd, b, s),
}
}
}
- fn visit_view_item(&mut self, i:&ast::ViewItem) {
+ fn visit_view_item(&mut self, i: &ast::ViewItem) {
if generated_code(i.span) {
return
}
visit::walk_expr(self, ex);
},
ast::ExprPath(ref path) => self.process_path(ex, path),
- ast::ExprStruct(ref path, ref fields, base) =>
+ ast::ExprStruct(ref path, ref fields, ref base) =>
self.process_struct_lit(ex, path, fields, base),
ast::ExprMethodCall(_, _, ref args) => self.process_method_call(ex, args),
ast::ExprField(sub_ex, ident, _) => {
}
}
self.collected_paths.clear();
- visit::walk_expr_opt(self, arm.guard);
+ visit::walk_expr_opt(self, &arm.guard);
self.visit_expr(&*arm.body);
}
- fn visit_stmt(&mut self, s:&ast::Stmt) {
+ fn visit_stmt(&mut self, s: &ast::Stmt) {
if generated_code(s.span) {
return
}
visit::walk_stmt(self, s)
}
- fn visit_local(&mut self, l:&ast::Local) {
+ fn visit_local(&mut self, l: &ast::Local) {
if generated_code(l.span) {
return
}
// Just walk the initialiser and type (don't want to walk the pattern again).
self.visit_ty(&*l.ty);
- visit::walk_expr_opt(self, l.init);
+ visit::walk_expr_opt(self, &l.init);
}
}
}
}
-impl Visitor for Annotator {
+impl<'v> Visitor<'v> for Annotator {
fn visit_item(&mut self, i: &Item) {
self.annotate(i.id, &i.attrs, |v| visit::walk_item(v, i));
}
- fn visit_fn(&mut self, fk: &FnKind, fd: &FnDecl, b: &Block, s: Span, _: NodeId) {
- match *fk {
+ fn visit_fn(&mut self, fk: FnKind<'v>, fd: &'v FnDecl,
+ b: &'v Block, s: Span, _: NodeId) {
+ match fk {
FkMethod(_, _, meth) => {
self.annotate(meth.id, &meth.attrs, |v| visit::walk_fn(v, fk, fd, b, s));
}
self.annotate(id, attrs, |v| visit::walk_trait_item(v, t));
}
- fn visit_variant(&mut self, var: &Variant, g: &Generics) {
+ fn visit_variant(&mut self, var: &Variant, g: &'v Generics) {
self.annotate(var.node.id, &var.node.attrs, |v| visit::walk_variant(v, var, g))
}
}
}
-impl Visitor for CheckForNestedReturnsVisitor {
+impl<'v> Visitor<'v> for CheckForNestedReturnsVisitor {
fn visit_expr(&mut self, e: &ast::Expr) {
match e.node {
ast::ExprRet(..) => {
let mut explicit = CheckForNestedReturnsVisitor::explicit();
let mut implicit = CheckForNestedReturnsVisitor::implicit();
visit::walk_item(&mut explicit, &*i);
- visit::walk_expr_opt(&mut implicit, blk.expr);
+ visit::walk_expr_opt(&mut implicit, &blk.expr);
explicit.found || implicit.found
}
_ => tcx.sess.bug("unexpected item variant in has_nested_returns")
let mut explicit = CheckForNestedReturnsVisitor::explicit();
let mut implicit = CheckForNestedReturnsVisitor::implicit();
visit::walk_method_helper(&mut explicit, &*m);
- visit::walk_expr_opt(&mut implicit, blk.expr);
+ visit::walk_expr_opt(&mut implicit, &blk.expr);
explicit.found || implicit.found
}
ast::MethMac(_) => tcx.sess.bug("unexpanded macro")
let mut explicit = CheckForNestedReturnsVisitor::explicit();
let mut implicit = CheckForNestedReturnsVisitor::implicit();
visit::walk_method_helper(&mut explicit, &**m);
- visit::walk_expr_opt(&mut implicit, blk.expr);
+ visit::walk_expr_opt(&mut implicit, &blk.expr);
explicit.found || implicit.found
}
ast::MethMac(_) => tcx.sess.bug("unexpanded macro")
let mut explicit = CheckForNestedReturnsVisitor::explicit();
let mut implicit = CheckForNestedReturnsVisitor::implicit();
visit::walk_expr(&mut explicit, &*e);
- visit::walk_expr_opt(&mut implicit, blk.expr);
+ visit::walk_expr_opt(&mut implicit, &blk.expr);
explicit.found || implicit.found
}
_ => tcx.sess.bug("unexpected expr variant in has_nested_returns")
pub ccx: &'a CrateContext<'a, 'tcx>,
}
-impl<'a, 'tcx> Visitor for TransItemVisitor<'a, 'tcx> {
+impl<'a, 'tcx, 'v> Visitor<'v> for TransItemVisitor<'a, 'tcx> {
fn visit_item(&mut self, i: &ast::Item) {
trans_item(self.ccx, i);
}
struct CheckItemTypesVisitor<'a, 'tcx: 'a> { ccx: &'a CrateCtxt<'a, 'tcx> }
struct CheckTypeWellFormedVisitor<'a, 'tcx: 'a> { ccx: &'a CrateCtxt<'a, 'tcx> }
-impl<'a, 'tcx> Visitor for CheckTypeWellFormedVisitor<'a, 'tcx> {
+impl<'a, 'tcx, 'v> Visitor<'v> for CheckTypeWellFormedVisitor<'a, 'tcx> {
fn visit_item(&mut self, i: &ast::Item) {
check_type_well_formed(self.ccx, i);
visit::walk_item(self, i);
}
-impl<'a, 'tcx> Visitor for CheckItemTypesVisitor<'a, 'tcx> {
+impl<'a, 'tcx, 'v> Visitor<'v> for CheckItemTypesVisitor<'a, 'tcx> {
fn visit_item(&mut self, i: &ast::Item) {
check_item(self.ccx, i);
visit::walk_item(self, i);
ccx: &'a CrateCtxt<'a, 'tcx>
}
-impl<'a, 'tcx> Visitor for CheckItemSizedTypesVisitor<'a, 'tcx> {
+impl<'a, 'tcx, 'v> Visitor<'v> for CheckItemSizedTypesVisitor<'a, 'tcx> {
fn visit_item(&mut self, i: &ast::Item) {
check_item_sized(self.ccx, i);
visit::walk_item(self, i);
}
}
-impl<'a, 'tcx> Visitor for GatherLocalsVisitor<'a, 'tcx> {
+impl<'a, 'tcx, 'v> Visitor<'v> for GatherLocalsVisitor<'a, 'tcx> {
// Add explicitly-declared locals.
fn visit_local(&mut self, local: &ast::Local) {
let o_ty = match local.ty.node {
}
// Don't descend into fns and items
- fn visit_fn(&mut self, _: &visit::FnKind, _: &ast::FnDecl,
- _: &ast::Block, _: Span, _: ast::NodeId) { }
+ fn visit_fn(&mut self, _: visit::FnKind<'v>, _: &'v ast::FnDecl,
+ _: &'v ast::Block, _: Span, _: ast::NodeId) { }
fn visit_item(&mut self, _: &ast::Item) { }
}
}
}
-impl<'a, 'tcx> Visitor for Rcx<'a, 'tcx> {
+impl<'a, 'tcx, 'v> Visitor<'v> for Rcx<'a, 'tcx> {
// (..) FIXME(#3238) should use visit_pat, not visit_arm/visit_local,
// However, right now we run into an issue whereby some free
// regions are not properly related if they appear within the
// hierarchy, and in particular the relationships between free
// regions, until regionck, as described in #3238.
- fn visit_fn(&mut self, _fk: &visit::FnKind, _fd: &ast::FnDecl,
- b: &ast::Block, _s: Span, id: ast::NodeId) {
+ fn visit_fn(&mut self, _fk: visit::FnKind<'v>, _fd: &'v ast::FnDecl,
+ b: &'v ast::Block, _s: Span, id: ast::NodeId) {
self.visit_fn_body(id, b)
}
false)
}
-impl<'a, 'b, 'tcx> visit::Visitor for &'a FnCtxt<'b, 'tcx> {
+impl<'a, 'b, 'tcx, 'v> Visitor<'v> for &'a FnCtxt<'b, 'tcx> {
fn visit_expr(&mut self, ex: &ast::Expr) {
early_resolve_expr(ex, *self, false);
visit::walk_expr(self, ex);
// below. In general, a function is made into a `visitor` if it must
// traffic in node-ids or update tables in the type context etc.
-impl<'cx, 'tcx> Visitor for WritebackCx<'cx, 'tcx> {
+impl<'cx, 'tcx, 'v> Visitor<'v> for WritebackCx<'cx, 'tcx> {
fn visit_item(&mut self, _: &ast::Item) {
// Ignore items
}
visit::walk_stmt(self, s);
}
- fn visit_expr(&mut self, e:&ast::Expr) {
+ fn visit_expr(&mut self, e: &ast::Expr) {
if self.fcx.writeback_errors.get() {
return;
}
cc: &'a CoherenceChecker<'a, 'tcx>
}
-impl<'a, 'tcx> visit::Visitor for CoherenceCheckVisitor<'a, 'tcx> {
+impl<'a, 'tcx, 'v> visit::Visitor<'v> for CoherenceCheckVisitor<'a, 'tcx> {
fn visit_item(&mut self, item: &Item) {
//debug!("(checking coherence) item '{}'", token::get_ident(item.ident));
cc: &'a CoherenceChecker<'a, 'tcx>
}
-impl<'a, 'tcx> visit::Visitor for PrivilegedScopeVisitor<'a, 'tcx> {
+impl<'a, 'tcx, 'v> visit::Visitor<'v> for PrivilegedScopeVisitor<'a, 'tcx> {
fn visit_item(&mut self, item: &Item) {
match item.node {
ccx: &'a CrateCtxt<'a, 'tcx>
}
-impl<'a, 'tcx> visit::Visitor for CollectTraitDefVisitor<'a, 'tcx> {
+impl<'a, 'tcx, 'v> visit::Visitor<'v> for CollectTraitDefVisitor<'a, 'tcx> {
fn visit_item(&mut self, i: &ast::Item) {
match i.node {
ast::ItemTrait(..) => {
ccx: &'a CrateCtxt<'a, 'tcx>
}
-impl<'a, 'tcx> visit::Visitor for CollectItemTypesVisitor<'a, 'tcx> {
+impl<'a, 'tcx, 'v> visit::Visitor<'v> for CollectItemTypesVisitor<'a, 'tcx> {
fn visit_item(&mut self, i: &ast::Item) {
convert(self.ccx, i);
visit::walk_item(self, i);
}
}
-impl<'a, 'tcx> Visitor for TermsContext<'a, 'tcx> {
+impl<'a, 'tcx, 'v> Visitor<'v> for TermsContext<'a, 'tcx> {
fn visit_item(&mut self, item: &ast::Item) {
debug!("add_inferreds for item {}", item.repr(self.tcx));
constraint_cx
}
-impl<'a, 'tcx> Visitor for ConstraintContext<'a, 'tcx> {
+impl<'a, 'tcx, 'v> Visitor<'v> for ConstraintContext<'a, 'tcx> {
fn visit_item(&mut self, item: &ast::Item) {
let did = ast_util::local_def(item.id);
let tcx = self.terms_cx.tcx;
}
}
-impl<'a> Visitor for Context<'a> {
+impl<'a, 'v> Visitor<'v> for Context<'a> {
fn visit_foreign_item(&mut self, i: &ast::ForeignItem) {
match lang_items::extract(i.attrs.as_slice()) {
None => {}
registrars: Vec<(ast::NodeId, Span)> ,
}
-impl Visitor for RegistrarFinder {
+impl<'v> Visitor<'v> for RegistrarFinder {
fn visit_item(&mut self, item: &ast::Item) {
match item.node {
ast::ItemFn(..) => {
}
// note that macros aren't expanded yet, and therefore macros can't add plugins.
-impl<'a> Visitor for PluginLoader<'a> {
+impl<'a, 'v> Visitor<'v> for PluginLoader<'a> {
fn visit_view_item(&mut self, vi: &ast::ViewItem) {
match vi.node {
ast::ViewItemExternCrate(name, _, _) => {
flag: bool,
}
-impl<'a> Visitor for LoopQueryVisitor<'a> {
+impl<'a, 'v> Visitor<'v> for LoopQueryVisitor<'a> {
fn visit_expr(&mut self, e: &ast::Expr) {
self.flag |= (self.p)(&e.node);
match e.node {
flag: bool,
}
-impl<'a> Visitor for BlockQueryVisitor<'a> {
+impl<'a, 'v> Visitor<'v> for BlockQueryVisitor<'a> {
fn visit_expr(&mut self, e: &ast::Expr) {
self.flag |= (self.p)(e);
visit::walk_expr(self, e)
}
fn content<K:InternKey>(k: K) -> token::InternedString { k.get_content() }
- impl<'a> Visitor for StrictVersionHashVisitor<'a> {
+ impl<'a, 'v> Visitor<'v> for StrictVersionHashVisitor<'a> {
fn visit_mac(&mut self, macro: &Mac) {
// macro invocations, namely macro_rules definitions,
SawGenerics.hash(self.st); visit::walk_generics(self, g)
}
- fn visit_fn(&mut self, fk: &FnKind, fd: &FnDecl, b: &Block, s: Span, _: NodeId) {
+ fn visit_fn(&mut self, fk: FnKind<'v>, fd: &'v FnDecl,
+ b: &'v Block, s: Span, _: NodeId) {
SawFn.hash(self.st); visit::walk_fn(self, fk, fd, b, s)
}
}
}
-impl<'a, O: IdVisitingOperation> Visitor for IdVisitor<'a, O> {
+impl<'a, 'v, O: IdVisitingOperation> Visitor<'v> for IdVisitor<'a, O> {
fn visit_mod(&mut self,
module: &Mod,
_: Span,
}
fn visit_fn(&mut self,
- function_kind: &visit::FnKind,
- function_declaration: &FnDecl,
- block: &Block,
+ function_kind: visit::FnKind<'v>,
+ function_declaration: &'v FnDecl,
+ block: &'v Block,
span: Span,
node_id: NodeId) {
if !self.pass_through_items {
- match *function_kind {
+ match function_kind {
visit::FkMethod(..) if self.visited_outermost => return,
visit::FkMethod(..) => self.visited_outermost = true,
_ => {}
self.operation.visit_id(node_id);
- match *function_kind {
+ match function_kind {
visit::FkItemFn(_, generics, _, _) |
visit::FkMethod(_, generics, _) => {
self.visit_generics_helper(generics)
span);
if !self.pass_through_items {
- match *function_kind {
+ match function_kind {
visit::FkMethod(..) => self.visited_outermost = false,
_ => {}
}
visitor.result.get()
}
-pub fn compute_id_range_for_fn_body(fk: &visit::FnKind,
+pub fn compute_id_range_for_fn_body(fk: visit::FnKind,
decl: &FnDecl,
body: &Block,
sp: Span,
callback: |&ast::ViewItem|: 'a -> bool,
}
-impl<'a> Visitor for EachViewItemData<'a> {
+impl<'a, 'v> Visitor<'v> for EachViewItemData<'a> {
fn visit_view_item(&mut self, view_item: &ast::ViewItem) {
let _ = (self.callback)(view_item);
}
ident_accumulator: Vec<ast::Ident>
}
-impl Visitor for PatIdentFinder {
+impl<'v> Visitor<'v> for PatIdentFinder {
fn visit_pat(&mut self, pattern: &ast::Pat) {
match *pattern {
ast::Pat { id: _, node: ast::PatIdent(_, ref path1, ref inner), span: _ } => {
sess: &'a parse::ParseSess
}
-impl<'a> Visitor for MacroExterminator<'a> {
+impl<'a, 'v> Visitor<'v> for MacroExterminator<'a> {
fn visit_mac(&mut self, macro: &ast::Mac) {
self.sess.span_diagnostic.span_bug(macro.span,
"macro exterminator: expected AST \
path_accumulator: Vec<ast::Path> ,
}
- impl Visitor for PathExprFinderContext {
+ impl<'v> Visitor<'v> for PathExprFinderContext {
fn visit_expr(&mut self, expr: &ast::Expr) {
match expr.node {
ast::ExprPath(ref p) => {
ident_accumulator: Vec<ast::Ident>
}
- impl Visitor for IdentFinder {
+ impl<'v> Visitor<'v> for IdentFinder {
fn visit_ident(&mut self, _: codemap::Span, id: ast::Ident){
self.ident_accumulator.push(id);
}
use abi::Abi;
use ast::*;
use ast;
-use ast_util;
use codemap::Span;
-use parse;
use owned_slice::OwnedSlice;
use std::gc::Gc;
FkFnBlock,
}
-pub fn name_of_fn(fk: &FnKind) -> Ident {
- match *fk {
- FkItemFn(name, _, _, _) | FkMethod(name, _, _) => name,
- FkFnBlock(..) => parse::token::special_idents::invalid
- }
-}
-
-pub fn generics_of_fn(fk: &FnKind) -> Generics {
- match *fk {
- FkItemFn(_, generics, _, _) |
- FkMethod(_, generics, _) => {
- (*generics).clone()
- }
- FkFnBlock(..) => ast_util::empty_generics(),
- }
-}
-
/// Each method of the Visitor trait is a hook to be potentially
/// overridden. Each method's default implementation recursively visits
/// the substructure of the input via the corresponding `walk` method;
/// explicitly, you need to override each method. (And you also need
/// to monitor future changes to `Visitor` in case a new method with a
/// new default implementation gets introduced.)
-pub trait Visitor {
+pub trait Visitor<'v> {
fn visit_ident(&mut self, _sp: Span, _ident: Ident) {
/*! Visit the idents */
}
- fn visit_mod(&mut self, m: &Mod, _s: Span, _n: NodeId) { walk_mod(self, m) }
- fn visit_view_item(&mut self, i: &ViewItem) { walk_view_item(self, i) }
- fn visit_foreign_item(&mut self, i: &ForeignItem) { walk_foreign_item(self, i) }
- fn visit_item(&mut self, i: &Item) { walk_item(self, i) }
- fn visit_local(&mut self, l: &Local) { walk_local(self, l) }
- fn visit_block(&mut self, b: &Block) { walk_block(self, b) }
- fn visit_stmt(&mut self, s: &Stmt) { walk_stmt(self, s) }
- fn visit_arm(&mut self, a: &Arm) { walk_arm(self, a) }
- fn visit_pat(&mut self, p: &Pat) { walk_pat(self, p) }
- fn visit_decl(&mut self, d: &Decl) { walk_decl(self, d) }
- fn visit_expr(&mut self, ex: &Expr) { walk_expr(self, ex) }
- fn visit_expr_post(&mut self, _ex: &Expr) { }
- fn visit_ty(&mut self, t: &Ty) { walk_ty(self, t) }
- fn visit_generics(&mut self, g: &Generics) { walk_generics(self, g) }
- fn visit_fn(&mut self, fk: &FnKind, fd: &FnDecl, b: &Block, s: Span, _: NodeId) {
+ fn visit_mod(&mut self, m: &'v Mod, _s: Span, _n: NodeId) { walk_mod(self, m) }
+ fn visit_view_item(&mut self, i: &'v ViewItem) { walk_view_item(self, i) }
+ fn visit_foreign_item(&mut self, i: &'v ForeignItem) { walk_foreign_item(self, i) }
+ fn visit_item(&mut self, i: &'v Item) { walk_item(self, i) }
+ fn visit_local(&mut self, l: &'v Local) { walk_local(self, l) }
+ fn visit_block(&mut self, b: &'v Block) { walk_block(self, b) }
+ fn visit_stmt(&mut self, s: &'v Stmt) { walk_stmt(self, s) }
+ fn visit_arm(&mut self, a: &'v Arm) { walk_arm(self, a) }
+ fn visit_pat(&mut self, p: &'v Pat) { walk_pat(self, p) }
+ fn visit_decl(&mut self, d: &'v Decl) { walk_decl(self, d) }
+ fn visit_expr(&mut self, ex: &'v Expr) { walk_expr(self, ex) }
+ fn visit_expr_post(&mut self, _ex: &'v Expr) { }
+ fn visit_ty(&mut self, t: &'v Ty) { walk_ty(self, t) }
+ fn visit_generics(&mut self, g: &'v Generics) { walk_generics(self, g) }
+ fn visit_fn(&mut self, fk: FnKind<'v>, fd: &'v FnDecl, b: &'v Block, s: Span, _: NodeId) {
walk_fn(self, fk, fd, b, s)
}
- fn visit_ty_method(&mut self, t: &TypeMethod) { walk_ty_method(self, t) }
- fn visit_trait_item(&mut self, t: &TraitItem) { walk_trait_item(self, t) }
- fn visit_struct_def(&mut self, s: &StructDef, _: Ident, _: &Generics, _: NodeId) {
+ fn visit_ty_method(&mut self, t: &'v TypeMethod) { walk_ty_method(self, t) }
+ fn visit_trait_item(&mut self, t: &'v TraitItem) { walk_trait_item(self, t) }
+ fn visit_struct_def(&mut self, s: &'v StructDef, _: Ident, _: &'v Generics, _: NodeId) {
walk_struct_def(self, s)
}
- fn visit_struct_field(&mut self, s: &StructField) { walk_struct_field(self, s) }
- fn visit_variant(&mut self, v: &Variant, g: &Generics) { walk_variant(self, v, g) }
+ fn visit_struct_field(&mut self, s: &'v StructField) { walk_struct_field(self, s) }
+ fn visit_variant(&mut self, v: &'v Variant, g: &'v Generics) { walk_variant(self, v, g) }
fn visit_opt_lifetime_ref(&mut self,
_span: Span,
- opt_lifetime: &Option<Lifetime>) {
+ opt_lifetime: &'v Option<Lifetime>) {
/*!
* Visits an optional reference to a lifetime. The `span` is
* the span of some surrounding reference should opt_lifetime
None => ()
}
}
- fn visit_lifetime_ref(&mut self, _lifetime: &Lifetime) {
+ fn visit_lifetime_ref(&mut self, _lifetime: &'v Lifetime) {
/*! Visits a reference to a lifetime */
}
- fn visit_lifetime_decl(&mut self, _lifetime: &LifetimeDef) {
+ fn visit_lifetime_decl(&mut self, _lifetime: &'v LifetimeDef) {
/*! Visits a declaration of a lifetime */
}
- fn visit_explicit_self(&mut self, es: &ExplicitSelf) {
+ fn visit_explicit_self(&mut self, es: &'v ExplicitSelf) {
walk_explicit_self(self, es)
}
- fn visit_mac(&mut self, _macro: &Mac) {
+ fn visit_mac(&mut self, _macro: &'v Mac) {
fail!("visit_mac disabled by default");
// NB: see note about macros above.
// if you really want a visitor that
// definition in your trait impl:
// visit::walk_mac(self, _macro)
}
- fn visit_path(&mut self, path: &Path, _id: ast::NodeId) {
+ fn visit_path(&mut self, path: &'v Path, _id: ast::NodeId) {
walk_path(self, path)
}
- fn visit_attribute(&mut self, _attr: &Attribute) {}
+ fn visit_attribute(&mut self, _attr: &'v Attribute) {}
}
-pub fn walk_inlined_item<V: Visitor>(visitor: &mut V, item: &ast::InlinedItem) {
+pub fn walk_inlined_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v InlinedItem) {
match *item {
- IIItem(i) => visitor.visit_item(&*i),
- IIForeign(i) => visitor.visit_foreign_item(&*i),
- IITraitItem(_, iti) => {
- match iti {
- ProvidedInlinedTraitItem(m) => {
- walk_method_helper(visitor, &*m)
+ IIItem(ref i) => visitor.visit_item(&**i),
+ IIForeign(ref i) => visitor.visit_foreign_item(&**i),
+ IITraitItem(_, ref iti) => {
+ match *iti {
+ ProvidedInlinedTraitItem(ref m) => {
+ walk_method_helper(visitor, &**m)
}
- RequiredInlinedTraitItem(m) => {
- walk_method_helper(visitor, &*m)
+ RequiredInlinedTraitItem(ref m) => {
+ walk_method_helper(visitor, &**m)
}
}
}
}
-pub fn walk_crate<V: Visitor>(visitor: &mut V, krate: &Crate) {
+pub fn walk_crate<'v, V: Visitor<'v>>(visitor: &mut V, krate: &'v Crate) {
visitor.visit_mod(&krate.module, krate.span, CRATE_NODE_ID);
for attr in krate.attrs.iter() {
visitor.visit_attribute(attr);
}
}
-pub fn walk_mod<V: Visitor>(visitor: &mut V, module: &Mod) {
+pub fn walk_mod<'v, V: Visitor<'v>>(visitor: &mut V, module: &'v Mod) {
for view_item in module.view_items.iter() {
visitor.visit_view_item(view_item)
}
}
}
-pub fn walk_view_item<V: Visitor>(visitor: &mut V, vi: &ViewItem) {
+pub fn walk_view_item<'v, V: Visitor<'v>>(visitor: &mut V, vi: &'v ViewItem) {
match vi.node {
ViewItemExternCrate(name, _, _) => {
visitor.visit_ident(vi.span, name)
}
}
-pub fn walk_local<V: Visitor>(visitor: &mut V, local: &Local) {
+pub fn walk_local<'v, V: Visitor<'v>>(visitor: &mut V, local: &'v Local) {
visitor.visit_pat(&*local.pat);
visitor.visit_ty(&*local.ty);
- match local.init {
- None => {}
- Some(initializer) => visitor.visit_expr(&*initializer),
- }
+ walk_expr_opt(visitor, &local.init);
}
-pub fn walk_explicit_self<V: Visitor>(visitor: &mut V, explicit_self: &ExplicitSelf) {
+pub fn walk_explicit_self<'v, V: Visitor<'v>>(visitor: &mut V,
+ explicit_self: &'v ExplicitSelf) {
match explicit_self.node {
SelfStatic | SelfValue(_) => {},
SelfRegion(ref lifetime, _, _) => {
/// Like with walk_method_helper this doesn't correspond to a method
/// in Visitor, and so it gets a _helper suffix.
-pub fn walk_trait_ref_helper<V: Visitor>(visitor: &mut V, trait_ref: &TraitRef) {
+pub fn walk_trait_ref_helper<'v, V: Visitor<'v>>(visitor: &mut V, trait_ref: &'v TraitRef) {
visitor.visit_path(&trait_ref.path, trait_ref.ref_id)
}
-pub fn walk_item<V: Visitor>(visitor: &mut V, item: &Item) {
+pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) {
visitor.visit_ident(item.span, item.ident);
match item.node {
ItemStatic(ref typ, _, ref expr) => {
visitor.visit_ty(&**typ);
visitor.visit_expr(&**expr);
}
- ItemFn(declaration, fn_style, abi, ref generics, body) => {
- visitor.visit_fn(&FkItemFn(item.ident, generics, fn_style, abi),
- &*declaration,
- &*body,
+ ItemFn(ref declaration, fn_style, abi, ref generics, ref body) => {
+ visitor.visit_fn(FkItemFn(item.ident, generics, fn_style, abi),
+ &**declaration,
+ &**body,
item.span,
item.id)
}
}
ItemImpl(ref type_parameters,
ref trait_reference,
- typ,
+ ref typ,
ref impl_items) => {
visitor.visit_generics(type_parameters);
match *trait_reference {
trait_reference),
None => ()
}
- visitor.visit_ty(&*typ);
+ visitor.visit_ty(&**typ);
for impl_item in impl_items.iter() {
match *impl_item {
- MethodImplItem(method) => {
- walk_method_helper(visitor, &*method)
+ MethodImplItem(ref method) => {
+ walk_method_helper(visitor, &**method)
}
}
}
}
}
-pub fn walk_enum_def<V: Visitor>(visitor: &mut V,
- enum_definition: &EnumDef,
- generics: &Generics) {
- for &variant in enum_definition.variants.iter() {
- visitor.visit_variant(&*variant, generics);
+pub fn walk_enum_def<'v, V: Visitor<'v>>(visitor: &mut V,
+ enum_definition: &'v EnumDef,
+ generics: &'v Generics) {
+ for variant in enum_definition.variants.iter() {
+ visitor.visit_variant(&**variant, generics);
}
}
-pub fn walk_variant<V: Visitor>(visitor: &mut V,
- variant: &Variant,
- generics: &Generics) {
+pub fn walk_variant<'v, V: Visitor<'v>>(visitor: &mut V,
+ variant: &'v Variant,
+ generics: &'v Generics) {
visitor.visit_ident(variant.span, variant.node.name);
match variant.node.kind {
}
}
-pub fn skip_ty<V: Visitor>(_: &mut V, _: &Ty) {
+pub fn skip_ty<'v, V: Visitor<'v>>(_: &mut V, _: &'v Ty) {
// Empty!
}
-pub fn walk_ty<V: Visitor>(visitor: &mut V, typ: &Ty) {
+pub fn walk_ty<'v, V: Visitor<'v>>(visitor: &mut V, typ: &'v Ty) {
match typ.node {
- TyUniq(ty) | TyVec(ty) | TyBox(ty) | TyParen(ty) => {
- visitor.visit_ty(&*ty)
+ TyUniq(ref ty) | TyVec(ref ty) | TyBox(ref ty) | TyParen(ref ty) => {
+ visitor.visit_ty(&**ty)
}
TyPtr(ref mutable_type) => {
visitor.visit_ty(&*mutable_type.ty)
visitor.visit_ty(&*mutable_type.ty)
}
TyTup(ref tuple_element_types) => {
- for &tuple_element_type in tuple_element_types.iter() {
- visitor.visit_ty(&*tuple_element_type)
+ for tuple_element_type in tuple_element_types.iter() {
+ visitor.visit_ty(&**tuple_element_type)
}
}
TyClosure(ref function_declaration) => {
}
}
-fn walk_lifetime_decls<V: Visitor>(visitor: &mut V, lifetimes: &Vec<LifetimeDef>) {
+fn walk_lifetime_decls<'v, V: Visitor<'v>>(visitor: &mut V,
+ lifetimes: &'v Vec<LifetimeDef>) {
for l in lifetimes.iter() {
visitor.visit_lifetime_decl(l);
}
}
-pub fn walk_path<V: Visitor>(visitor: &mut V, path: &Path) {
+pub fn walk_path<'v, V: Visitor<'v>>(visitor: &mut V, path: &'v Path) {
for segment in path.segments.iter() {
visitor.visit_ident(path.span, segment.identifier);
}
}
-pub fn walk_pat<V: Visitor>(visitor: &mut V, pattern: &Pat) {
+pub fn walk_pat<'v, V: Visitor<'v>>(visitor: &mut V, pattern: &'v Pat) {
match pattern.node {
PatEnum(ref path, ref children) => {
visitor.visit_path(path, pattern.id);
}
}
-pub fn walk_foreign_item<V: Visitor>(visitor: &mut V, foreign_item: &ForeignItem) {
+pub fn walk_foreign_item<'v, V: Visitor<'v>>(visitor: &mut V,
+ foreign_item: &'v ForeignItem) {
visitor.visit_ident(foreign_item.span, foreign_item.ident);
match foreign_item.node {
}
}
-pub fn walk_ty_param_bounds<V: Visitor>(visitor: &mut V,
- bounds: &OwnedSlice<TyParamBound>) {
+pub fn walk_ty_param_bounds<'v, V: Visitor<'v>>(visitor: &mut V,
+ bounds: &'v OwnedSlice<TyParamBound>) {
for bound in bounds.iter() {
match *bound {
TraitTyParamBound(ref typ) => {
}
}
-pub fn walk_generics<V: Visitor>(visitor: &mut V, generics: &Generics) {
+pub fn walk_generics<'v, V: Visitor<'v>>(visitor: &mut V, generics: &'v Generics) {
for type_parameter in generics.ty_params.iter() {
walk_ty_param_bounds(visitor, &type_parameter.bounds);
match type_parameter.default {
}
}
-pub fn walk_fn_decl<V: Visitor>(visitor: &mut V, function_declaration: &FnDecl) {
+pub fn walk_fn_decl<'v, V: Visitor<'v>>(visitor: &mut V, function_declaration: &'v FnDecl) {
for argument in function_declaration.inputs.iter() {
visitor.visit_pat(&*argument.pat);
visitor.visit_ty(&*argument.ty)
// visit_fn() and check for FkMethod(). I named this visit_method_helper()
// because it is not a default impl of any method, though I doubt that really
// clarifies anything. - Niko
-pub fn walk_method_helper<V: Visitor>(visitor: &mut V, method: &Method) {
+pub fn walk_method_helper<'v, V: Visitor<'v>>(visitor: &mut V, method: &'v Method) {
match method.node {
- MethDecl(ident, ref generics, _, _, _, decl, body, _) => {
+ MethDecl(ident, ref generics, _, _, _, ref decl, ref body, _) => {
visitor.visit_ident(method.span, ident);
- visitor.visit_fn(&FkMethod(ident, generics, method),
- &*decl,
- &*body,
+ visitor.visit_fn(FkMethod(ident, generics, method),
+ &**decl,
+ &**body,
method.span,
method.id);
for attr in method.attrs.iter() {
}
}
-pub fn walk_fn<V: Visitor>(visitor: &mut V,
- function_kind: &FnKind,
- function_declaration: &FnDecl,
- function_body: &Block,
- _span: Span) {
+pub fn walk_fn<'v, V: Visitor<'v>>(visitor: &mut V,
+ function_kind: FnKind<'v>,
+ function_declaration: &'v FnDecl,
+ function_body: &'v Block,
+ _span: Span) {
walk_fn_decl(visitor, function_declaration);
- match *function_kind {
+ match function_kind {
FkItemFn(_, generics, _, _) => {
visitor.visit_generics(generics);
}
visitor.visit_block(function_body)
}
-pub fn walk_ty_method<V: Visitor>(visitor: &mut V, method_type: &TypeMethod) {
+pub fn walk_ty_method<'v, V: Visitor<'v>>(visitor: &mut V, method_type: &'v TypeMethod) {
visitor.visit_ident(method_type.span, method_type.ident);
visitor.visit_explicit_self(&method_type.explicit_self);
for argument_type in method_type.decl.inputs.iter() {
}
}
-pub fn walk_trait_item<V: Visitor>(visitor: &mut V, trait_method: &TraitItem) {
+pub fn walk_trait_item<'v, V: Visitor<'v>>(visitor: &mut V, trait_method: &'v TraitItem) {
match *trait_method {
RequiredMethod(ref method_type) => {
visitor.visit_ty_method(method_type)
}
}
-pub fn walk_struct_def<V: Visitor>(visitor: &mut V,
- struct_definition: &StructDef) {
+pub fn walk_struct_def<'v, V: Visitor<'v>>(visitor: &mut V,
+ struct_definition: &'v StructDef) {
match struct_definition.super_struct {
Some(ref t) => visitor.visit_ty(&**t),
None => {},
}
}
-pub fn walk_struct_field<V: Visitor>(visitor: &mut V,
- struct_field: &StructField) {
+pub fn walk_struct_field<'v, V: Visitor<'v>>(visitor: &mut V,
+ struct_field: &'v StructField) {
match struct_field.node.kind {
NamedField(name, _) => {
visitor.visit_ident(struct_field.span, name)
}
}
-pub fn walk_block<V: Visitor>(visitor: &mut V, block: &Block) {
+pub fn walk_block<'v, V: Visitor<'v>>(visitor: &mut V, block: &'v Block) {
for view_item in block.view_items.iter() {
visitor.visit_view_item(view_item)
}
for statement in block.stmts.iter() {
visitor.visit_stmt(&**statement)
}
- walk_expr_opt(visitor, block.expr)
+ walk_expr_opt(visitor, &block.expr)
}
-pub fn walk_stmt<V: Visitor>(visitor: &mut V, statement: &Stmt) {
+pub fn walk_stmt<'v, V: Visitor<'v>>(visitor: &mut V, statement: &'v Stmt) {
match statement.node {
StmtDecl(ref declaration, _) => visitor.visit_decl(&**declaration),
StmtExpr(ref expression, _) | StmtSemi(ref expression, _) => {
}
}
-pub fn walk_decl<V: Visitor>(visitor: &mut V, declaration: &Decl) {
+pub fn walk_decl<'v, V: Visitor<'v>>(visitor: &mut V, declaration: &'v Decl) {
match declaration.node {
DeclLocal(ref local) => visitor.visit_local(&**local),
DeclItem(ref item) => visitor.visit_item(&**item),
}
}
-pub fn walk_expr_opt<V: Visitor>(visitor: &mut V,
- optional_expression: Option<Gc<Expr>>) {
- match optional_expression {
+pub fn walk_expr_opt<'v, V: Visitor<'v>>(visitor: &mut V,
+ optional_expression: &'v Option<Gc<Expr>>) {
+ match *optional_expression {
None => {}
Some(ref expression) => visitor.visit_expr(&**expression),
}
}
-pub fn walk_exprs<V: Visitor>(visitor: &mut V, expressions: &[Gc<Expr>]) {
+pub fn walk_exprs<'v, V: Visitor<'v>>(visitor: &mut V, expressions: &'v [Gc<Expr>]) {
for expression in expressions.iter() {
visitor.visit_expr(&**expression)
}
}
-pub fn walk_mac<V: Visitor>(_: &mut V, _: &Mac) {
+pub fn walk_mac<'v, V: Visitor<'v>>(_: &mut V, _: &'v Mac) {
// Empty!
}
-pub fn walk_expr<V: Visitor>(visitor: &mut V, expression: &Expr) {
+pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr) {
match expression.node {
ExprBox(ref place, ref subexpression) => {
visitor.visit_expr(&**place);
visitor.visit_expr(&**element);
visitor.visit_expr(&**count)
}
- ExprStruct(ref path, ref fields, optional_base) => {
+ ExprStruct(ref path, ref fields, ref optional_base) => {
visitor.visit_path(path, expression.id);
for field in fields.iter() {
visitor.visit_expr(&*field.expr)
visitor.visit_expr(&**subexpression);
visitor.visit_ty(&**typ)
}
- ExprIf(ref head_expression, ref if_block, optional_else) => {
+ ExprIf(ref head_expression, ref if_block, ref optional_else) => {
visitor.visit_expr(&**head_expression);
visitor.visit_block(&**if_block);
walk_expr_opt(visitor, optional_else)
}
}
ExprFnBlock(_, ref function_declaration, ref body) => {
- visitor.visit_fn(&FkFnBlock,
+ visitor.visit_fn(FkFnBlock,
&**function_declaration,
&**body,
expression.span,
expression.id)
}
ExprUnboxedFn(_, _, ref function_declaration, ref body) => {
- visitor.visit_fn(&FkFnBlock,
+ visitor.visit_fn(FkFnBlock,
&**function_declaration,
&**body,
expression.span,
expression.id)
}
ExprProc(ref function_declaration, ref body) => {
- visitor.visit_fn(&FkFnBlock,
+ visitor.visit_fn(FkFnBlock,
&**function_declaration,
&**body,
expression.span,
visitor.visit_path(path, expression.id)
}
ExprBreak(_) | ExprAgain(_) => {}
- ExprRet(optional_expression) => {
+ ExprRet(ref optional_expression) => {
walk_expr_opt(visitor, optional_expression)
}
ExprMac(ref macro) => visitor.visit_mac(macro),
visitor.visit_expr(&**subexpression)
}
ExprInlineAsm(ref ia) => {
- for &(_, ref input) in ia.inputs.iter() {
+ for input in ia.inputs.iter() {
+ let (_, ref input) = *input;
visitor.visit_expr(&**input)
}
- for &(_, ref output, _) in ia.outputs.iter() {
+ for output in ia.outputs.iter() {
+ let (_, ref output, _) = *output;
visitor.visit_expr(&**output)
}
}
visitor.visit_expr_post(expression)
}
-pub fn walk_arm<V: Visitor>(visitor: &mut V, arm: &Arm) {
+pub fn walk_arm<'v, V: Visitor<'v>>(visitor: &mut V, arm: &'v Arm) {
for pattern in arm.pats.iter() {
visitor.visit_pat(&**pattern)
}
- walk_expr_opt(visitor, arm.guard);
+ walk_expr_opt(visitor, &arm.guard);
visitor.visit_expr(&*arm.body);
for attr in arm.attrs.iter() {
visitor.visit_attribute(attr);
projects / rust.git / commitdiff