item_fn(ItemFnParts {
id: i.id,
name: i.name,
- decl: &**decl,
+ decl: &decl,
unsafety: unsafety,
- body: &**block,
+ body: &block,
generics: generics,
abi: abi,
vis: i.vis,
}
map::NodeExpr(e) => match e.node {
ast::ExprClosure(_, ref decl, ref block) =>
- closure(ClosureParts::new(&**decl, &**block, e.id, e.span)),
+ closure(ClosureParts::new(&decl, &block, e.id, e.span)),
_ => panic!("expr FnLikeNode that is not fn-like"),
},
_ => panic!("other FnLikeNode that is not fn-like"),
loop {
match map.find(id) {
None => return None,
- Some(NodeItem(item)) if item_is_mod(&*item) =>
+ Some(NodeItem(item)) if item_is_mod(&item) =>
return Some((id, item.name)),
_ => {}
}
impl<'a> NodePrinter for pprust::State<'a> {
fn print_node(&mut self, node: &Node) -> io::Result<()> {
match *node {
- NodeItem(a) => self.print_item(&*a),
- NodeForeignItem(a) => self.print_foreign_item(&*a),
+ NodeItem(a) => self.print_item(&a),
+ NodeForeignItem(a) => self.print_foreign_item(&a),
NodeTraitItem(a) => self.print_trait_item(a),
NodeImplItem(a) => self.print_impl_item(a),
- NodeVariant(a) => self.print_variant(&*a),
- NodeExpr(a) => self.print_expr(&*a),
- NodeStmt(a) => self.print_stmt(&*a),
- NodePat(a) => self.print_pat(&*a),
- NodeBlock(a) => self.print_block(&*a),
- NodeLifetime(a) => self.print_lifetime(&*a),
+ NodeVariant(a) => self.print_variant(&a),
+ NodeExpr(a) => self.print_expr(&a),
+ NodeStmt(a) => self.print_stmt(&a),
+ NodePat(a) => self.print_pat(&a),
+ NodeBlock(a) => self.print_block(&a),
+ NodeLifetime(a) => self.print_lifetime(&a),
NodeTyParam(_) => panic!("cannot print TyParam"),
// these cases do not carry enough information in the
// ast_map to reconstruct their full structure for pretty
map.path_to_string(id), id_str)
}
Some(NodeExpr(ref expr)) => {
- format!("expr {}{}", pprust::expr_to_string(&**expr), id_str)
+ format!("expr {}{}", pprust::expr_to_string(&expr), id_str)
}
Some(NodeStmt(ref stmt)) => {
- format!("stmt {}{}", pprust::stmt_to_string(&**stmt), id_str)
+ format!("stmt {}{}", pprust::stmt_to_string(&stmt), id_str)
}
Some(NodeLocal(ref pat)) => {
- format!("local {}{}", pprust::pat_to_string(&**pat), id_str)
+ format!("local {}{}", pprust::pat_to_string(&pat), id_str)
}
Some(NodePat(ref pat)) => {
- format!("pat {}{}", pprust::pat_to_string(&**pat), id_str)
+ format!("pat {}{}", pprust::pat_to_string(&pat), id_str)
}
Some(NodeBlock(ref block)) => {
- format!("block {}{}", pprust::block_to_string(&**block), id_str)
+ format!("block {}{}", pprust::block_to_string(&block), id_str)
}
Some(NodeStructCtor(_)) => {
format!("struct_ctor {}{}", map.path_to_string(id), id_str)
}
Some(NodeLifetime(ref l)) => {
format!("lifetime {}{}",
- pprust::lifetime_to_string(&**l), id_str)
+ pprust::lifetime_to_string(&l), id_str)
}
Some(NodeTyParam(ref ty_param)) => {
format!("typaram {:?}{}", ty_param, id_str)
fn stmt(&mut self, stmt: &hir::Stmt, pred: CFGIndex) -> CFGIndex {
match stmt.node {
hir::StmtDecl(ref decl, id) => {
- let exit = self.decl(&**decl, pred);
+ let exit = self.decl(&decl, pred);
self.add_ast_node(id, &[exit])
}
hir::StmtExpr(ref expr, id) | hir::StmtSemi(ref expr, id) => {
- let exit = self.expr(&**expr, pred);
+ let exit = self.expr(&expr, pred);
self.add_ast_node(id, &[exit])
}
}
match decl.node {
hir::DeclLocal(ref local) => {
let init_exit = self.opt_expr(&local.init, pred);
- self.pat(&*local.pat, init_exit)
+ self.pat(&local.pat, init_exit)
}
hir::DeclItem(_) => {
hir::PatBox(ref subpat) |
hir::PatRegion(ref subpat, _) |
hir::PatIdent(_, _, Some(ref subpat)) => {
- let subpat_exit = self.pat(&**subpat, pred);
+ let subpat_exit = self.pat(&subpat, pred);
self.add_ast_node(pat.id, &[subpat_exit])
}
pats: I,
pred: CFGIndex) -> CFGIndex {
//! Handles case where all of the patterns must match.
- pats.fold(pred, |pred, pat| self.pat(&**pat, pred))
+ pats.fold(pred, |pred, pat| self.pat(&pat, pred))
}
fn expr(&mut self, expr: &hir::Expr, pred: CFGIndex) -> CFGIndex {
match expr.node {
hir::ExprBlock(ref blk) => {
- let blk_exit = self.block(&**blk, pred);
+ let blk_exit = self.block(&blk, pred);
self.add_ast_node(expr.id, &[blk_exit])
}
// v 3 v 4
// [..expr..]
//
- let cond_exit = self.expr(&**cond, pred); // 1
- let then_exit = self.block(&**then, cond_exit); // 2
+ let cond_exit = self.expr(&cond, pred); // 1
+ let then_exit = self.block(&then, cond_exit); // 2
self.add_ast_node(expr.id, &[cond_exit, then_exit]) // 3,4
}
// v 4 v 5
// [..expr..]
//
- let cond_exit = self.expr(&**cond, pred); // 1
- let then_exit = self.block(&**then, cond_exit); // 2
- let else_exit = self.expr(&**otherwise, cond_exit); // 3
+ let cond_exit = self.expr(&cond, pred); // 1
+ let then_exit = self.block(&then, cond_exit); // 2
+ let else_exit = self.expr(&otherwise, cond_exit); // 3
self.add_ast_node(expr.id, &[then_exit, else_exit]) // 4, 5
}
// Is the condition considered part of the loop?
let loopback = self.add_dummy_node(&[pred]); // 1
- let cond_exit = self.expr(&**cond, loopback); // 2
+ let cond_exit = self.expr(&cond, loopback); // 2
let expr_exit = self.add_ast_node(expr.id, &[cond_exit]); // 3
self.loop_scopes.push(LoopScope {
loop_id: expr.id,
continue_index: loopback,
break_index: expr_exit
});
- let body_exit = self.block(&**body, cond_exit); // 4
+ let body_exit = self.block(&body, cond_exit); // 4
self.add_contained_edge(body_exit, loopback); // 5
self.loop_scopes.pop();
expr_exit
continue_index: loopback,
break_index: expr_exit,
});
- let body_exit = self.block(&**body, loopback); // 3
+ let body_exit = self.block(&body, loopback); // 3
self.add_contained_edge(body_exit, loopback); // 4
self.loop_scopes.pop();
expr_exit
// v 3 v 4
// [..exit..]
//
- let l_exit = self.expr(&**l, pred); // 1
- let r_exit = self.expr(&**r, l_exit); // 2
+ let l_exit = self.expr(&l, pred); // 1
+ let r_exit = self.expr(&r, l_exit); // 2
self.add_ast_node(expr.id, &[l_exit, r_exit]) // 3,4
}
}
hir::ExprCall(ref func, ref args) => {
- self.call(expr, pred, &**func, args.iter().map(|e| &**e))
+ self.call(expr, pred, &func, args.iter().map(|e| &**e))
}
hir::ExprMethodCall(_, _, ref args) => {
- self.call(expr, pred, &*args[0], args[1..].iter().map(|e| &**e))
+ self.call(expr, pred, &args[0], args[1..].iter().map(|e| &**e))
}
hir::ExprIndex(ref l, ref r) |
hir::ExprBinary(_, ref l, ref r) if self.tcx.is_method_call(expr.id) => {
- self.call(expr, pred, &**l, Some(&**r).into_iter())
+ self.call(expr, pred, &l, Some(&**r).into_iter())
}
hir::ExprRange(ref start, ref end) => {
}
hir::ExprUnary(_, ref e) if self.tcx.is_method_call(expr.id) => {
- self.call(expr, pred, &**e, None::<hir::Expr>.iter())
+ self.call(expr, pred, &e, None::<hir::Expr>.iter())
}
hir::ExprTup(ref exprs) => {
opt_expr: &Option<P<hir::Expr>>,
pred: CFGIndex) -> CFGIndex {
//! Constructs graph for `opt_expr` evaluated, if Some
- opt_expr.iter().fold(pred, |p, e| self.expr(&**e, p))
+ opt_expr.iter().fold(pred, |p, e| self.expr(&e, p))
}
fn straightline<'b, I: Iterator<Item=&'b hir::Expr>>(&mut self,
for pat in &arm.pats {
// Visit the pattern, coming from the discriminant exit
- let mut pat_exit = self.pat(&**pat, discr_exit);
+ let mut pat_exit = self.pat(&pat, discr_exit);
// If there is a guard expression, handle it here
if let Some(ref guard) = arm.guard {
// expression to target
let guard_start = self.add_dummy_node(&[pat_exit]);
// Visit the guard expression
- let guard_exit = self.expr(&**guard, guard_start);
+ let guard_exit = self.expr(&guard, guard_start);
let this_has_bindings = pat_util::pat_contains_bindings_or_wild(
- &self.tcx.def_map.borrow(), &**pat);
+ &self.tcx.def_map.borrow(), &pat);
// If both this pattern and the previous pattern
// were free of bindings, they must consist only
let &Matrix(ref m) = self;
let pretty_printed_matrix: Vec<Vec<String>> = m.iter().map(|row| {
row.iter()
- .map(|&pat| pat_to_string(&*pat))
+ .map(|&pat| pat_to_string(&pat))
.collect::<Vec<String>>()
}).collect();
// Second, if there is a guard on each arm, make sure it isn't
// assigning or borrowing anything mutably.
match arm.guard {
- Some(ref guard) => check_for_mutation_in_guard(cx, &**guard),
+ Some(ref guard) => check_for_mutation_in_guard(cx, &guard),
None => {}
}
}
.iter()
.flat_map(|&(ref pats, _)| pats) {
// Third, check legality of move bindings.
- check_legality_of_bindings_in_at_patterns(cx, &**pat);
+ check_legality_of_bindings_in_at_patterns(cx, &pat);
// Fourth, check if there are any references to NaN that we should warn about.
- check_for_static_nan(cx, &**pat);
+ check_for_static_nan(cx, &pat);
// Fifth, check if for any of the patterns that match an enumerated type
// are bindings with the same name as one of the variants of said type.
- check_for_bindings_named_the_same_as_variants(cx, &**pat);
+ check_for_bindings_named_the_same_as_variants(cx, &pat);
}
// Fourth, check for unreachable arms.
fn check_for_static_nan(cx: &MatchCheckCtxt, pat: &Pat) {
front_util::walk_pat(pat, |p| {
if let hir::PatLit(ref expr) = p.node {
- match eval_const_expr_partial(cx.tcx, &**expr, ExprTypeChecked, None) {
+ match eval_const_expr_partial(cx.tcx, &expr, ExprTypeChecked, None) {
Ok(ConstVal::Float(f)) if f.is_nan() => {
span_warn!(cx.tcx.sess, p.span, E0003,
"unmatchable NaN in pattern, \
fn raw_pat<'a>(p: &'a Pat) -> &'a Pat {
match p.node {
- hir::PatIdent(_, _, Some(ref s)) => raw_pat(&**s),
+ hir::PatIdent(_, _, Some(ref s)) => raw_pat(&s),
_ => p
}
}
let left_ty = if real_pat.id == DUMMY_NODE_ID {
cx.tcx.mk_nil()
} else {
- let left_ty = cx.tcx.pat_ty(&*real_pat);
+ let left_ty = cx.tcx.pat_ty(&real_pat);
match real_pat.node {
hir::PatIdent(hir::BindByRef(..), _, _) => {
_ => vec!(Single)
},
hir::PatLit(ref expr) =>
- vec!(ConstantValue(eval_const_expr(cx.tcx, &**expr))),
+ vec!(ConstantValue(eval_const_expr(cx.tcx, &expr))),
hir::PatRange(ref lo, ref hi) =>
- vec!(ConstantRange(eval_const_expr(cx.tcx, &**lo), eval_const_expr(cx.tcx, &**hi))),
+ vec!(ConstantRange(eval_const_expr(cx.tcx, &lo), eval_const_expr(cx.tcx, &hi))),
hir::PatVec(ref before, ref slice, ref after) =>
match left_ty.sty {
ty::TyArray(_, _) => vec!(Single),
Some(vec![&**inner]),
hir::PatLit(ref expr) => {
- let expr_value = eval_const_expr(cx.tcx, &**expr);
+ let expr_value = eval_const_expr(cx.tcx, &expr);
match range_covered_by_constructor(constructor, &expr_value, &expr_value) {
Some(true) => Some(vec![]),
Some(false) => None,
}
hir::PatRange(ref from, ref to) => {
- let from_value = eval_const_expr(cx.tcx, &**from);
- let to_value = eval_const_expr(cx.tcx, &**to);
+ let from_value = eval_const_expr(cx.tcx, &from);
+ let to_value = eval_const_expr(cx.tcx, &to);
match range_covered_by_constructor(constructor, &from_value, &to_value) {
Some(true) => Some(vec![]),
Some(false) => None,
// Check legality of move bindings and `@` patterns.
check_legality_of_move_bindings(cx, false, slice::ref_slice(&loc.pat));
- check_legality_of_bindings_in_at_patterns(cx, &*loc.pat);
+ check_legality_of_bindings_in_at_patterns(cx, &loc.pat);
}
fn check_fn(cx: &mut MatchCheckCtxt,
for input in &decl.inputs {
check_irrefutable(cx, &input.pat, true);
check_legality_of_move_bindings(cx, false, slice::ref_slice(&input.pat));
- check_legality_of_bindings_in_at_patterns(cx, &*input.pat);
+ check_legality_of_bindings_in_at_patterns(cx, &input.pat);
}
}
match is_useful(cx, &pats, &[DUMMY_WILD_PAT], ConstructWitness) {
UsefulWithWitness(pats) => {
assert_eq!(pats.len(), 1);
- Some(refutable(&*pats[0]))
+ Some(refutable(&pats[0]))
},
NotUseful => None,
Useful => unreachable!()
let def_map = &tcx.def_map;
let mut by_ref_span = None;
for pat in pats {
- pat_bindings(def_map, &**pat, |bm, _, span, _path| {
+ pat_bindings(def_map, &pat, |bm, _, span, _path| {
match bm {
hir::BindByRef(_) => {
by_ref_span = Some(span);
// check legality of moving out of the enum
// x @ Foo(..) is legal, but x @ Foo(y) isn't.
- if sub.map_or(false, |p| pat_contains_bindings(&def_map.borrow(), &*p)) {
+ if sub.map_or(false, |p| pat_contains_bindings(&def_map.borrow(), &p)) {
span_err!(cx.tcx.sess, p.span, E0007, "cannot bind by-move with sub-bindings");
} else if has_guard {
span_err!(cx.tcx.sess, p.span, E0008, "cannot bind by-move into a pattern guard");
};
for pat in pats {
- front_util::walk_pat(&**pat, |p| {
- if pat_is_binding(&def_map.borrow(), &*p) {
+ front_util::walk_pat(&pat, |p| {
+ if pat_is_binding(&def_map.borrow(), &p) {
match p.node {
hir::PatIdent(hir::BindByValue(_), _, ref sub) => {
let pat_ty = tcx.node_id_to_type(p.id);
None => None,
Some(ast_map::NodeItem(it)) => match it.node {
hir::ItemConst(_, ref const_expr) => {
- Some(&*const_expr)
+ Some(&const_expr)
}
_ => None
},
},
Some(ast_map::NodeImplItem(ii)) => match ii.node {
hir::ImplItemKind::Const(_, ref expr) => {
- Some(&*expr)
+ Some(&expr)
}
_ => None
},
pub fn const_expr_to_pat(tcx: &ty::ctxt, expr: &Expr, span: Span) -> P<hir::Pat> {
let pat = match expr.node {
hir::ExprTup(ref exprs) =>
- hir::PatTup(exprs.iter().map(|expr| const_expr_to_pat(tcx, &**expr, span)).collect()),
+ hir::PatTup(exprs.iter().map(|expr| const_expr_to_pat(tcx, &expr, span)).collect()),
hir::ExprCall(ref callee, ref args) => {
let def = *tcx.def_map.borrow().get(&callee.id).unwrap();
}),
_ => unreachable!()
};
- let pats = args.iter().map(|expr| const_expr_to_pat(tcx, &**expr, span)).collect();
+ let pats = args.iter().map(|expr| const_expr_to_pat(tcx, &expr, span)).collect();
hir::PatEnum(path, Some(pats))
}
span: codemap::DUMMY_SP,
node: hir::FieldPat {
name: field.name.node,
- pat: const_expr_to_pat(tcx, &*field.expr, span),
+ pat: const_expr_to_pat(tcx, &field.expr, span),
is_shorthand: false,
},
}).collect();
}
hir::ExprVec(ref exprs) => {
- let pats = exprs.iter().map(|expr| const_expr_to_pat(tcx, &**expr, span)).collect();
+ let pats = exprs.iter().map(|expr| const_expr_to_pat(tcx, &expr, span)).collect();
hir::PatVec(pats, None, hir::HirVec::new())
}
let result = match e.node {
hir::ExprUnary(hir::UnNeg, ref inner) => {
- match try!(eval_const_expr_partial(tcx, &**inner, ty_hint, fn_args)) {
+ match try!(eval_const_expr_partial(tcx, &inner, ty_hint, fn_args)) {
Float(f) => Float(-f),
Int(n) => try!(const_int_checked_neg(n, e, expr_int_type)),
Uint(i) => {
}
}
hir::ExprUnary(hir::UnNot, ref inner) => {
- match try!(eval_const_expr_partial(tcx, &**inner, ty_hint, fn_args)) {
+ match try!(eval_const_expr_partial(tcx, &inner, ty_hint, fn_args)) {
Int(i) => Int(!i),
Uint(i) => const_uint_not(i, expr_uint_type),
Bool(b) => Bool(!b),
hir::BiShl | hir::BiShr => ty_hint.checked_or(tcx.types.usize),
_ => ty_hint
};
- match (try!(eval_const_expr_partial(tcx, &**a, ty_hint, fn_args)),
- try!(eval_const_expr_partial(tcx, &**b, b_ty, fn_args))) {
+ match (try!(eval_const_expr_partial(tcx, &a, ty_hint, fn_args)),
+ try!(eval_const_expr_partial(tcx, &b, b_ty, fn_args))) {
(Float(a), Float(b)) => {
match op.node {
hir::BiAdd => Float(a + b),
}
}
hir::ExprCast(ref base, ref target_ty) => {
- let ety = ety.or_else(|| ast_ty_to_prim_ty(tcx, &**target_ty))
+ let ety = ety.or_else(|| ast_ty_to_prim_ty(tcx, &target_ty))
.unwrap_or_else(|| {
tcx.sess.span_fatal(target_ty.span,
"target type not found for const cast")
}
};
- let val = try!(eval_const_expr_partial(tcx, &**base, base_hint, fn_args));
+ let val = try!(eval_const_expr_partial(tcx, &base, base_hint, fn_args));
match cast_const(tcx, val, ety) {
Ok(val) => val,
Err(kind) => return Err(ConstEvalErr { span: e.span, kind: kind }),
assert!(old.is_none());
}
debug!("const call({:?})", call_args);
- try!(eval_const_expr_partial(tcx, &**result, ty_hint, Some(&call_args)))
+ try!(eval_const_expr_partial(tcx, &result, ty_hint, Some(&call_args)))
},
- hir::ExprLit(ref lit) => lit_to_const(tcx.sess, e.span, &**lit, ety),
+ hir::ExprLit(ref lit) => lit_to_const(tcx.sess, e.span, &lit, ety),
hir::ExprBlock(ref block) => {
match block.expr {
- Some(ref expr) => try!(eval_const_expr_partial(tcx, &**expr, ty_hint, fn_args)),
+ Some(ref expr) => try!(eval_const_expr_partial(tcx, &expr, ty_hint, fn_args)),
None => unreachable!(),
}
}
- hir::ExprType(ref e, _) => try!(eval_const_expr_partial(tcx, &**e, ty_hint, fn_args)),
+ hir::ExprType(ref e, _) => try!(eval_const_expr_partial(tcx, &e, ty_hint, fn_args)),
hir::ExprTup(_) => Tuple(e.id),
hir::ExprStruct(..) => Struct(e.id),
hir::ExprIndex(ref arr, ref idx) => {
match arr {
Array(_, n) if idx >= n => signal!(e, IndexOutOfBounds),
Array(v, _) => if let hir::ExprVec(ref v) = tcx.map.expect_expr(v).node {
- try!(eval_const_expr_partial(tcx, &*v[idx as usize], ty_hint, fn_args))
+ try!(eval_const_expr_partial(tcx, &v[idx as usize], ty_hint, fn_args))
} else {
unreachable!()
},
Repeat(_, n) if idx >= n => signal!(e, IndexOutOfBounds),
Repeat(elem, _) => try!(eval_const_expr_partial(
tcx,
- &*tcx.map.expect_expr(elem),
+ &tcx.map.expect_expr(elem),
ty_hint,
fn_args,
)),
let len_hint = ty_hint.checked_or(tcx.types.usize);
Repeat(
e.id,
- match try!(eval_const_expr_partial(tcx, &**n, len_hint, fn_args)) {
+ match try!(eval_const_expr_partial(tcx, &n, len_hint, fn_args)) {
Int(i) if i >= 0 => i as u64,
Int(_) => signal!(e, RepeatCountNotNatural),
Uint(i) => i,
// if the idents are compared run-pass/issue-19244 fails
if let Some(f) = fields.iter().find(|f| f.name.node
== field_name.node) {
- return eval_const_expr_partial(tcx, &*f.expr, base_hint, fn_args)
+ return eval_const_expr_partial(tcx, &f.expr, base_hint, fn_args)
} else {
signal!(e, MissingStructField);
}
where V: Visitor<'ast>
{
match *self {
- InlinedItem::Item(ref i) => visitor.visit_item(&**i),
- InlinedItem::Foreign(ref i) => visitor.visit_foreign_item(&**i),
+ InlinedItem::Item(ref i) => visitor.visit_item(&i),
+ InlinedItem::Foreign(ref i) => visitor.visit_foreign_item(&i),
InlinedItem::TraitItem(_, ref ti) => visitor.visit_trait_item(ti),
InlinedItem::ImplItem(_, ref ii) => visitor.visit_impl_item(ii),
}
.contains(&attr::ReprExtern)
});
- intravisit::walk_item(self, &*item);
+ intravisit::walk_item(self, &item);
}
hir::ItemEnum(..) => {
self.inherited_pub_visibility = item.vis == hir::Public;
- intravisit::walk_item(self, &*item);
+ intravisit::walk_item(self, &item);
}
hir::ItemFn(..)
| hir::ItemTy(..)
| hir::ItemStatic(..)
| hir::ItemConst(..) => {
- intravisit::walk_item(self, &*item);
+ intravisit::walk_item(self, &item);
}
_ => ()
}
intravisit::walk_impl_item(self, impl_item);
}
ast_map::NodeForeignItem(foreign_item) => {
- intravisit::walk_foreign_item(self, &*foreign_item);
+ intravisit::walk_foreign_item(self, &foreign_item);
}
_ => ()
}
self.lookup_and_handle_method(expr.id);
}
hir::ExprField(ref lhs, ref name) => {
- self.handle_field_access(&**lhs, name.node);
+ self.handle_field_access(&lhs, name.node);
}
hir::ExprTupField(ref lhs, idx) => {
- self.handle_tup_field_access(&**lhs, idx.node);
+ self.handle_tup_field_access(&lhs, idx.node);
}
_ => ()
}
// necessary for the pattern to match. Those construction sites
// can't be reached unless the variant is constructed elsewhere.
let len = self.ignore_variant_stack.len();
- self.ignore_variant_stack.extend_from_slice(&*variants);
+ self.ignore_variant_stack.extend_from_slice(&variants);
intravisit::walk_arm(self, arm);
self.ignore_variant_stack.truncate(len);
} else {
ty::ReScope(fn_body_scope), // Args live only as long as the fn body.
arg_ty);
- self.walk_irrefutable_pat(arg_cmt, &*arg.pat);
+ self.walk_irrefutable_pat(arg_cmt, &arg.pat);
}
}
fn consume_exprs(&mut self, exprs: &[P<hir::Expr>]) {
for expr in exprs {
- self.consume_expr(&**expr);
+ self.consume_expr(&expr);
}
}
hir::ExprPath(..) => { }
hir::ExprType(ref subexpr, _) => {
- self.walk_expr(&**subexpr)
+ self.walk_expr(&subexpr)
}
hir::ExprUnary(hir::UnDeref, ref base) => { // *base
- if !self.walk_overloaded_operator(expr, &**base, Vec::new(), PassArgs::ByRef) {
- self.select_from_expr(&**base);
+ if !self.walk_overloaded_operator(expr, &base, Vec::new(), PassArgs::ByRef) {
+ self.select_from_expr(&base);
}
}
hir::ExprField(ref base, _) => { // base.f
- self.select_from_expr(&**base);
+ self.select_from_expr(&base);
}
hir::ExprTupField(ref base, _) => { // base.<n>
- self.select_from_expr(&**base);
+ self.select_from_expr(&base);
}
hir::ExprIndex(ref lhs, ref rhs) => { // lhs[rhs]
if !self.walk_overloaded_operator(expr,
- &**lhs,
- vec![&**rhs],
+ &lhs,
+ vec![&rhs],
PassArgs::ByValue) {
- self.select_from_expr(&**lhs);
- self.consume_expr(&**rhs);
+ self.select_from_expr(&lhs);
+ self.consume_expr(&rhs);
}
}
hir::ExprRange(ref start, ref end) => {
- start.as_ref().map(|e| self.consume_expr(&**e));
- end.as_ref().map(|e| self.consume_expr(&**e));
+ start.as_ref().map(|e| self.consume_expr(&e));
+ end.as_ref().map(|e| self.consume_expr(&e));
}
hir::ExprCall(ref callee, ref args) => { // callee(args)
- self.walk_callee(expr, &**callee);
+ self.walk_callee(expr, &callee);
self.consume_exprs(args);
}
}
hir::ExprIf(ref cond_expr, ref then_blk, ref opt_else_expr) => {
- self.consume_expr(&**cond_expr);
- self.walk_block(&**then_blk);
+ self.consume_expr(&cond_expr);
+ self.walk_block(&then_blk);
if let Some(ref else_expr) = *opt_else_expr {
- self.consume_expr(&**else_expr);
+ self.consume_expr(&else_expr);
}
}
hir::ExprMatch(ref discr, ref arms, _) => {
- let discr_cmt = return_if_err!(self.mc.cat_expr(&**discr));
- self.borrow_expr(&**discr, ty::ReEmpty, ty::ImmBorrow, MatchDiscriminant);
+ let discr_cmt = return_if_err!(self.mc.cat_expr(&discr));
+ self.borrow_expr(&discr, ty::ReEmpty, ty::ImmBorrow, MatchDiscriminant);
// treatment of the discriminant is handled while walking the arms.
for arm in arms {
let expr_ty = return_if_err!(self.typer.node_ty(expr.id));
if let ty::TyRef(&r, _) = expr_ty.sty {
let bk = ty::BorrowKind::from_mutbl(m);
- self.borrow_expr(&**base, r, bk, AddrOf);
+ self.borrow_expr(&base, r, bk, AddrOf);
}
}
hir::ExprInlineAsm(ref ia) => {
for &(_, ref input) in &ia.inputs {
- self.consume_expr(&**input);
+ self.consume_expr(&input);
}
for output in &ia.outputs {
if output.is_indirect {
- self.consume_expr(&*output.expr);
+ self.consume_expr(&output.expr);
} else {
- self.mutate_expr(expr, &*output.expr,
+ self.mutate_expr(expr, &output.expr,
if output.is_rw {
MutateMode::WriteAndRead
} else {
hir::ExprLit(..) => {}
hir::ExprLoop(ref blk, _) => {
- self.walk_block(&**blk);
+ self.walk_block(&blk);
}
hir::ExprWhile(ref cond_expr, ref blk, _) => {
- self.consume_expr(&**cond_expr);
- self.walk_block(&**blk);
+ self.consume_expr(&cond_expr);
+ self.walk_block(&blk);
}
hir::ExprUnary(op, ref lhs) => {
PassArgs::ByRef
};
- if !self.walk_overloaded_operator(expr, &**lhs, Vec::new(), pass_args) {
- self.consume_expr(&**lhs);
+ if !self.walk_overloaded_operator(expr, &lhs, Vec::new(), pass_args) {
+ self.consume_expr(&lhs);
}
}
PassArgs::ByRef
};
- if !self.walk_overloaded_operator(expr, &**lhs, vec![&**rhs], pass_args) {
- self.consume_expr(&**lhs);
- self.consume_expr(&**rhs);
+ if !self.walk_overloaded_operator(expr, &lhs, vec![&rhs], pass_args) {
+ self.consume_expr(&lhs);
+ self.consume_expr(&rhs);
}
}
hir::ExprBlock(ref blk) => {
- self.walk_block(&**blk);
+ self.walk_block(&blk);
}
hir::ExprRet(ref opt_expr) => {
if let Some(ref expr) = *opt_expr {
- self.consume_expr(&**expr);
+ self.consume_expr(&expr);
}
}
hir::ExprAssign(ref lhs, ref rhs) => {
- self.mutate_expr(expr, &**lhs, MutateMode::JustWrite);
- self.consume_expr(&**rhs);
+ self.mutate_expr(expr, &lhs, MutateMode::JustWrite);
+ self.consume_expr(&rhs);
}
hir::ExprCast(ref base, _) => {
- self.consume_expr(&**base);
+ self.consume_expr(&base);
}
hir::ExprAssignOp(op, ref lhs, ref rhs) => {
assert!(::rustc_front::util::is_by_value_binop(op.node));
if !self.walk_overloaded_operator(expr, lhs, vec![rhs], PassArgs::ByValue) {
- self.mutate_expr(expr, &**lhs, MutateMode::WriteAndRead);
- self.consume_expr(&**rhs);
+ self.mutate_expr(expr, &lhs, MutateMode::WriteAndRead);
+ self.consume_expr(&rhs);
}
}
hir::ExprRepeat(ref base, ref count) => {
- self.consume_expr(&**base);
- self.consume_expr(&**count);
+ self.consume_expr(&base);
+ self.consume_expr(&count);
}
hir::ExprClosure(..) => {
}
hir::ExprBox(ref base) => {
- self.consume_expr(&**base);
+ self.consume_expr(&base);
}
}
}
hir::StmtDecl(ref decl, _) => {
match decl.node {
hir::DeclLocal(ref local) => {
- self.walk_local(&**local);
+ self.walk_local(&local);
}
hir::DeclItem(_) => {
hir::StmtExpr(ref expr, _) |
hir::StmtSemi(ref expr, _) => {
- self.consume_expr(&**expr);
+ self.consume_expr(&expr);
}
}
}
match local.init {
None => {
let delegate = &mut self.delegate;
- pat_util::pat_bindings(&self.typer.tcx.def_map, &*local.pat,
+ pat_util::pat_bindings(&self.typer.tcx.def_map, &local.pat,
|_, id, span, _| {
delegate.decl_without_init(id, span);
})
// initializers are considered
// "assigns", which is handled by
// `walk_pat`:
- self.walk_expr(&**expr);
- let init_cmt = return_if_err!(self.mc.cat_expr(&**expr));
- self.walk_irrefutable_pat(init_cmt, &*local.pat);
+ self.walk_expr(&expr);
+ let init_cmt = return_if_err!(self.mc.cat_expr(&expr));
+ self.walk_irrefutable_pat(init_cmt, &local.pat);
}
}
}
}
if let Some(ref tail_expr) = blk.expr {
- self.consume_expr(&**tail_expr);
+ self.consume_expr(&tail_expr);
}
}
opt_with: &Option<P<hir::Expr>>) {
// Consume the expressions supplying values for each field.
for field in fields {
- self.consume_expr(&*field.expr);
+ self.consume_expr(&field.expr);
}
let with_expr = match *opt_with {
None => { return; }
};
- let with_cmt = return_if_err!(self.mc.cat_expr(&*with_expr));
+ let with_cmt = return_if_err!(self.mc.cat_expr(&with_expr));
// Select just those fields of the `with`
// expression that will actually be used
fn arm_move_mode(&mut self, discr_cmt: mc::cmt<'tcx>, arm: &hir::Arm) -> TrackMatchMode {
let mut mode = Unknown;
for pat in &arm.pats {
- self.determine_pat_move_mode(discr_cmt.clone(), &**pat, &mut mode);
+ self.determine_pat_move_mode(discr_cmt.clone(), &pat, &mut mode);
}
mode
}
fn walk_arm(&mut self, discr_cmt: mc::cmt<'tcx>, arm: &hir::Arm, mode: MatchMode) {
for pat in &arm.pats {
- self.walk_pat(discr_cmt.clone(), &**pat, mode);
+ self.walk_pat(discr_cmt.clone(), &pat, mode);
}
if let Some(ref guard) = arm.guard {
- self.consume_expr(&**guard);
+ self.consume_expr(&guard);
}
- self.consume_expr(&*arm.body);
+ self.consume_expr(&arm.body);
}
/// Walks a pat that occurs in isolation (i.e. top-level of fn
// matched.
let (slice_cmt, slice_mutbl, slice_r) =
- return_if_err!(mc.cat_slice_pattern(cmt_pat, &**slice_pat));
+ return_if_err!(mc.cat_slice_pattern(cmt_pat, &slice_pat));
// Note: We declare here that the borrow
// occurs upon entering the `[...]`
_ => "expression",
},
Some(ast_map::NodeStmt(_)) => "statement",
- Some(ast_map::NodeItem(it)) => item_scope_tag(&*it),
+ Some(ast_map::NodeItem(it)) => item_scope_tag(&it),
Some(_) | None => {
err.span_note(span, &unknown_scope());
return;
(format!("{} {}", prefix, msg), opt_span)
}
Some(ast_map::NodeItem(it)) => {
- let tag = item_scope_tag(&*it);
+ let tag = item_scope_tag(&it);
let (msg, opt_span) = explain_span(self, tag, it.span);
(format!("{} {}", prefix, msg), opt_span)
}
-> hir::HirVec<hir::Arg> {
let mut new_inputs = Vec::new();
for arg in inputs {
- let new_ty = self.rebuild_arg_ty_or_output(&*arg.ty, lifetime,
+ let new_ty = self.rebuild_arg_ty_or_output(&arg.ty, lifetime,
anon_nums, region_names);
let possibly_new_arg = hir::Arg {
ty: new_ty,
region_names: &HashSet<ast::Name>) -> hir::FunctionRetTy {
match *ty {
hir::Return(ref ret_ty) => hir::Return(
- self.rebuild_arg_ty_or_output(&**ret_ty, lifetime, anon_nums, region_names)
+ self.rebuild_arg_ty_or_output(&ret_ty, lifetime, anon_nums, region_names)
),
hir::DefaultReturn(span) => hir::DefaultReturn(span),
hir::NoReturn(span) => hir::NoReturn(span)
};
new_ty = self.rebuild_ty(new_ty, P(to));
}
- ty_queue.push(&*mut_ty.ty);
+ ty_queue.push(&mut_ty.ty);
}
hir::TyPath(ref maybe_qself, ref path) => {
let a_def = match self.tcx.def_map.borrow().get(&cur_ty.id) {
}
hir::TyPtr(ref mut_ty) => {
- ty_queue.push(&*mut_ty.ty);
+ ty_queue.push(&mut_ty.ty);
}
hir::TyVec(ref ty) |
hir::TyFixedLengthVec(ref ty, _) => {
- ty_queue.push(&**ty);
+ ty_queue.push(&ty);
}
hir::TyTup(ref tys) => ty_queue.extend(tys.iter().map(|ty| &**ty)),
_ => {}
}
}
let new_types = data.types.iter().map(|t| {
- self.rebuild_arg_ty_or_output(&**t, lifetime, anon_nums, region_names)
+ self.rebuild_arg_ty_or_output(&t, lifetime, anon_nums, region_names)
}).collect();
let new_bindings = data.bindings.iter().map(|b| {
hir::TypeBinding {
id: b.id,
name: b.name,
- ty: self.rebuild_arg_ty_or_output(&*b.ty,
+ ty: self.rebuild_arg_ty_or_output(&b.ty,
lifetime,
anon_nums,
region_names),
let output_path = {
let output_template = match requested_output {
- Ok(ref s) if &**s == "help" => {
+ Ok(ref s) if s == "help" => {
static PRINTED_YET: AtomicBool = AtomicBool::new(false);
if !PRINTED_YET.load(Ordering::SeqCst) {
print_help_message();
for arg in &decl.inputs {
pat_util::pat_bindings(&ir.tcx.def_map,
- &*arg.pat,
+ &arg.pat,
|_bm, arg_id, _x, path1| {
debug!("adding argument {}", arg_id);
let name = path1.node;
}
fn visit_local(ir: &mut IrMaps, local: &hir::Local) {
- pat_util::pat_bindings(&ir.tcx.def_map, &*local.pat, |_, p_id, sp, path1| {
+ pat_util::pat_bindings(&ir.tcx.def_map, &local.pat, |_, p_id, sp, path1| {
debug!("adding local variable {}", p_id);
let name = path1.node;
ir.add_live_node_for_node(p_id, VarDefNode(sp));
fn visit_arm(ir: &mut IrMaps, arm: &hir::Arm) {
for pat in &arm.pats {
- pat_util::pat_bindings(&ir.tcx.def_map, &**pat, |bm, p_id, sp, path1| {
+ pat_util::pat_bindings(&ir.tcx.def_map, &pat, |bm, p_id, sp, path1| {
debug!("adding local variable {} from match with bm {:?}",
p_id, bm);
let name = path1.node;
-> LiveNode {
match stmt.node {
hir::StmtDecl(ref decl, _) => {
- self.propagate_through_decl(&**decl, succ)
+ self.propagate_through_decl(&decl, succ)
}
hir::StmtExpr(ref expr, _) | hir::StmtSemi(ref expr, _) => {
- self.propagate_through_expr(&**expr, succ)
+ self.propagate_through_expr(&expr, succ)
}
}
}
-> LiveNode {
match decl.node {
hir::DeclLocal(ref local) => {
- self.propagate_through_local(&**local, succ)
+ self.propagate_through_local(&local, succ)
}
hir::DeclItem(_) => succ,
}
// once at the func header but otherwise equivalent.
let succ = self.propagate_through_opt_expr(local.init.as_ref().map(|e| &**e), succ);
- self.define_bindings_in_pat(&*local.pat, succ)
+ self.define_bindings_in_pat(&local.pat, succ)
}
fn propagate_through_exprs(&mut self, exprs: &[P<Expr>], succ: LiveNode)
-> LiveNode {
exprs.iter().rev().fold(succ, |succ, expr| {
- self.propagate_through_expr(&**expr, succ)
+ self.propagate_through_expr(&expr, succ)
})
}
}
hir::ExprField(ref e, _) => {
- self.propagate_through_expr(&**e, succ)
+ self.propagate_through_expr(&e, succ)
}
hir::ExprTupField(ref e, _) => {
- self.propagate_through_expr(&**e, succ)
+ self.propagate_through_expr(&e, succ)
}
hir::ExprClosure(_, _, ref blk) => {
// ( succ )
//
let else_ln = self.propagate_through_opt_expr(els.as_ref().map(|e| &**e), succ);
- let then_ln = self.propagate_through_block(&**then, succ);
+ let then_ln = self.propagate_through_block(&then, succ);
let ln = self.live_node(expr.id, expr.span);
self.init_from_succ(ln, else_ln);
self.merge_from_succ(ln, then_ln, false);
- self.propagate_through_expr(&**cond, ln)
+ self.propagate_through_expr(&cond, ln)
}
hir::ExprWhile(ref cond, ref blk, _) => {
- self.propagate_through_loop(expr, WhileLoop(&**cond), &**blk, succ)
+ self.propagate_through_loop(expr, WhileLoop(&cond), &blk, succ)
}
// Note that labels have been resolved, so we don't need to look
// at the label ident
hir::ExprLoop(ref blk, _) => {
- self.propagate_through_loop(expr, LoopLoop, &**blk, succ)
+ self.propagate_through_loop(expr, LoopLoop, &blk, succ)
}
hir::ExprMatch(ref e, ref arms, _) => {
let mut first_merge = true;
for arm in arms {
let body_succ =
- self.propagate_through_expr(&*arm.body, succ);
+ self.propagate_through_expr(&arm.body, succ);
let guard_succ =
self.propagate_through_opt_expr(arm.guard.as_ref().map(|e| &**e), body_succ);
// only consider the first pattern; any later patterns must have
self.merge_from_succ(ln, arm_succ, first_merge);
first_merge = false;
};
- self.propagate_through_expr(&**e, ln)
+ self.propagate_through_expr(&e, ln)
}
hir::ExprRet(ref o_e) => {
hir::ExprAssign(ref l, ref r) => {
// see comment on lvalues in
// propagate_through_lvalue_components()
- let succ = self.write_lvalue(&**l, succ, ACC_WRITE);
- let succ = self.propagate_through_lvalue_components(&**l, succ);
- self.propagate_through_expr(&**r, succ)
+ let succ = self.write_lvalue(&l, succ, ACC_WRITE);
+ let succ = self.propagate_through_lvalue_components(&l, succ);
+ self.propagate_through_expr(&r, succ)
}
hir::ExprAssignOp(_, ref l, ref r) => {
// see comment on lvalues in
// propagate_through_lvalue_components()
- let succ = self.write_lvalue(&**l, succ, ACC_WRITE|ACC_READ);
- let succ = self.propagate_through_expr(&**r, succ);
- self.propagate_through_lvalue_components(&**l, succ)
+ let succ = self.write_lvalue(&l, succ, ACC_WRITE|ACC_READ);
+ let succ = self.propagate_through_expr(&r, succ);
+ self.propagate_through_lvalue_components(&l, succ)
}
// Uninteresting cases: just propagate in rev exec order
}
hir::ExprRepeat(ref element, ref count) => {
- let succ = self.propagate_through_expr(&**count, succ);
- self.propagate_through_expr(&**element, succ)
+ let succ = self.propagate_through_expr(&count, succ);
+ self.propagate_through_expr(&element, succ)
}
hir::ExprStruct(_, ref fields, ref with_expr) => {
let succ = self.propagate_through_opt_expr(with_expr.as_ref().map(|e| &**e), succ);
fields.iter().rev().fold(succ, |succ, field| {
- self.propagate_through_expr(&*field.expr, succ)
+ self.propagate_through_expr(&field.expr, succ)
})
}
hir::ExprCall(ref f, ref args) => {
let diverges = !self.ir.tcx.is_method_call(expr.id) &&
- self.ir.tcx.expr_ty_adjusted(&**f).fn_ret().diverges();
+ self.ir.tcx.expr_ty_adjusted(&f).fn_ret().diverges();
let succ = if diverges {
self.s.exit_ln
} else {
succ
};
let succ = self.propagate_through_exprs(&args[..], succ);
- self.propagate_through_expr(&**f, succ)
+ self.propagate_through_expr(&f, succ)
}
hir::ExprMethodCall(_, _, ref args) => {
}
hir::ExprBinary(op, ref l, ref r) if ::rustc_front::util::lazy_binop(op.node) => {
- let r_succ = self.propagate_through_expr(&**r, succ);
+ let r_succ = self.propagate_through_expr(&r, succ);
let ln = self.live_node(expr.id, expr.span);
self.init_from_succ(ln, succ);
self.merge_from_succ(ln, r_succ, false);
- self.propagate_through_expr(&**l, ln)
+ self.propagate_through_expr(&l, ln)
}
hir::ExprIndex(ref l, ref r) |
hir::ExprBinary(_, ref l, ref r) => {
- let r_succ = self.propagate_through_expr(&**r, succ);
- self.propagate_through_expr(&**l, r_succ)
+ let r_succ = self.propagate_through_expr(&r, succ);
+ self.propagate_through_expr(&l, r_succ)
}
hir::ExprRange(ref e1, ref e2) => {
- let succ = e2.as_ref().map_or(succ, |e| self.propagate_through_expr(&**e, succ));
- e1.as_ref().map_or(succ, |e| self.propagate_through_expr(&**e, succ))
+ let succ = e2.as_ref().map_or(succ, |e| self.propagate_through_expr(&e, succ));
+ e1.as_ref().map_or(succ, |e| self.propagate_through_expr(&e, succ))
}
hir::ExprBox(ref e) |
hir::ExprCast(ref e, _) |
hir::ExprType(ref e, _) |
hir::ExprUnary(_, ref e) => {
- self.propagate_through_expr(&**e, succ)
+ self.propagate_through_expr(&e, succ)
}
hir::ExprInlineAsm(ref ia) => {
// see comment on lvalues
// in propagate_through_lvalue_components()
if out.is_indirect {
- self.propagate_through_expr(&*out.expr, succ)
+ self.propagate_through_expr(&out.expr, succ)
} else {
let acc = if out.is_rw { ACC_WRITE|ACC_READ } else { ACC_WRITE };
- let succ = self.write_lvalue(&*out.expr, succ, acc);
- self.propagate_through_lvalue_components(&*out.expr, succ)
+ let succ = self.write_lvalue(&out.expr, succ, acc);
+ self.propagate_through_lvalue_components(&out.expr, succ)
}
}
);
// Inputs are executed first. Propagate last because of rev order
ia.inputs.iter().rev().fold(succ, |succ, &(_, ref expr)| {
- self.propagate_through_expr(&**expr, succ)
+ self.propagate_through_expr(&expr, succ)
})
}
}
hir::ExprBlock(ref blk) => {
- self.propagate_through_block(&**blk, succ)
+ self.propagate_through_block(&blk, succ)
}
}
}
match expr.node {
hir::ExprPath(..) => succ,
- hir::ExprField(ref e, _) => self.propagate_through_expr(&**e, succ),
- hir::ExprTupField(ref e, _) => self.propagate_through_expr(&**e, succ),
+ hir::ExprField(ref e, _) => self.propagate_through_expr(&e, succ),
+ hir::ExprTupField(ref e, _) => self.propagate_through_expr(&e, succ),
_ => self.propagate_through_expr(expr, succ)
}
}
let cond_ln = match kind {
LoopLoop => ln,
- WhileLoop(ref cond) => self.propagate_through_expr(&**cond, ln),
+ WhileLoop(ref cond) => self.propagate_through_expr(&cond, ln),
};
let body_ln = self.with_loop_nodes(expr.id, succ, ln, |this| {
this.propagate_through_block(body, cond_ln)
let new_cond_ln = match kind {
LoopLoop => ln,
WhileLoop(ref cond) => {
- self.propagate_through_expr(&**cond, ln)
+ self.propagate_through_expr(&cond, ln)
}
};
assert!(cond_ln == new_cond_ln);
fn check_local(this: &mut Liveness, local: &hir::Local) {
match local.init {
Some(_) => {
- this.warn_about_unused_or_dead_vars_in_pat(&*local.pat);
+ this.warn_about_unused_or_dead_vars_in_pat(&local.pat);
},
None => {
- this.pat_bindings(&*local.pat, |this, ln, var, sp, id| {
+ this.pat_bindings(&local.pat, |this, ln, var, sp, id| {
this.warn_about_unused(sp, id, ln, var);
})
}
fn check_expr(this: &mut Liveness, expr: &Expr) {
match expr.node {
hir::ExprAssign(ref l, _) => {
- this.check_lvalue(&**l);
+ this.check_lvalue(&l);
intravisit::walk_expr(this, expr);
}
hir::ExprAssignOp(_, ref l, _) => {
- this.check_lvalue(&**l);
+ this.check_lvalue(&l);
intravisit::walk_expr(this, expr);
}
hir::ExprInlineAsm(ref ia) => {
for &(_, ref input) in &ia.inputs {
- this.visit_expr(&**input);
+ this.visit_expr(&input);
}
// Output operands must be lvalues
for out in &ia.outputs {
if !out.is_indirect {
- this.check_lvalue(&*out.expr);
+ this.check_lvalue(&out.expr);
}
- this.visit_expr(&*out.expr);
+ this.visit_expr(&out.expr);
}
intravisit::walk_expr(this, expr);
None if !body.stmts.is_empty() =>
match body.stmts.first().unwrap().node {
hir::StmtSemi(ref e, _) => {
- self.ir.tcx.expr_ty(&**e) == t_ret
+ self.ir.tcx.expr_ty(&e) == t_ret
},
_ => false
},
fn warn_about_unused_args(&self, decl: &hir::FnDecl, entry_ln: LiveNode) {
for arg in &decl.inputs {
pat_util::pat_bindings(&self.ir.tcx.def_map,
- &*arg.pat,
+ &arg.pat,
|_bm, p_id, sp, path1| {
let var = self.variable(p_id, sp);
// Ignore unused self.
let expr_ty = try!(self.expr_ty(expr));
match expr.node {
hir::ExprUnary(hir::UnDeref, ref e_base) => {
- let base_cmt = try!(self.cat_expr(&**e_base));
+ let base_cmt = try!(self.cat_expr(&e_base));
self.cat_deref(expr, base_cmt, 0, None)
}
hir::ExprField(ref base, f_name) => {
- let base_cmt = try!(self.cat_expr(&**base));
+ let base_cmt = try!(self.cat_expr(&base));
debug!("cat_expr(cat_field): id={} expr={:?} base={:?}",
expr.id,
expr,
}
hir::ExprTupField(ref base, idx) => {
- let base_cmt = try!(self.cat_expr(&**base));
+ let base_cmt = try!(self.cat_expr(&base));
Ok(self.cat_tup_field(expr, base_cmt, idx.node, expr_ty))
}
self.cat_deref_common(expr, base_cmt, 1, elem_ty, Some(context), true)
}
None => {
- self.cat_index(expr, try!(self.cat_expr(&**base)), context)
+ self.cat_index(expr, try!(self.cat_expr(&base)), context)
}
}
}
}
hir::ExprType(ref e, _) => {
- self.cat_expr(&**e)
+ self.cat_expr(&e)
}
hir::ExprAddrOf(..) | hir::ExprCall(..) |
None => {
self.tcx().sess.span_bug(
span,
- &*format!("No closure kind for {:?}", closure_id));
+ &format!("No closure kind for {:?}", closure_id));
}
}
}
Some(Def::Variant(..)) => {
// variant(x, y, z)
for (i, subpat) in subpats.iter().enumerate() {
- let subpat_ty = try!(self.pat_ty(&**subpat)); // see (*2)
+ let subpat_ty = try!(self.pat_ty(&subpat)); // see (*2)
let subcmt =
self.cat_imm_interior(
pat, cmt.clone(), subpat_ty,
InteriorField(PositionalField(i)));
- try!(self.cat_pattern_(subcmt, &**subpat, op));
+ try!(self.cat_pattern_(subcmt, &subpat, op));
}
}
Some(Def::Struct(..)) => {
for (i, subpat) in subpats.iter().enumerate() {
- let subpat_ty = try!(self.pat_ty(&**subpat)); // see (*2)
+ let subpat_ty = try!(self.pat_ty(&subpat)); // see (*2)
let cmt_field =
self.cat_imm_interior(
pat, cmt.clone(), subpat_ty,
InteriorField(PositionalField(i)));
- try!(self.cat_pattern_(cmt_field, &**subpat, op));
+ try!(self.cat_pattern_(cmt_field, &subpat, op));
}
}
Some(Def::Const(..)) | Some(Def::AssociatedConst(..)) => {
for subpat in subpats {
- try!(self.cat_pattern_(cmt.clone(), &**subpat, op));
+ try!(self.cat_pattern_(cmt.clone(), &subpat, op));
}
}
_ => {
}
hir::PatIdent(_, _, Some(ref subpat)) => {
- try!(self.cat_pattern_(cmt, &**subpat, op));
+ try!(self.cat_pattern_(cmt, &subpat, op));
}
hir::PatIdent(_, _, None) => {
hir::PatStruct(_, ref field_pats, _) => {
// {f1: p1, ..., fN: pN}
for fp in field_pats {
- let field_ty = try!(self.pat_ty(&*fp.node.pat)); // see (*2)
+ let field_ty = try!(self.pat_ty(&fp.node.pat)); // see (*2)
let cmt_field = self.cat_field(pat, cmt.clone(), fp.node.name, field_ty);
- try!(self.cat_pattern_(cmt_field, &*fp.node.pat, op));
+ try!(self.cat_pattern_(cmt_field, &fp.node.pat, op));
}
}
hir::PatTup(ref subpats) => {
// (p1, ..., pN)
for (i, subpat) in subpats.iter().enumerate() {
- let subpat_ty = try!(self.pat_ty(&**subpat)); // see (*2)
+ let subpat_ty = try!(self.pat_ty(&subpat)); // see (*2)
let subcmt =
self.cat_imm_interior(
pat, cmt.clone(), subpat_ty,
InteriorField(PositionalField(i)));
- try!(self.cat_pattern_(subcmt, &**subpat, op));
+ try!(self.cat_pattern_(subcmt, &subpat, op));
}
}
// PatRegion since that information is already contained
// in the type.
let subcmt = try!(self.cat_deref(pat, cmt, 0, None));
- try!(self.cat_pattern_(subcmt, &**subpat, op));
+ try!(self.cat_pattern_(subcmt, &subpat, op));
}
hir::PatVec(ref before, ref slice, ref after) => {
let vec_cmt = try!(self.deref_vec(pat, cmt, context));
let elt_cmt = try!(self.cat_index(pat, vec_cmt, context));
for before_pat in before {
- try!(self.cat_pattern_(elt_cmt.clone(), &**before_pat, op));
+ try!(self.cat_pattern_(elt_cmt.clone(), &before_pat, op));
}
if let Some(ref slice_pat) = *slice {
- let slice_ty = try!(self.pat_ty(&**slice_pat));
+ let slice_ty = try!(self.pat_ty(&slice_pat));
let slice_cmt = self.cat_rvalue_node(pat.id(), pat.span(), slice_ty);
- try!(self.cat_pattern_(slice_cmt, &**slice_pat, op));
+ try!(self.cat_pattern_(slice_cmt, &slice_pat, op));
}
for after_pat in after {
- try!(self.cat_pattern_(elt_cmt.clone(), &**after_pat, op));
+ try!(self.cat_pattern_(elt_cmt.clone(), &after_pat, op));
}
}
if let Some(impl_node_id) = tcx.map.as_local_node_id(impl_src) {
match tcx.map.find(impl_node_id) {
Some(ast_map::NodeItem(item)) =>
- item_might_be_inlined(&*item),
+ item_might_be_inlined(&item),
Some(..) | None =>
tcx.sess.span_bug(impl_item.span, "impl did is not an item")
}
match self.tcx.map.find(node_id) {
Some(ast_map::NodeItem(item)) => {
match item.node {
- hir::ItemFn(..) => item_might_be_inlined(&*item),
+ hir::ItemFn(..) => item_might_be_inlined(&item),
_ => false,
}
}
ast_map::NodeItem(item) => {
match item.node {
hir::ItemFn(_, _, _, _, _, ref search_block) => {
- if item_might_be_inlined(&*item) {
- intravisit::walk_block(self, &**search_block)
+ if item_might_be_inlined(&item) {
+ intravisit::walk_block(self, &search_block)
}
}
// unconditionally, so we need to make sure that their
// contents are also reachable.
hir::ItemConst(_, ref init) => {
- self.visit_expr(&**init);
+ self.visit_expr(&init);
}
// These are normal, nothing reachable about these
// Keep going, nothing to get exported
}
hir::ConstTraitItem(_, Some(ref expr)) => {
- self.visit_expr(&*expr);
+ self.visit_expr(&expr);
}
hir::MethodTraitItem(_, Some(ref body)) => {
intravisit::walk_block(self, body);
ast_map::NodeImplItem(impl_item) => {
match impl_item.node {
hir::ImplItemKind::Const(_, ref expr) => {
- self.visit_expr(&*expr);
+ self.visit_expr(&expr);
}
hir::ImplItemKind::Method(ref sig, ref body) => {
let did = self.tcx.map.get_parent_did(search_item);
match local.init {
Some(ref expr) => {
- record_rvalue_scope_if_borrow_expr(visitor, &**expr, blk_scope);
+ record_rvalue_scope_if_borrow_expr(visitor, &expr, blk_scope);
let is_borrow =
- if let Some(ref ty) = local.ty { is_borrowed_ty(&**ty) } else { false };
+ if let Some(ref ty) = local.ty { is_borrowed_ty(&ty) } else { false };
- if is_binding_pat(&*local.pat) || is_borrow {
- record_rvalue_scope(visitor, &**expr, blk_scope);
+ if is_binding_pat(&local.pat) || is_borrow {
+ record_rvalue_scope(visitor, &expr, blk_scope);
}
}
hir::PatIdent(hir::BindByRef(_), _, _) => true,
hir::PatStruct(_, ref field_pats, _) => {
- field_pats.iter().any(|fp| is_binding_pat(&*fp.node.pat))
+ field_pats.iter().any(|fp| is_binding_pat(&fp.node.pat))
}
hir::PatVec(ref pats1, ref pats2, ref pats3) => {
- pats1.iter().any(|p| is_binding_pat(&**p)) ||
- pats2.iter().any(|p| is_binding_pat(&**p)) ||
- pats3.iter().any(|p| is_binding_pat(&**p))
+ pats1.iter().any(|p| is_binding_pat(&p)) ||
+ pats2.iter().any(|p| is_binding_pat(&p)) ||
+ pats3.iter().any(|p| is_binding_pat(&p))
}
hir::PatEnum(_, Some(ref subpats)) |
hir::PatTup(ref subpats) => {
- subpats.iter().any(|p| is_binding_pat(&**p))
+ subpats.iter().any(|p| is_binding_pat(&p))
}
hir::PatBox(ref subpat) => {
- is_binding_pat(&**subpat)
+ is_binding_pat(&subpat)
}
_ => false,
blk_id: CodeExtent) {
match expr.node {
hir::ExprAddrOf(_, ref subexpr) => {
- record_rvalue_scope_if_borrow_expr(visitor, &**subexpr, blk_id);
- record_rvalue_scope(visitor, &**subexpr, blk_id);
+ record_rvalue_scope_if_borrow_expr(visitor, &subexpr, blk_id);
+ record_rvalue_scope(visitor, &subexpr, blk_id);
}
hir::ExprStruct(_, ref fields, _) => {
for field in fields {
record_rvalue_scope_if_borrow_expr(
- visitor, &*field.expr, blk_id);
+ visitor, &field.expr, blk_id);
}
}
hir::ExprVec(ref subexprs) |
hir::ExprTup(ref subexprs) => {
for subexpr in subexprs {
record_rvalue_scope_if_borrow_expr(
- visitor, &**subexpr, blk_id);
+ visitor, &subexpr, blk_id);
}
}
hir::ExprCast(ref subexpr, _) => {
- record_rvalue_scope_if_borrow_expr(visitor, &**subexpr, blk_id)
+ record_rvalue_scope_if_borrow_expr(visitor, &subexpr, blk_id)
}
hir::ExprBlock(ref block) => {
match block.expr {
Some(ref subexpr) => {
record_rvalue_scope_if_borrow_expr(
- visitor, &**subexpr, blk_id);
+ visitor, &subexpr, blk_id);
}
None => { }
}
hir::ExprField(ref subexpr, _) |
hir::ExprTupField(ref subexpr, _) |
hir::ExprIndex(ref subexpr, _) => {
- expr = &**subexpr;
+ expr = &subexpr;
}
_ => {
return;
for ty_param in generics.ty_params.iter() {
walk_list!(self, visit_ty_param_bound, &ty_param.bounds);
match ty_param.default {
- Some(ref ty) => self.visit_ty(&**ty),
+ Some(ref ty) => self.visit_ty(&ty),
None => {}
}
}
let result = self.with(LateScope(bound_lifetimes, self.scope),
|old_scope, this| {
this.check_lifetime_defs(old_scope, bound_lifetimes);
- this.visit_ty(&**bounded_ty);
+ this.visit_ty(&bounded_ty);
walk_list!(this, visit_ty_param_bound, bounds);
});
self.trait_ref_hack = false;
result
} else {
- self.visit_ty(&**bounded_ty);
+ self.visit_ty(&bounded_ty);
walk_list!(self, visit_ty_param_bound, bounds);
}
}
ref ty,
.. }) => {
self.visit_path(path, id);
- self.visit_ty(&**ty);
+ self.visit_ty(&ty);
}
}
}
&hir::WherePredicate::BoundPredicate(hir::WhereBoundPredicate{ref bounds,
ref bounded_ty,
..}) => {
- collector.visit_ty(&**bounded_ty);
+ collector.visit_ty(&bounded_ty);
walk_list!(&mut collector, visit_ty_param_bound, bounds);
}
&hir::WherePredicate::RegionPredicate(hir::WhereRegionPredicate{ref lifetime,
err,
&parent_predicate,
cause_span,
- &*data.parent_code);
+ &data.parent_code);
}
ObligationCauseCode::ImplDerivedObligation(ref data) => {
let parent_trait_ref = infcx.resolve_type_vars_if_possible(&data.parent_trait_ref);
err,
&parent_predicate,
cause_span,
- &*data.parent_code);
+ &data.parent_code);
}
ObligationCauseCode::CompareImplMethodObligation => {
err.fileline_note(
.filter_map(|item| {
match *item {
ty::MethodTraitItem(ref m) => {
- object_safety_violation_for_method(tcx, trait_def_id, &**m)
+ object_safety_violation_for_method(tcx, trait_def_id, &m)
.map(|code| ObjectSafetyViolation::Method(m.clone(), code))
}
_ => None,
p: p,
flag: false,
};
- intravisit::walk_block(&mut v, &*b);
+ intravisit::walk_block(&mut v, &b);
return v.flag;
}
projects / rust.git / commitdiff