From 4f691cd5bc83311da1b91b6e5da54e5514440749 Mon Sep 17 00:00:00 2001 From: "Felix S. Klock II" Date: Tue, 24 Sep 2013 03:25:41 +0200 Subject: [PATCH] visit::Visitor refactor: fold moves.rs VisitContext into ComputeModesVisitor. --- src/librustc/middle/lint.rs | 2 - src/librustc/middle/moves.rs | 196 ++++++++++++++++------------------- 2 files changed, 90 insertions(+), 108 deletions(-) diff --git a/src/librustc/middle/lint.rs b/src/librustc/middle/lint.rs index da181ff2eb6..17f07bb7b70 100644 --- a/src/librustc/middle/lint.rs +++ b/src/librustc/middle/lint.rs @@ -375,8 +375,6 @@ enum AnyVisitor { NewVisitor(@mut visit::Visitor<()>), } -type VCObj = @mut Visitor<@mut Context>; - struct Context { // All known lint modes (string versions) dict: @LintDict, diff --git a/src/librustc/middle/moves.rs b/src/librustc/middle/moves.rs index a9527831d3a..b7bdb9a1e5d 100644 --- a/src/librustc/middle/moves.rs +++ b/src/librustc/middle/moves.rs @@ -191,18 +191,16 @@ enum UseMode { Read // Read no matter what the type. } -struct ComputeModesVisitor; - -impl visit::Visitor for ComputeModesVisitor { +impl visit::Visitor<()> for VisitContext { fn visit_fn(&mut self, fk:&visit::fn_kind, fd:&fn_decl, - b:&Block, s:Span, n:NodeId, e:VisitContext) { - compute_modes_for_fn(*self, fk, fd, b, s, n, e); + b:&Block, s:Span, n:NodeId, _:()) { + compute_modes_for_fn(self, fk, fd, b, s, n); } - fn visit_expr(&mut self, ex:@Expr, e:VisitContext) { - compute_modes_for_expr(*self, ex, e); + fn visit_expr(&mut self, ex:@Expr, _:()) { + compute_modes_for_expr(self, ex); } - fn visit_local(&mut self, l:@Local, e:VisitContext) { - compute_modes_for_local(*self, l, e); + fn visit_local(&mut self, l:@Local, _:()) { + compute_modes_for_local(self, l); } } @@ -210,8 +208,7 @@ pub fn compute_moves(tcx: ty::ctxt, method_map: method_map, crate: &Crate) -> MoveMaps { - let mut visitor = ComputeModesVisitor; - let visit_cx = VisitContext { + let mut visit_cx = VisitContext { tcx: tcx, method_map: method_map, move_maps: MoveMaps { @@ -220,7 +217,8 @@ pub fn compute_moves(tcx: ty::ctxt, moved_variables_set: @mut HashSet::new() } }; - visit::walk_crate(&mut visitor, crate, visit_cx); + let visit_cx = &mut visit_cx; + visit::walk_crate(visit_cx, crate, ()); return visit_cx.move_maps; } @@ -238,44 +236,40 @@ pub fn moved_variable_node_id_from_def(def: Def) -> Option { /////////////////////////////////////////////////////////////////////////// // Expressions -fn compute_modes_for_local<'a>(v: ComputeModesVisitor, - local: @Local, - cx: VisitContext) { +fn compute_modes_for_local<'a>(cx: &mut VisitContext, + local: @Local) { cx.use_pat(local.pat); for &init in local.init.iter() { - cx.use_expr(init, Read, v); + cx.use_expr(init, Read); } } -fn compute_modes_for_fn(v: ComputeModesVisitor, +fn compute_modes_for_fn(cx: &mut VisitContext, fk: &visit::fn_kind, decl: &fn_decl, body: &Block, span: Span, - id: NodeId, - cx: VisitContext) { - let mut v = v; + id: NodeId) { for a in decl.inputs.iter() { cx.use_pat(a.pat); } - visit::walk_fn(&mut v, fk, decl, body, span, id, cx); + visit::walk_fn(cx, fk, decl, body, span, id, ()); } -fn compute_modes_for_expr(v: ComputeModesVisitor, - expr: @Expr, - cx: VisitContext) +fn compute_modes_for_expr(cx: &mut VisitContext, + expr: @Expr) { - cx.consume_expr(expr, v); + cx.consume_expr(expr); } impl VisitContext { - pub fn consume_exprs(&self, exprs: &[@Expr], visitor: ComputeModesVisitor) { + pub fn consume_exprs(&mut self, exprs: &[@Expr]) { for expr in exprs.iter() { - self.consume_expr(*expr, visitor); + self.consume_expr(*expr); } } - pub fn consume_expr(&self, expr: @Expr, visitor: ComputeModesVisitor) { + pub fn consume_expr(&mut self, expr: @Expr) { /*! * Indicates that the value of `expr` will be consumed, * meaning either copied or moved depending on its type. @@ -287,13 +281,13 @@ impl VisitContext { let expr_ty = ty::expr_ty_adjusted(self.tcx, expr); if ty::type_moves_by_default(self.tcx, expr_ty) { self.move_maps.moves_map.insert(expr.id); - self.use_expr(expr, Move, visitor); + self.use_expr(expr, Move); } else { - self.use_expr(expr, Read, visitor); + self.use_expr(expr, Read); }; } - pub fn consume_block(&self, blk: &Block, visitor: ComputeModesVisitor) { + pub fn consume_block(&mut self, blk: &Block) { /*! * Indicates that the value of `blk` will be consumed, * meaning either copied or moved depending on its type. @@ -302,19 +296,17 @@ impl VisitContext { debug!("consume_block(blk.id=%?)", blk.id); for stmt in blk.stmts.iter() { - let mut v = visitor; - v.visit_stmt(*stmt, *self); + self.visit_stmt(*stmt, ()); } for tail_expr in blk.expr.iter() { - self.consume_expr(*tail_expr, visitor); + self.consume_expr(*tail_expr); } } - pub fn use_expr(&self, + pub fn use_expr(&mut self, expr: @Expr, - expr_mode: UseMode, - visitor: ComputeModesVisitor) { + expr_mode: UseMode) { /*! * Indicates that `expr` is used with a given mode. This will * in turn trigger calls to the subcomponents of `expr`. @@ -351,25 +343,23 @@ impl VisitContext { } ExprUnary(_, UnDeref, base) => { // *base - if !self.use_overloaded_operator( - expr, base, [], visitor) + if !self.use_overloaded_operator(expr, base, []) { // Moving out of *base moves out of base. - self.use_expr(base, comp_mode, visitor); + self.use_expr(base, comp_mode); } } ExprField(base, _, _) => { // base.f // Moving out of base.f moves out of base. - self.use_expr(base, comp_mode, visitor); + self.use_expr(base, comp_mode); } ExprIndex(_, lhs, rhs) => { // lhs[rhs] - if !self.use_overloaded_operator( - expr, lhs, [rhs], visitor) + if !self.use_overloaded_operator(expr, lhs, [rhs]) { - self.use_expr(lhs, comp_mode, visitor); - self.consume_expr(rhs, visitor); + self.use_expr(lhs, comp_mode); + self.consume_expr(rhs); } } @@ -394,20 +384,20 @@ impl VisitContext { if mode == Move { self.move_maps.moves_map.insert(callee.id); } - self.use_expr(callee, mode, visitor); - self.use_fn_args(callee.id, *args, visitor); + self.use_expr(callee, mode); + self.use_fn_args(callee.id, *args); } ExprMethodCall(callee_id, rcvr, _, _, ref args, _) => { // callee.m(args) // Implicit self is equivalent to & mode, but every // other kind should be + mode. - self.use_receiver(rcvr, visitor); - self.use_fn_args(callee_id, *args, visitor); + self.use_receiver(rcvr); + self.use_fn_args(callee_id, *args); } ExprStruct(_, ref fields, opt_with) => { for field in fields.iter() { - self.consume_expr(field.expr, visitor); + self.consume_expr(field.expr); } for with_expr in opt_with.iter() { @@ -449,22 +439,22 @@ impl VisitContext { which defines the `Drop` trait", with_ty.user_string(self.tcx))); } - self.consume_expr(*with_expr, visitor); + self.consume_expr(*with_expr); } else { - self.use_expr(*with_expr, Read, visitor); + self.use_expr(*with_expr, Read); } } } ExprTup(ref exprs) => { - self.consume_exprs(*exprs, visitor); + self.consume_exprs(*exprs); } ExprIf(cond_expr, ref then_blk, opt_else_expr) => { - self.consume_expr(cond_expr, visitor); - self.consume_block(then_blk, visitor); + self.consume_expr(cond_expr); + self.consume_block(then_blk); for else_expr in opt_else_expr.iter() { - self.consume_expr(*else_expr, visitor); + self.consume_expr(*else_expr); } } @@ -472,27 +462,27 @@ impl VisitContext { // We must do this first so that `arms_have_by_move_bindings` // below knows which bindings are moves. for arm in arms.iter() { - self.consume_arm(arm, visitor); + self.consume_arm(arm); } // The discriminant may, in fact, be partially moved // if there are by-move bindings, but borrowck deals // with that itself. - self.use_expr(discr, Read, visitor); + self.use_expr(discr, Read); } ExprParen(base) => { // Note: base is not considered a *component* here, so // use `expr_mode` not `comp_mode`. - self.use_expr(base, expr_mode, visitor); + self.use_expr(base, expr_mode); } ExprVec(ref exprs, _) => { - self.consume_exprs(*exprs, visitor); + self.consume_exprs(*exprs); } ExprAddrOf(_, base) => { // &base - self.use_expr(base, Read, visitor); + self.use_expr(base, Read); } ExprLogLevel | @@ -502,70 +492,67 @@ impl VisitContext { ExprLit(*) => {} ExprLoop(ref blk, _) => { - self.consume_block(blk, visitor); + self.consume_block(blk); } ExprWhile(cond_expr, ref blk) => { - self.consume_expr(cond_expr, visitor); - self.consume_block(blk, visitor); + self.consume_expr(cond_expr); + self.consume_block(blk); } ExprForLoop(*) => fail!("non-desugared expr_for_loop"), ExprUnary(_, _, lhs) => { - if !self.use_overloaded_operator( - expr, lhs, [], visitor) + if !self.use_overloaded_operator(expr, lhs, []) { - self.consume_expr(lhs, visitor); + self.consume_expr(lhs); } } ExprBinary(_, _, lhs, rhs) => { - if !self.use_overloaded_operator( - expr, lhs, [rhs], visitor) + if !self.use_overloaded_operator(expr, lhs, [rhs]) { - self.consume_expr(lhs, visitor); - self.consume_expr(rhs, visitor); + self.consume_expr(lhs); + self.consume_expr(rhs); } } ExprBlock(ref blk) => { - self.consume_block(blk, visitor); + self.consume_block(blk); } ExprRet(ref opt_expr) => { for expr in opt_expr.iter() { - self.consume_expr(*expr, visitor); + self.consume_expr(*expr); } } ExprAssign(lhs, rhs) => { - self.use_expr(lhs, Read, visitor); - self.consume_expr(rhs, visitor); + self.use_expr(lhs, Read); + self.consume_expr(rhs); } ExprCast(base, _) => { - self.consume_expr(base, visitor); + self.consume_expr(base); } ExprAssignOp(_, _, lhs, rhs) => { // FIXME(#4712) --- Overloaded operators? // - // if !self.use_overloaded_operator( - // expr, DoDerefArgs, lhs, [rhs], visitor) + // if !self.use_overloaded_operator(expr, DoDerefArgs, lhs, [rhs]) // { - self.consume_expr(lhs, visitor); - self.consume_expr(rhs, visitor); + self.consume_expr(lhs); + self.consume_expr(rhs); // } } ExprRepeat(base, count, _) => { - self.consume_expr(base, visitor); - self.consume_expr(count, visitor); + self.consume_expr(base); + self.consume_expr(count); } ExprDoBody(base) => { - self.use_expr(base, comp_mode, visitor); + self.use_expr(base, comp_mode); } ExprFnBlock(ref decl, ref body) => { @@ -574,11 +561,11 @@ impl VisitContext { } let cap_vars = self.compute_captures(expr.id); self.move_maps.capture_map.insert(expr.id, cap_vars); - self.consume_block(body, visitor); + self.consume_block(body); } ExprVstore(base, _) => { - self.use_expr(base, comp_mode, visitor); + self.use_expr(base, comp_mode); } ExprMac(*) => { @@ -589,40 +576,39 @@ impl VisitContext { } } - pub fn use_overloaded_operator(&self, + pub fn use_overloaded_operator(&mut self, expr: &Expr, receiver_expr: @Expr, - arg_exprs: &[@Expr], - visitor: ComputeModesVisitor) + arg_exprs: &[@Expr]) -> bool { if !self.method_map.contains_key(&expr.id) { return false; } - self.use_receiver(receiver_expr, visitor); + self.use_receiver(receiver_expr); // for overloaded operatrs, we are always passing in a // borrowed pointer, so it's always read mode: for arg_expr in arg_exprs.iter() { - self.use_expr(*arg_expr, Read, visitor); + self.use_expr(*arg_expr, Read); } return true; } - pub fn consume_arm(&self, arm: &Arm, visitor: ComputeModesVisitor) { + pub fn consume_arm(&mut self, arm: &Arm) { for pat in arm.pats.iter() { self.use_pat(*pat); } for guard in arm.guard.iter() { - self.consume_expr(*guard, visitor); + self.consume_expr(*guard); } - self.consume_block(&arm.body, visitor); + self.consume_block(&arm.body); } - pub fn use_pat(&self, pat: @Pat) { + pub fn use_pat(&mut self, pat: @Pat) { /*! * * Decides whether each binding in a pattern moves the value @@ -651,28 +637,26 @@ impl VisitContext { } } - pub fn use_receiver(&self, - receiver_expr: @Expr, - visitor: ComputeModesVisitor) { - self.use_fn_arg(receiver_expr, visitor); + pub fn use_receiver(&mut self, + receiver_expr: @Expr) { + self.use_fn_arg(receiver_expr); } - pub fn use_fn_args(&self, + pub fn use_fn_args(&mut self, _: NodeId, - arg_exprs: &[@Expr], - visitor: ComputeModesVisitor) { + arg_exprs: &[@Expr]) { //! Uses the argument expressions. for arg_expr in arg_exprs.iter() { - self.use_fn_arg(*arg_expr, visitor); + self.use_fn_arg(*arg_expr); } } - pub fn use_fn_arg(&self, arg_expr: @Expr, visitor: ComputeModesVisitor) { + pub fn use_fn_arg(&mut self, arg_expr: @Expr) { //! Uses the argument. - self.consume_expr(arg_expr, visitor) + self.consume_expr(arg_expr) } - pub fn arms_have_by_move_bindings(&self, + pub fn arms_have_by_move_bindings(&mut self, moves_map: MovesMap, arms: &[Arm]) -> Option<@Pat> { @@ -693,7 +677,7 @@ impl VisitContext { ret } - pub fn compute_captures(&self, fn_expr_id: NodeId) -> @[CaptureVar] { + pub fn compute_captures(&mut self, fn_expr_id: NodeId) -> @[CaptureVar] { debug!("compute_capture_vars(fn_expr_id=%?)", fn_expr_id); let _indenter = indenter();