From 7ef6ff06696c29dc956b17b9a5c57713b0c8e0cb Mon Sep 17 00:00:00 2001 From: Eduard Burtescu Date: Wed, 10 Sep 2014 01:54:36 +0300 Subject: [PATCH] Track the visited AST's lifetime throughout Visitor. --- src/librustc/front/feature_gate.rs | 12 +- src/librustc/front/show_span.rs | 2 +- src/librustc/lint/builtin.rs | 14 +- src/librustc/lint/context.rs | 8 +- src/librustc/lint/mod.rs | 2 +- src/librustc/metadata/creader.rs | 2 +- src/librustc/metadata/encoder.rs | 6 +- .../middle/borrowck/gather_loans/mod.rs | 2 +- src/librustc/middle/borrowck/mod.rs | 12 +- src/librustc/middle/check_const.rs | 4 +- src/librustc/middle/check_loop.rs | 2 +- src/librustc/middle/check_match.rs | 9 +- src/librustc/middle/check_rvalues.rs | 8 +- src/librustc/middle/check_static.rs | 2 +- src/librustc/middle/const_eval.rs | 2 +- src/librustc/middle/dataflow.rs | 2 +- src/librustc/middle/dead.rs | 23 +- src/librustc/middle/effect.rs | 8 +- src/librustc/middle/entry.rs | 2 +- src/librustc/middle/freevars.rs | 8 +- src/librustc/middle/intrinsicck.rs | 2 +- src/librustc/middle/kind.rs | 10 +- src/librustc/middle/lang_items.rs | 2 +- src/librustc/middle/liveness.rs | 15 +- src/librustc/middle/privacy.rs | 26 +- src/librustc/middle/reachable.rs | 2 +- src/librustc/middle/region.rs | 10 +- src/librustc/middle/resolve.rs | 8 +- src/librustc/middle/resolve_lifetime.rs | 10 +- src/librustc/middle/save/mod.rs | 26 +- src/librustc/middle/stability.rs | 9 +- src/librustc/middle/trans/base.rs | 12 +- src/librustc/middle/typeck/check/mod.rs | 12 +- src/librustc/middle/typeck/check/regionck.rs | 6 +- src/librustc/middle/typeck/check/vtable.rs | 2 +- src/librustc/middle/typeck/check/writeback.rs | 4 +- src/librustc/middle/typeck/coherence.rs | 4 +- src/librustc/middle/typeck/collect.rs | 4 +- src/librustc/middle/typeck/variance.rs | 4 +- src/librustc/middle/weak_lang_items.rs | 2 +- src/librustc/plugin/build.rs | 2 +- src/librustc/plugin/load.rs | 2 +- src/librustc/util/common.rs | 4 +- src/librustc_back/svh.rs | 5 +- src/libsyntax/ast_util.rs | 18 +- src/libsyntax/ext/expand.rs | 8 +- src/libsyntax/visit.rs | 251 ++++++++---------- 47 files changed, 288 insertions(+), 302 deletions(-) diff --git a/src/librustc/front/feature_gate.rs b/src/librustc/front/feature_gate.rs index b3653b5dcffb..7750ddc91e1a 100644 --- a/src/librustc/front/feature_gate.rs +++ b/src/librustc/front/feature_gate.rs @@ -143,7 +143,7 @@ impl<'a> Context<'a> { } } -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, @@ -386,13 +386,13 @@ impl<'a> Visitor for Context<'a> { } 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") diff --git a/src/librustc/front/show_span.rs b/src/librustc/front/show_span.rs index 2ccba474bfe5..df0b02261b14 100644 --- a/src/librustc/front/show_span.rs +++ b/src/librustc/front/show_span.rs @@ -23,7 +23,7 @@ struct ShowSpanVisitor<'a> { 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); diff --git a/src/librustc/lint/builtin.rs b/src/librustc/lint/builtin.rs index b1ea8b5d8181..bfc73a8b6658 100644 --- a/src/librustc/lint/builtin.rs +++ b/src/librustc/lint/builtin.rs @@ -366,7 +366,7 @@ impl<'a, 'tcx> CTypesVisitor<'a, 'tcx> { } } -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), @@ -500,7 +500,7 @@ struct RawPtrDerivingVisitor<'a, 'tcx: 'a> { 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 { @@ -908,9 +908,9 @@ impl LintPass for NonSnakeCase { } 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), @@ -1218,7 +1218,7 @@ impl LintPass for UnusedMut { } 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]); @@ -1387,9 +1387,9 @@ impl LintPass for MissingDoc { } 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; } diff --git a/src/librustc/lint/context.rs b/src/librustc/lint/context.rs index bd7f6296d92f..bb2deca160e5 100644 --- a/src/librustc/lint/context.rs +++ b/src/librustc/lint/context.rs @@ -492,7 +492,7 @@ impl<'a, 'tcx> AstConv<'tcx> for Context<'a, 'tcx>{ } } -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); @@ -531,9 +531,9 @@ impl<'a, 'tcx> Visitor for Context<'a, 'tcx> { 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); diff --git a/src/librustc/lint/mod.rs b/src/librustc/lint/mod.rs index dbdda96dcb84..9a3edbbb70bb 100644 --- a/src/librustc/lint/mod.rs +++ b/src/librustc/lint/mod.rs @@ -139,7 +139,7 @@ pub trait LintPass { 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, diff --git a/src/librustc/metadata/creader.rs b/src/librustc/metadata/creader.rs index 7b8c7a0ab472..8c17c16afee1 100644 --- a/src/librustc/metadata/creader.rs +++ b/src/librustc/metadata/creader.rs @@ -54,7 +54,7 @@ pub fn read_crates(sess: &Session, 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); diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index 25e80b26a933..209a09dbfafd 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -1473,7 +1473,7 @@ struct EncodeVisitor<'a,'b:'a> { index: &'a mut Vec>, } -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); @@ -1775,7 +1775,7 @@ fn encode_struct_field_attrs(rbml_w: &mut Encoder, krate: &Crate) { 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); @@ -1798,7 +1798,7 @@ struct ImplVisitor<'a, 'b:'a, 'c:'a, 'tcx:'b> { 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), _, _) => { diff --git a/src/librustc/middle/borrowck/gather_loans/mod.rs b/src/librustc/middle/borrowck/gather_loans/mod.rs index 5910aba81161..cd003432ef22 100644 --- a/src/librustc/middle/borrowck/gather_loans/mod.rs +++ b/src/librustc/middle/borrowck/gather_loans/mod.rs @@ -471,7 +471,7 @@ struct StaticInitializerCtxt<'a, 'tcx: 'a> { 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) => { diff --git a/src/librustc/middle/borrowck/mod.rs b/src/librustc/middle/borrowck/mod.rs index 0c61f96ada60..acc2f47a0fe6 100644 --- a/src/librustc/middle/borrowck/mod.rs +++ b/src/librustc/middle/borrowck/mod.rs @@ -60,9 +60,9 @@ pub struct LoanDataFlowOperator; 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); } @@ -127,7 +127,7 @@ pub struct AnalysisData<'a, 'tcx: 'a> { } fn borrowck_fn(this: &mut BorrowckCtxt, - fk: &FnKind, + fk: FnKind, decl: &ast::FnDecl, body: &ast::Block, sp: Span, @@ -146,7 +146,7 @@ fn borrowck_fn(this: &mut BorrowckCtxt, } 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, @@ -217,7 +217,7 @@ pub fn build_borrowck_dataflow_data_for_fn<'a, 'tcx>( let p = input.fn_parts; let dataflow_data = build_borrowck_dataflow_data(&mut bccx, - &p.kind, + p.kind, &*p.decl, input.cfg, &*p.body, diff --git a/src/librustc/middle/check_const.rs b/src/librustc/middle/check_const.rs index abe5118734b8..c0160b72784c 100644 --- a/src/librustc/middle/check_const.rs +++ b/src/librustc/middle/check_const.rs @@ -41,7 +41,7 @@ impl<'a, 'tcx> CheckCrateVisitor<'a, 'tcx> { } } -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); } @@ -238,7 +238,7 @@ pub fn check_item_recursion<'a>(sess: &'a Session, 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"); diff --git a/src/librustc/middle/check_loop.rs b/src/librustc/middle/check_loop.rs index 67c62262dcdf..3abf49bdfb29 100644 --- a/src/librustc/middle/check_loop.rs +++ b/src/librustc/middle/check_loop.rs @@ -29,7 +29,7 @@ pub fn check_crate(sess: &Session, krate: &ast::Crate) { 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)); } diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs index b0a5e7f11924..6e8f6530075e 100644 --- a/src/librustc/middle/check_match.rs +++ b/src/librustc/middle/check_match.rs @@ -119,14 +119,15 @@ enum WitnessPreference { 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); } } @@ -868,7 +869,7 @@ fn check_local(cx: &mut MatchCheckCtxt, loc: &Local) { } fn check_fn(cx: &mut MatchCheckCtxt, - kind: &FnKind, + kind: FnKind, decl: &FnDecl, body: &Block, sp: Span) { @@ -1022,7 +1023,7 @@ struct AtBindingPatternVisitor<'a, 'b:'a, 'tcx:'b> { 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, diff --git a/src/librustc/middle/check_rvalues.rs b/src/librustc/middle/check_rvalues.rs index 07ccfb0b27be..21023986e1c2 100644 --- a/src/librustc/middle/check_rvalues.rs +++ b/src/librustc/middle/check_rvalues.rs @@ -30,11 +30,11 @@ struct RvalueContext<'a, 'tcx: 'a> { 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); diff --git a/src/librustc/middle/check_static.rs b/src/librustc/middle/check_static.rs index c4a74abed69b..46896b8811f0 100644 --- a/src/librustc/middle/check_static.rs +++ b/src/librustc/middle/check_static.rs @@ -69,7 +69,7 @@ impl<'a, 'tcx> CheckStaticVisitor<'a, '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 { diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs index 375678b2a610..23ab6f4585b1 100644 --- a/src/librustc/middle/const_eval.rs +++ b/src/librustc/middle/const_eval.rs @@ -268,7 +268,7 @@ impl<'a, 'tcx> ConstEvalVisitor<'a, 'tcx> { } -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) => { diff --git a/src/librustc/middle/dataflow.rs b/src/librustc/middle/dataflow.rs index c26acedb1b8c..d39b560c6d53 100644 --- a/src/librustc/middle/dataflow.rs +++ b/src/librustc/middle/dataflow.rs @@ -173,7 +173,7 @@ fn build_nodeid_to_index(decl: Option<&ast::FnDecl>, } 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) diff --git a/src/librustc/middle/dead.rs b/src/librustc/middle/dead.rs index 4684e64ed2b9..68bcd950f9ce 100644 --- a/src/librustc/middle/dead.rs +++ b/src/librustc/middle/dead.rs @@ -237,7 +237,7 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> { } } -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) { @@ -329,7 +329,7 @@ struct LifeSeeder { worklist: Vec , } -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); @@ -349,11 +349,11 @@ impl Visitor for LifeSeeder { 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); @@ -499,7 +499,7 @@ impl<'a, 'tcx> DeadVisitor<'a, 'tcx> { } } -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) { @@ -515,15 +515,14 @@ impl<'a, 'tcx> Visitor for DeadVisitor<'a, 'tcx> { 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); } } _ => () diff --git a/src/librustc/middle/effect.rs b/src/librustc/middle/effect.rs index 7ce7a112bdc2..db9eb90b6ec0 100644 --- a/src/librustc/middle/effect.rs +++ b/src/librustc/middle/effect.rs @@ -86,11 +86,11 @@ impl<'a, 'tcx> EffectCheckVisitor<'a, 'tcx> { } } -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) => diff --git a/src/librustc/middle/entry.rs b/src/librustc/middle/entry.rs index cfa96619f197..2b96eb717ea8 100644 --- a/src/librustc/middle/entry.rs +++ b/src/librustc/middle/entry.rs @@ -41,7 +41,7 @@ struct EntryContext<'a> { 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); } diff --git a/src/librustc/middle/freevars.rs b/src/librustc/middle/freevars.rs index 7f3691ba5a9d..5b7c72208ea7 100644 --- a/src/librustc/middle/freevars.rs +++ b/src/librustc/middle/freevars.rs @@ -53,7 +53,7 @@ struct CollectFreevarsVisitor<'a> { 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 } @@ -144,9 +144,9 @@ struct AnnotateFreevarsVisitor<'a> { 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); diff --git a/src/librustc/middle/intrinsicck.rs b/src/librustc/middle/intrinsicck.rs index 89e1fb8ae97f..76ade1a7504e 100644 --- a/src/librustc/middle/intrinsicck.rs +++ b/src/librustc/middle/intrinsicck.rs @@ -116,7 +116,7 @@ impl<'a, 'tcx> IntrinsicCheckingVisitor<'a, 'tcx> { } } -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(..) => { diff --git a/src/librustc/middle/kind.rs b/src/librustc/middle/kind.rs index 88da3abcac36..1e398ce210b5 100644 --- a/src/librustc/middle/kind.rs +++ b/src/librustc/middle/kind.rs @@ -56,13 +56,13 @@ pub struct Context<'a, 'tcx: 'a> { parameter_environments: Vec, } -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); } @@ -341,7 +341,7 @@ fn with_appropriate_checker(cx: &Context, // 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, @@ -356,7 +356,7 @@ fn check_fn( }); }); - 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); diff --git a/src/librustc/middle/lang_items.rs b/src/librustc/middle/lang_items.rs index 6b0eec451a48..24782240f06c 100644 --- a/src/librustc/middle/lang_items.rs +++ b/src/librustc/middle/lang_items.rs @@ -115,7 +115,7 @@ struct LanguageItemCollector<'a> { 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) => { diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs index 121a6d80d018..18f3de82280e 100644 --- a/src/librustc/middle/liveness.rs +++ b/src/librustc/middle/liveness.rs @@ -179,8 +179,9 @@ fn live_node_kind_to_string(lnk: LiveNodeKind, cx: &ty::ctxt) -> String { } } -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); } @@ -343,8 +344,8 @@ impl<'a, 'tcx> IrMaps<'a, 'tcx> { } } -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) { @@ -359,7 +360,7 @@ impl<'a, 'tcx> Visitor for Liveness<'a, 'tcx> { } fn visit_fn(ir: &mut IrMaps, - fk: &FnKind, + fk: FnKind, decl: &FnDecl, body: &Block, sp: Span, @@ -1462,7 +1463,7 @@ fn check_expr(this: &mut Liveness, expr: &Expr) { } fn check_fn(_v: &Liveness, - _fk: &FnKind, + _fk: FnKind, _decl: &FnDecl, _body: &Block, _sp: Span, @@ -1474,7 +1475,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { 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() { diff --git a/src/librustc/middle/privacy.rs b/src/librustc/middle/privacy.rs index 458b1dbc210e..da957024b9a2 100644 --- a/src/librustc/middle/privacy.rs +++ b/src/librustc/middle/privacy.rs @@ -57,7 +57,7 @@ struct ParentVisitor { 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); @@ -100,8 +100,8 @@ impl Visitor for ParentVisitor { 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. @@ -112,7 +112,7 @@ impl Visitor for ParentVisitor { } 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 { @@ -180,7 +180,7 @@ impl<'a, 'tcx> EmbargoVisitor<'a, 'tcx> { } } -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; @@ -802,7 +802,7 @@ impl<'a, 'tcx> PrivacyVisitor<'a, 'tcx> { } } -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); @@ -1036,7 +1036,7 @@ struct SanePrivacyVisitor<'a, 'tcx: 'a> { 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); @@ -1053,8 +1053,8 @@ impl<'a, 'tcx> Visitor for SanePrivacyVisitor<'a, 'tcx> { 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); @@ -1264,7 +1264,7 @@ impl<'a, 'tcx> VisiblePrivateTypesVisitor<'a, 'tcx> { } } -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) => { @@ -1287,7 +1287,7 @@ impl<'a, 'b, 'tcx> Visitor for CheckTypeForPrivatenessVisitor<'a, 'b, 'tcx> { 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 @@ -1434,8 +1434,8 @@ impl<'a, 'tcx> Visitor for VisiblePrivateTypesVisitor<'a, 'tcx> { } } - 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); diff --git a/src/librustc/middle/reachable.rs b/src/librustc/middle/reachable.rs index c27c7b3096a6..d7cf25e7410e 100644 --- a/src/librustc/middle/reachable.rs +++ b/src/librustc/middle/reachable.rs @@ -101,7 +101,7 @@ struct ReachableContext<'a, 'tcx: 'a> { 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) { diff --git a/src/librustc/middle/region.rs b/src/librustc/middle/region.rs index 7de8aab371ef..45107d26f2f8 100644 --- a/src/librustc/middle/region.rs +++ b/src/librustc/middle/region.rs @@ -796,7 +796,7 @@ fn resolve_item(visitor: &mut RegionResolutionVisitor, item: &ast::Item) { } fn resolve_fn(visitor: &mut RegionResolutionVisitor, - fk: &FnKind, + fk: FnKind, decl: &ast::FnDecl, body: &ast::Block, sp: Span, @@ -821,7 +821,7 @@ fn resolve_fn(visitor: &mut RegionResolutionVisitor, // 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); @@ -841,7 +841,7 @@ fn resolve_fn(visitor: &mut RegionResolutionVisitor, } } -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); @@ -851,8 +851,8 @@ impl<'a> Visitor for RegionResolutionVisitor<'a> { 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) { diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs index b79db38e1296..ca0000eb5051 100644 --- a/src/librustc/middle/resolve.rs +++ b/src/librustc/middle/resolve.rs @@ -185,7 +185,7 @@ enum NameDefinition { 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); } @@ -906,7 +906,7 @@ struct BuildReducedGraphVisitor<'a, 'b:'a> { 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()); @@ -945,7 +945,7 @@ struct UnusedImportCheckVisitor<'a, 'b:'a> { 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); @@ -4593,7 +4593,7 @@ impl<'a> Resolver<'a> { // 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(); diff --git a/src/librustc/middle/resolve_lifetime.rs b/src/librustc/middle/resolve_lifetime.rs index 628174b0f4e2..22acdca5f9bd 100644 --- a/src/librustc/middle/resolve_lifetime.rs +++ b/src/librustc/middle/resolve_lifetime.rs @@ -84,7 +84,7 @@ pub fn krate(sess: &Session, krate: &ast::Crate) -> NamedRegionMap { 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 @@ -110,9 +110,9 @@ impl<'a> Visitor for LifetimeContext<'a> { }); } - 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)) @@ -450,7 +450,7 @@ fn early_bound_lifetime_names(generics: &ast::Generics) -> Vec { late_bound: &'a mut Vec, } - 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); diff --git a/src/librustc/middle/save/mod.rs b/src/librustc/middle/save/mod.rs index d7be7af3d07f..1d4050c71b18 100644 --- a/src/librustc/middle/save/mod.rs +++ b/src/librustc/middle/save/mod.rs @@ -833,7 +833,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { ex: &ast::Expr, path: &ast::Path, fields: &Vec, - base: Option>) { + base: &Option>) { if generated_code(path.span) { return } @@ -1018,8 +1018,8 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { } } -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 } @@ -1082,16 +1082,16 @@ impl<'l, 'tcx> Visitor for DxrVisitor<'l, 'tcx> { // 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), } @@ -1143,7 +1143,7 @@ impl<'l, 'tcx> Visitor for DxrVisitor<'l, 'tcx> { } } - fn visit_view_item(&mut self, i:&ast::ViewItem) { + fn visit_view_item(&mut self, i: &ast::ViewItem) { if generated_code(i.span) { return } @@ -1275,7 +1275,7 @@ impl<'l, 'tcx> Visitor for DxrVisitor<'l, 'tcx> { 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, _) => { @@ -1410,11 +1410,11 @@ impl<'l, 'tcx> Visitor for DxrVisitor<'l, 'tcx> { } } 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 } @@ -1422,7 +1422,7 @@ impl<'l, 'tcx> Visitor for DxrVisitor<'l, 'tcx> { 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 } @@ -1455,7 +1455,7 @@ impl<'l, 'tcx> Visitor for DxrVisitor<'l, 'tcx> { // 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); } } diff --git a/src/librustc/middle/stability.rs b/src/librustc/middle/stability.rs index 6d0c02ff4e3d..eb736ae8a766 100644 --- a/src/librustc/middle/stability.rs +++ b/src/librustc/middle/stability.rs @@ -59,13 +59,14 @@ impl Annotator { } } -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)); } @@ -85,7 +86,7 @@ impl Visitor for Annotator { 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)) } diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs index 86877c032d13..c023b7a95349 100644 --- a/src/librustc/middle/trans/base.rs +++ b/src/librustc/middle/trans/base.rs @@ -1335,7 +1335,7 @@ impl CheckForNestedReturnsVisitor { } } -impl Visitor for CheckForNestedReturnsVisitor { +impl<'v> Visitor<'v> for CheckForNestedReturnsVisitor { fn visit_expr(&mut self, e: &ast::Expr) { match e.node { ast::ExprRet(..) => { @@ -1360,7 +1360,7 @@ fn has_nested_returns(tcx: &ty::ctxt, id: ast::NodeId) -> bool { 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") @@ -1374,7 +1374,7 @@ fn has_nested_returns(tcx: &ty::ctxt, id: ast::NodeId) -> bool { 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") @@ -1394,7 +1394,7 @@ fn has_nested_returns(tcx: &ty::ctxt, id: ast::NodeId) -> bool { 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") @@ -1410,7 +1410,7 @@ fn has_nested_returns(tcx: &ty::ctxt, id: ast::NodeId) -> bool { 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") @@ -2141,7 +2141,7 @@ pub struct TransItemVisitor<'a, 'tcx: 'a> { 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); } diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs index da16e443ef21..47a4b6f86229 100644 --- a/src/librustc/middle/typeck/check/mod.rs +++ b/src/librustc/middle/typeck/check/mod.rs @@ -375,7 +375,7 @@ fn static_inherited_fields<'a, 'tcx>(ccx: &'a CrateCtxt<'a, 'tcx>) 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); @@ -383,7 +383,7 @@ impl<'a, 'tcx> Visitor for CheckTypeWellFormedVisitor<'a, 'tcx> { } -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); @@ -394,7 +394,7 @@ struct CheckItemSizedTypesVisitor<'a, 'tcx: 'a> { 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); @@ -464,7 +464,7 @@ impl<'a, 'tcx> GatherLocalsVisitor<'a, 'tcx> { } } -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 { @@ -516,8 +516,8 @@ impl<'a, 'tcx> Visitor for GatherLocalsVisitor<'a, 'tcx> { } // 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) { } } diff --git a/src/librustc/middle/typeck/check/regionck.rs b/src/librustc/middle/typeck/check/regionck.rs index 241aa5b91898..8cd8a6aa051c 100644 --- a/src/librustc/middle/typeck/check/regionck.rs +++ b/src/librustc/middle/typeck/check/regionck.rs @@ -479,7 +479,7 @@ impl<'fcx, 'tcx> mc::Typer<'tcx> for Rcx<'fcx, 'tcx> { } } -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 @@ -488,8 +488,8 @@ impl<'a, 'tcx> Visitor for Rcx<'a, 'tcx> { // 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) } diff --git a/src/librustc/middle/typeck/check/vtable.rs b/src/librustc/middle/typeck/check/vtable.rs index 086887326a23..9a70cf574fc4 100644 --- a/src/librustc/middle/typeck/check/vtable.rs +++ b/src/librustc/middle/typeck/check/vtable.rs @@ -1025,7 +1025,7 @@ pub fn trans_resolve_method(tcx: &ty::ctxt, id: ast::NodeId, 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); diff --git a/src/librustc/middle/typeck/check/writeback.rs b/src/librustc/middle/typeck/check/writeback.rs index 89518add8391..4716ffe700b5 100644 --- a/src/librustc/middle/typeck/check/writeback.rs +++ b/src/librustc/middle/typeck/check/writeback.rs @@ -106,7 +106,7 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> { // 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 } @@ -120,7 +120,7 @@ impl<'cx, 'tcx> Visitor for WritebackCx<'cx, 'tcx> { 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; } diff --git a/src/librustc/middle/typeck/coherence.rs b/src/librustc/middle/typeck/coherence.rs index 6a6426516094..ff3372b30726 100644 --- a/src/librustc/middle/typeck/coherence.rs +++ b/src/librustc/middle/typeck/coherence.rs @@ -191,7 +191,7 @@ struct CoherenceCheckVisitor<'a, 'tcx: 'a> { 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)); @@ -218,7 +218,7 @@ struct PrivilegedScopeVisitor<'a, 'tcx: 'a> { 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 { diff --git a/src/librustc/middle/typeck/collect.rs b/src/librustc/middle/typeck/collect.rs index 3af083be57a7..20e76b01317b 100644 --- a/src/librustc/middle/typeck/collect.rs +++ b/src/librustc/middle/typeck/collect.rs @@ -99,7 +99,7 @@ struct CollectTraitDefVisitor<'a, 'tcx: 'a> { 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(..) => { @@ -120,7 +120,7 @@ struct CollectItemTypesVisitor<'a, 'tcx: 'a> { 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); diff --git a/src/librustc/middle/typeck/variance.rs b/src/librustc/middle/typeck/variance.rs index 83d7972e11c2..9526e5d3eb5b 100644 --- a/src/librustc/middle/typeck/variance.rs +++ b/src/librustc/middle/typeck/variance.rs @@ -337,7 +337,7 @@ impl<'a, 'tcx> TermsContext<'a, 'tcx> { } } -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)); @@ -477,7 +477,7 @@ fn add_constraints_from_crate<'a, 'tcx>(terms_cx: TermsContext<'a, '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; diff --git a/src/librustc/middle/weak_lang_items.rs b/src/librustc/middle/weak_lang_items.rs index 0375ddbd3712..81099da3fac0 100644 --- a/src/librustc/middle/weak_lang_items.rs +++ b/src/librustc/middle/weak_lang_items.rs @@ -105,7 +105,7 @@ impl<'a> Context<'a> { } } -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 => {} diff --git a/src/librustc/plugin/build.rs b/src/librustc/plugin/build.rs index f02251350a4b..457fcb861e6d 100644 --- a/src/librustc/plugin/build.rs +++ b/src/librustc/plugin/build.rs @@ -21,7 +21,7 @@ struct RegistrarFinder { 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(..) => { diff --git a/src/librustc/plugin/load.rs b/src/librustc/plugin/load.rs index 31265cc75715..ecbe3409139f 100644 --- a/src/librustc/plugin/load.rs +++ b/src/librustc/plugin/load.rs @@ -87,7 +87,7 @@ pub fn load_plugins(sess: &Session, krate: &ast::Crate, } // 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, _, _) => { diff --git a/src/librustc/util/common.rs b/src/librustc/util/common.rs index b230b56a6cef..b3ac44a3574d 100644 --- a/src/librustc/util/common.rs +++ b/src/librustc/util/common.rs @@ -62,7 +62,7 @@ struct LoopQueryVisitor<'a> { 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 { @@ -90,7 +90,7 @@ struct BlockQueryVisitor<'a> { 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) diff --git a/src/librustc_back/svh.rs b/src/librustc_back/svh.rs index a34dcc41cc3d..c3d9edecc6e2 100644 --- a/src/librustc_back/svh.rs +++ b/src/librustc_back/svh.rs @@ -322,7 +322,7 @@ mod svh_visitor { } fn content(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, @@ -469,7 +469,8 @@ mod svh_visitor { 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) } diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index 3db71c6d3097..ff733673bd26 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -366,7 +366,7 @@ impl<'a, O: IdVisitingOperation> IdVisitor<'a, O> { } } -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, @@ -475,13 +475,13 @@ impl<'a, O: IdVisitingOperation> Visitor for IdVisitor<'a, O> { } 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, _ => {} @@ -490,7 +490,7 @@ impl<'a, O: IdVisitingOperation> Visitor for IdVisitor<'a, O> { self.operation.visit_id(node_id); - match *function_kind { + match function_kind { visit::FkItemFn(_, generics, _, _) | visit::FkMethod(_, generics, _) => { self.visit_generics_helper(generics) @@ -509,7 +509,7 @@ impl<'a, O: IdVisitingOperation> Visitor for IdVisitor<'a, O> { span); if !self.pass_through_items { - match *function_kind { + match function_kind { visit::FkMethod(..) => self.visited_outermost = false, _ => {} } @@ -571,7 +571,7 @@ pub fn compute_id_range_for_inlined_item(item: &InlinedItem) -> IdRange { 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, @@ -639,7 +639,7 @@ struct EachViewItemData<'a> { 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); } diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index 04df6d618e92..8b10c26c43ce 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -651,7 +651,7 @@ struct PatIdentFinder { ident_accumulator: Vec } -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: _ } => { @@ -1107,7 +1107,7 @@ struct MacroExterminator<'a>{ 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 \ @@ -1144,7 +1144,7 @@ mod test { path_accumulator: Vec , } - 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) => { @@ -1169,7 +1169,7 @@ mod test { ident_accumulator: Vec } - 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); } diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs index c31082ddf595..2a989e6d63a2 100644 --- a/src/libsyntax/visit.rs +++ b/src/libsyntax/visit.rs @@ -26,9 +26,7 @@ use abi::Abi; use ast::*; use ast; -use ast_util; use codemap::Span; -use parse; use owned_slice::OwnedSlice; use std::gc::Gc; @@ -45,23 +43,6 @@ pub enum FnKind<'a> { 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; @@ -71,38 +52,38 @@ pub fn generics_of_fn(fk: &FnKind) -> Generics { /// 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) { + opt_lifetime: &'v Option) { /*! * Visits an optional reference to a lifetime. The `span` is * the span of some surrounding reference should opt_lifetime @@ -113,16 +94,16 @@ pub trait Visitor { 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 @@ -130,23 +111,23 @@ pub trait Visitor { // 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(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) } } } @@ -154,14 +135,14 @@ pub fn walk_inlined_item(visitor: &mut V, item: &ast::InlinedItem) { } -pub fn walk_crate(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(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) } @@ -171,7 +152,7 @@ pub fn walk_mod(visitor: &mut V, module: &Mod) { } } -pub fn walk_view_item(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) @@ -204,16 +185,14 @@ pub fn walk_view_item(visitor: &mut V, vi: &ViewItem) { } } -pub fn walk_local(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(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, _, _) => { @@ -225,21 +204,21 @@ pub fn walk_explicit_self(visitor: &mut V, explicit_self: &ExplicitS /// 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(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(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) } @@ -264,7 +243,7 @@ pub fn walk_item(visitor: &mut V, item: &Item) { } ItemImpl(ref type_parameters, ref trait_reference, - typ, + ref typ, ref impl_items) => { visitor.visit_generics(type_parameters); match *trait_reference { @@ -272,11 +251,11 @@ pub fn walk_item(visitor: &mut V, item: &Item) { 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) } } } @@ -302,17 +281,17 @@ pub fn walk_item(visitor: &mut V, item: &Item) { } } -pub fn walk_enum_def(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(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 { @@ -337,14 +316,14 @@ pub fn walk_variant(visitor: &mut V, } } -pub fn skip_ty(_: &mut V, _: &Ty) { +pub fn skip_ty<'v, V: Visitor<'v>>(_: &mut V, _: &'v Ty) { // Empty! } -pub fn walk_ty(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) @@ -354,8 +333,8 @@ pub fn walk_ty(visitor: &mut V, typ: &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) => { @@ -407,13 +386,14 @@ pub fn walk_ty(visitor: &mut V, typ: &Ty) { } } -fn walk_lifetime_decls(visitor: &mut V, lifetimes: &Vec) { +fn walk_lifetime_decls<'v, V: Visitor<'v>>(visitor: &mut V, + lifetimes: &'v Vec) { for l in lifetimes.iter() { visitor.visit_lifetime_decl(l); } } -pub fn walk_path(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); @@ -426,7 +406,7 @@ pub fn walk_path(visitor: &mut V, path: &Path) { } } -pub fn walk_pat(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); @@ -479,7 +459,8 @@ pub fn walk_pat(visitor: &mut V, pattern: &Pat) { } } -pub fn walk_foreign_item(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 { @@ -495,8 +476,8 @@ pub fn walk_foreign_item(visitor: &mut V, foreign_item: &ForeignItem } } -pub fn walk_ty_param_bounds(visitor: &mut V, - bounds: &OwnedSlice) { +pub fn walk_ty_param_bounds<'v, V: Visitor<'v>>(visitor: &mut V, + bounds: &'v OwnedSlice) { for bound in bounds.iter() { match *bound { TraitTyParamBound(ref typ) => { @@ -515,7 +496,7 @@ pub fn walk_ty_param_bounds(visitor: &mut V, } } -pub fn walk_generics(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 { @@ -530,7 +511,7 @@ pub fn walk_generics(visitor: &mut V, generics: &Generics) { } } -pub fn walk_fn_decl(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) @@ -542,13 +523,13 @@ pub fn walk_fn_decl(visitor: &mut V, function_declaration: &FnDecl) // 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(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() { @@ -560,14 +541,14 @@ pub fn walk_method_helper(visitor: &mut V, method: &Method) { } } -pub fn walk_fn(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); } @@ -586,7 +567,7 @@ pub fn walk_fn(visitor: &mut V, visitor.visit_block(function_body) } -pub fn walk_ty_method(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() { @@ -599,7 +580,7 @@ pub fn walk_ty_method(visitor: &mut V, method_type: &TypeMethod) { } } -pub fn walk_trait_item(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) @@ -608,8 +589,8 @@ pub fn walk_trait_item(visitor: &mut V, trait_method: &TraitItem) { } } -pub fn walk_struct_def(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 => {}, @@ -619,8 +600,8 @@ pub fn walk_struct_def(visitor: &mut V, } } -pub fn walk_struct_field(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) @@ -635,17 +616,17 @@ pub fn walk_struct_field(visitor: &mut V, } } -pub fn walk_block(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(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, _) => { @@ -655,32 +636,32 @@ pub fn walk_stmt(visitor: &mut V, statement: &Stmt) { } } -pub fn walk_decl(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(visitor: &mut V, - optional_expression: Option>) { - match optional_expression { +pub fn walk_expr_opt<'v, V: Visitor<'v>>(visitor: &mut V, + optional_expression: &'v Option>) { + match *optional_expression { None => {} Some(ref expression) => visitor.visit_expr(&**expression), } } -pub fn walk_exprs(visitor: &mut V, expressions: &[Gc]) { +pub fn walk_exprs<'v, V: Visitor<'v>>(visitor: &mut V, expressions: &'v [Gc]) { for expression in expressions.iter() { visitor.visit_expr(&**expression) } } -pub fn walk_mac(_: &mut V, _: &Mac) { +pub fn walk_mac<'v, V: Visitor<'v>>(_: &mut V, _: &'v Mac) { // Empty! } -pub fn walk_expr(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); @@ -693,7 +674,7 @@ pub fn walk_expr(visitor: &mut V, expression: &Expr) { 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) @@ -729,7 +710,7 @@ pub fn walk_expr(visitor: &mut V, expression: &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) @@ -751,21 +732,21 @@ pub fn walk_expr(visitor: &mut V, expression: &Expr) { } } 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, @@ -800,7 +781,7 @@ pub fn walk_expr(visitor: &mut V, expression: &Expr) { 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), @@ -808,10 +789,12 @@ pub fn walk_expr(visitor: &mut V, expression: &Expr) { 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) } } @@ -820,11 +803,11 @@ pub fn walk_expr(visitor: &mut V, expression: &Expr) { visitor.visit_expr_post(expression) } -pub fn walk_arm(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);