all: remove unneeded deref and/or ref operations

birkenfeld · llogiq · commit b13d318f48f1 · 2015-08-25T17:35:20.000+02:00
diff --git a/src/attrs.rs b/src/attrs.rs
@@ -71,14 +71,14 @@ fn is_relevant_block(block: &Block) -> bool {
             _ => ()
         }
     }
-    block.expr.as_ref().map_or(false, |e| is_relevant_expr(&*e))
+    block.expr.as_ref().map_or(false, |e| is_relevant_expr(e))
 }
 
 fn is_relevant_expr(expr: &Expr) -> bool {
     match expr.node {
         ExprBlock(ref block) => is_relevant_block(block),
         ExprRet(Some(ref e)) | ExprParen(ref e) =>
-            is_relevant_expr(&*e),
+            is_relevant_expr(e),
         ExprRet(None) | ExprBreak(_) | ExprMac(_) => false,
         ExprCall(ref path_expr, _) => {
             if let ExprPath(_, ref path) = path_expr.node {
diff --git a/src/collapsible_if.rs b/src/collapsible_if.rs
@@ -79,7 +79,7 @@ fn single_stmt_of_block(block: &Block) -> Option<&Expr> {
         } else { None }
     } else {
         if block.stmts.is_empty() {
-            if let Some(ref p) = block.expr { Some(&*p) } else { None }
+            if let Some(ref p) = block.expr { Some(p) } else { None }
         } else { None }
     }
 }
diff --git a/src/consts.rs b/src/consts.rs
@@ -222,7 +222,7 @@ fn neg_float_str(s: String) -> String {
     if s.starts_with('-') {
         s[1..].to_owned()
     } else {
-        format!("-{}", &*s)
+        format!("-{}", s)
     }
 }
 
@@ -299,7 +299,7 @@ impl<'c, 'cc> ConstEvalContext<'c, 'cc> {
             ExprPath(_, _) => self.fetch_path(e),
             ExprBlock(ref block) => self.block(block),
             ExprIf(ref cond, ref then, ref otherwise) =>
-                self.ifthenelse(&*cond, &*then, &*otherwise),
+                self.ifthenelse(cond, then, otherwise),
             ExprLit(ref lit) => Some(lit_to_constant(&lit.node)),
             ExprVec(ref vec) => self.multi(vec).map(ConstantVec),
             ExprTup(ref tup) => self.multi(tup).map(ConstantTuple),
@@ -362,7 +362,7 @@ impl<'c, 'cc> ConstEvalContext<'c, 'cc> {
             if b {
                 self.block(then)
             } else {
-                otherwise.as_ref().and_then(|ref expr| self.expr(expr))
+                otherwise.as_ref().and_then(|expr| self.expr(expr))
             }
         } else { None }
     }
diff --git a/src/eta_reduction.rs b/src/eta_reduction.rs
@@ -22,7 +22,7 @@ impl LintPass for EtaPass {
             ExprCall(_, ref args) |
             ExprMethodCall(_, _, ref args) => {
                 for arg in args {
-                    check_closure(cx, &*arg)
+                    check_closure(cx, arg)
                 }
             },
             _ => (),
diff --git a/src/len_zero.rs b/src/len_zero.rs
@@ -102,7 +102,7 @@ fn check_len_zero(cx: &Context, span: Span, method: &SpannedIdent,
                   args: &[P<Expr>], lit: &Lit, op: &str) {
     if let Spanned{node: LitInt(0, _), ..} = *lit {
         if method.node.name == "len" && args.len() == 1 &&
-            has_is_empty(cx, &*args[0]) {
+            has_is_empty(cx, &args[0]) {
                 span_lint(cx, LEN_ZERO, span, &format!(
                     "consider replacing the len comparison with `{}{}.is_empty()`",
                     op, snippet(cx, args[0].span, "_")))
diff --git a/src/lifetimes.rs b/src/lifetimes.rs
@@ -26,14 +26,14 @@ impl LintPass for LifetimePass {
 
     fn check_impl_item(&mut self, cx: &Context, item: &ImplItem) {
         if let MethodImplItem(ref sig, _) = item.node {
-            check_fn_inner(cx, &*sig.decl, Some(&sig.explicit_self),
+            check_fn_inner(cx, &sig.decl, Some(&sig.explicit_self),
                            &sig.generics.lifetimes, item.span);
         }
     }
 
     fn check_trait_item(&mut self, cx: &Context, item: &TraitItem) {
         if let MethodTraitItem(ref sig, _) = item.node {
-            check_fn_inner(cx, &*sig.decl, Some(&sig.explicit_self),
+            check_fn_inner(cx, &sig.decl, Some(&sig.explicit_self),
                            &sig.generics.lifetimes, item.span);
         }
     }
@@ -92,7 +92,7 @@ fn could_use_elision(func: &FnDecl, slf: Option<&ExplicitSelf>,
     }
     // extract lifetimes in input argument types
     for arg in &func.inputs {
-        walk_ty(&mut input_visitor, &*arg.ty);
+        walk_ty(&mut input_visitor, &arg.ty);
     }
     // extract lifetimes in output type
     if let Return(ref ty) = func.output {
diff --git a/src/loops.rs b/src/loops.rs
@@ -95,9 +95,9 @@ fn recover_for_loop(expr: &Expr) -> Option<(&Pat, &Expr, &Expr)> {
             let PatEnum(_, Some(ref somepats)) = innerarms[0].pats[0].node,
             somepats.len() == 1
         ], {
-            return Some((&*somepats[0],
-                         &*iterargs[0],
-                         &*innerarms[0].body));
+            return Some((&somepats[0],
+                         &iterargs[0],
+                         &innerarms[0].body));
         }
     }
     None
diff --git a/src/matches.rs b/src/matches.rs
@@ -34,7 +34,7 @@ impl LintPass for MatchPass {
                 // when an enum is extended, so we don't consider these cases
                 arms[1].pats[0].node == PatWild(PatWildSingle) &&
                 // finally, we don't want any content in the second arm (unit or empty block)
-                is_unit_expr(&*arms[1].body)
+                is_unit_expr(&arms[1].body)
             {
                 let body_code = snippet_block(cx, arms[0].body.span, "..");
                 let body_code = if let ExprBlock(_) = arms[0].body.node {
@@ -46,10 +46,10 @@ impl LintPass for MatchPass {
                       "you seem to be trying to use match for \
                       destructuring a single pattern. Did you mean to \
                       use `if let`?",
-                      &*format!("try\nif let {} = {} {}",
-                                snippet(cx, arms[0].pats[0].span, ".."),
-                                snippet(cx, ex.span, ".."),
-                                body_code)
+                      &format!("try\nif let {} = {} {}",
+                               snippet(cx, arms[0].pats[0].span, ".."),
+                               snippet(cx, ex.span, ".."),
+                               body_code)
                 );
             }
 
diff --git a/src/methods.rs b/src/methods.rs
@@ -24,7 +24,7 @@ impl LintPass for MethodsPass {
 
     fn check_expr(&mut self, cx: &Context, expr: &Expr) {
         if let ExprMethodCall(ref ident, _, ref args) = expr.node {
-            let obj_ty = walk_ptrs_ty(cx.tcx.expr_ty(&*args[0]));
+            let obj_ty = walk_ptrs_ty(cx.tcx.expr_ty(&args[0]));
             if ident.node.name == "unwrap" {
                 if match_type(cx, obj_ty, &OPTION_PATH) {
                     span_lint(cx, OPTION_UNWRAP_USED, expr.span,
diff --git a/src/misc.rs b/src/misc.rs
@@ -203,7 +203,7 @@ fn check_to_owned(cx: &Context, expr: &Expr, other_span: Span) {
 
 fn is_str_arg(cx: &Context, args: &[P<Expr>]) -> bool {
     args.len() == 1 && if let ty::TyStr =
-        walk_ptrs_ty(cx.tcx.expr_ty(&*args[0])).sty { true } else { false }
+        walk_ptrs_ty(cx.tcx.expr_ty(&args[0])).sty { true } else { false }
 }
 
 declare_lint!(pub MODULO_ONE, Warn, "taking a number modulo 1, which always returns 0");
diff --git a/src/needless_bool.rs b/src/needless_bool.rs
@@ -5,7 +5,7 @@
 use rustc::lint::*;
 use syntax::ast::*;
 
-use utils::{de_p, span_lint, snippet};
+use utils::{span_lint, snippet};
 
 declare_lint! {
     pub NEEDLESS_BOOL,
@@ -55,7 +55,7 @@ impl LintPass for NeedlessBool {
 
 fn fetch_bool_block(block: &Block) -> Option<bool> {
     if block.stmts.is_empty() {
-        block.expr.as_ref().map(de_p).and_then(fetch_bool_expr)
+        block.expr.as_ref().and_then(|e| fetch_bool_expr(e))
     } else { None }
 }
 
diff --git a/src/ptr_arg.rs b/src/ptr_arg.rs
@@ -45,7 +45,7 @@ impl LintPass for PtrArg {
 
 fn check_fn(cx: &Context, decl: &FnDecl) {
     for arg in &decl.inputs {
-        if let Some(pat_ty) = cx.tcx.pat_ty_opt(&*arg.pat) {
+        if let Some(pat_ty) = cx.tcx.pat_ty_opt(&arg.pat) {
             if let ty::TyRef(_, ty::TypeAndMut { ty, mutbl: MutImmutable }) = pat_ty.sty {
                 if match_type(cx, ty, &VEC_PATH) {
                     span_lint(cx, PTR_ARG, arg.ty.span,
diff --git a/src/returns.rs b/src/returns.rs
@@ -50,7 +50,7 @@ impl ReturnPass {
             // a match expr, check all arms
             ExprMatch(_, ref arms, _) => {
                 for arm in arms {
-                    self.check_final_expr(cx, &*arm.body);
+                    self.check_final_expr(cx, &arm.body);
                 }
             }
             _ => { }
@@ -76,7 +76,7 @@ impl ReturnPass {
                 let PatIdent(_, Spanned { node: id, .. }, _) = local.pat.node,
                 let Some(ref retexpr) = block.expr,
                 let ExprPath(_, ref path) = retexpr.node,
-                match_path(path, &[&*id.name.as_str()])
+                match_path(path, &[&id.name.as_str()])
             ], {
                 self.emit_let_lint(cx, retexpr.span, initexpr.span);
             }
diff --git a/src/strings.rs b/src/strings.rs
@@ -70,8 +70,8 @@ fn is_add(cx: &Context, src: &Expr, target: &Expr) -> bool {
             is_exp_equal(cx, target, left),
         ExprBlock(ref block) => block.stmts.is_empty() &&
             block.expr.as_ref().map_or(false,
-                |expr| is_add(cx, &*expr, target)),
-        ExprParen(ref expr) => is_add(cx, &*expr, target),
+                |expr| is_add(cx, expr, target)),
+        ExprParen(ref expr) => is_add(cx, expr, target),
         _ => false
     }
 }
diff --git a/src/types.rs b/src/types.rs
@@ -55,7 +55,7 @@ declare_lint!(pub LET_UNIT_VALUE, Warn,
 fn check_let_unit(cx: &Context, decl: &Decl, info: Option<&ExpnInfo>) {
     if in_macro(cx, info) { return; }
     if let DeclLocal(ref local) = decl.node {
-        let bindtype = &cx.tcx.pat_ty(&*local.pat).sty;
+        let bindtype = &cx.tcx.pat_ty(&local.pat).sty;
         if *bindtype == ty::TyTuple(vec![]) {
             span_lint(cx, LET_UNIT_VALUE, decl.span, &format!(
                 "this let-binding has unit value. Consider omitting `let {} =`",
@@ -210,7 +210,7 @@ impl LintPass for CastPass {
 
     fn check_expr(&mut self, cx: &Context, expr: &Expr) {
         if let ExprCast(ref ex, _) = expr.node {
-            let (cast_from, cast_to) = (cx.tcx.expr_ty(&*ex), cx.tcx.expr_ty(expr));
+            let (cast_from, cast_to) = (cx.tcx.expr_ty(ex), cx.tcx.expr_ty(expr));
             if cast_from.is_numeric() && cast_to.is_numeric() && !in_external_macro(cx, expr.span) {
                 match (cast_from.is_integral(), cast_to.is_integral()) {
                     (true, false) => {
@@ -263,14 +263,14 @@ impl LintPass for TypeComplexityPass {
     }
 
     fn check_struct_field(&mut self, cx: &Context, field: &StructField) {
-        check_type(cx, &*field.node.ty);
+        check_type(cx, &field.node.ty);
     }
 
     fn check_variant(&mut self, cx: &Context, var: &Variant, _: &Generics) {
         // StructVariant is covered by check_struct_field
         if let TupleVariantKind(ref args) = var.node.kind {
             for arg in args {
-                check_type(cx, &*arg.ty);
+                check_type(cx, &arg.ty);
             }
         }
     }
@@ -312,7 +312,7 @@ impl LintPass for TypeComplexityPass {
 
 fn check_fndecl(cx: &Context, decl: &FnDecl) {
     for arg in &decl.inputs {
-        check_type(cx, &*arg.ty);
+        check_type(cx, &arg.ty);
     }
     if let Return(ref ty) = decl.output {
         check_type(cx, ty);
diff --git a/src/utils.rs b/src/utils.rs
@@ -1,7 +1,6 @@
 use rustc::lint::*;
 use syntax::ast::*;
 use syntax::codemap::{ExpnInfo, Span};
-use syntax::ptr::P;
 use rustc::ast_map::Node::NodeExpr;
 use rustc::middle::ty;
 use std::borrow::Cow;
@@ -130,9 +129,6 @@ pub fn get_parent_expr<'c>(cx: &'c Context, e: &Expr) -> Option<&'c Expr> {
         if let NodeExpr(parent) = node { Some(parent) } else { None } )
 }
 
-/// dereference a P<T> and return a ref on the result
-pub fn de_p<T>(p: &P<T>) -> &T { &*p }
-
 #[cfg(not(feature="structured_logging"))]
 pub fn span_lint(cx: &Context, lint: &'static Lint, sp: Span, msg: &str) {
     cx.span_lint(lint, sp, msg);

Original file line number	Diff line number	Diff line change
`@@ -71,14 +71,14 @@ fn is_relevant_block(block: &Block) -> bool {`
`71`	`71`	`_ => ()`
`72`	`72`	`}`
`73`	`73`	`}`
`74`		`- block.expr.as_ref().map_or(false, \|e\| is_relevant_expr(&*e))`
	`74`	`+ block.expr.as_ref().map_or(false, \|e\| is_relevant_expr(e))`
`75`	`75`	`}`
`76`	`76`
`77`	`77`	`fn is_relevant_expr(expr: &Expr) -> bool {`
`78`	`78`	`match expr.node {`
`79`	`79`	`ExprBlock(ref block) => is_relevant_block(block),`
`80`	`80`	`ExprRet(Some(ref e)) \| ExprParen(ref e) =>`
`81`		`- is_relevant_expr(&*e),`
	`81`	`+ is_relevant_expr(e),`
`82`	`82`	`ExprRet(None) \| ExprBreak(_) \| ExprMac(_) => false,`
`83`	`83`	`ExprCall(ref path_expr, _) => {`
`84`	`84`	`if let ExprPath(_, ref path) = path_expr.node {`
Original file line number	Diff line number	Diff line change
`@@ -79,7 +79,7 @@ fn single_stmt_of_block(block: &Block) -> Option<&Expr> {`
`79`	`79`	`} else { None }`
`80`	`80`	`} else {`
`81`	`81`	`if block.stmts.is_empty() {`
`82`		`- if let Some(ref p) = block.expr { Some(&*p) } else { None }`
	`82`	`+ if let Some(ref p) = block.expr { Some(p) } else { None }`
`83`	`83`	`} else { None }`
`84`	`84`	`}`
`85`	`85`	`}`
Original file line number	Diff line number	Diff line change
`@@ -222,7 +222,7 @@ fn neg_float_str(s: String) -> String {`
`222`	`222`	`if s.starts_with('-') {`
`223`	`223`	`s[1..].to_owned()`
`224`	`224`	`} else {`
`225`		`- format!("-{}", &*s)`
	`225`	`+ format!("-{}", s)`
`226`	`226`	`}`
`227`	`227`	`}`
`228`	`228`
`@@ -299,7 +299,7 @@ impl<'c, 'cc> ConstEvalContext<'c, 'cc> {`
`299`	`299`	`ExprPath(_, _) => self.fetch_path(e),`
`300`	`300`	`ExprBlock(ref block) => self.block(block),`
`301`	`301`	`ExprIf(ref cond, ref then, ref otherwise) =>`
`302`		`- self.ifthenelse(&cond, &then, &*otherwise),`
	`302`	`+ self.ifthenelse(cond, then, otherwise),`
`303`	`303`	`ExprLit(ref lit) => Some(lit_to_constant(&lit.node)),`
`304`	`304`	`ExprVec(ref vec) => self.multi(vec).map(ConstantVec),`
`305`	`305`	`ExprTup(ref tup) => self.multi(tup).map(ConstantTuple),`
`@@ -362,7 +362,7 @@ impl<'c, 'cc> ConstEvalContext<'c, 'cc> {`
`362`	`362`	`if b {`
`363`	`363`	`self.block(then)`
`364`	`364`	`} else {`
`365`		`- otherwise.as_ref().and_then(\|ref expr\| self.expr(expr))`
	`365`	`+ otherwise.as_ref().and_then(\|expr\| self.expr(expr))`
`366`	`366`	`}`
`367`	`367`	`} else { None }`
`368`	`368`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ impl LintPass for EtaPass {`
`22`	`22`	`ExprCall(_, ref args) \|`
`23`	`23`	`ExprMethodCall(_, _, ref args) => {`
`24`	`24`	`for arg in args {`
`25`		`- check_closure(cx, &*arg)`
	`25`	`+ check_closure(cx, arg)`
`26`	`26`	`}`
`27`	`27`	`},`
`28`	`28`	`_ => (),`
Original file line number	Diff line number	Diff line change
`@@ -26,14 +26,14 @@ impl LintPass for LifetimePass {`
`26`	`26`
`27`	`27`	`fn check_impl_item(&mut self, cx: &Context, item: &ImplItem) {`
`28`	`28`	`if let MethodImplItem(ref sig, _) = item.node {`
`29`		`- check_fn_inner(cx, &*sig.decl, Some(&sig.explicit_self),`
	`29`	`+ check_fn_inner(cx, &sig.decl, Some(&sig.explicit_self),`
`30`	`30`	`&sig.generics.lifetimes, item.span);`
`31`	`31`	`}`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`fn check_trait_item(&mut self, cx: &Context, item: &TraitItem) {`
`35`	`35`	`if let MethodTraitItem(ref sig, _) = item.node {`
`36`		`- check_fn_inner(cx, &*sig.decl, Some(&sig.explicit_self),`
	`36`	`+ check_fn_inner(cx, &sig.decl, Some(&sig.explicit_self),`
`37`	`37`	`&sig.generics.lifetimes, item.span);`
`38`	`38`	`}`
`39`	`39`	`}`
`@@ -92,7 +92,7 @@ fn could_use_elision(func: &FnDecl, slf: Option<&ExplicitSelf>,`
`92`	`92`	`}`
`93`	`93`	`// extract lifetimes in input argument types`
`94`	`94`	`for arg in &func.inputs {`
`95`		`- walk_ty(&mut input_visitor, &*arg.ty);`
	`95`	`+ walk_ty(&mut input_visitor, &arg.ty);`
`96`	`96`	`}`
`97`	`97`	`// extract lifetimes in output type`
`98`	`98`	`if let Return(ref ty) = func.output {`
Original file line number	Diff line number	Diff line change
`@@ -95,9 +95,9 @@ fn recover_for_loop(expr: &Expr) -> Option<(&Pat, &Expr, &Expr)> {`
`95`	`95`	`let PatEnum(_, Some(ref somepats)) = innerarms[0].pats[0].node,`
`96`	`96`	`somepats.len() == 1`
`97`	`97`	`], {`
`98`		`- return Some((&*somepats[0],`
`99`		`- &*iterargs[0],`
`100`		`- &*innerarms[0].body));`
	`98`	`+ return Some((&somepats[0],`
	`99`	`+ &iterargs[0],`
	`100`	`+ &innerarms[0].body));`
`101`	`101`	`}`
`102`	`102`	`}`
`103`	`103`	`None`
Original file line number	Diff line number	Diff line change
`@@ -203,7 +203,7 @@ fn check_to_owned(cx: &Context, expr: &Expr, other_span: Span) {`
`203`	`203`
`204`	`204`	`fn is_str_arg(cx: &Context, args: &[P<Expr>]) -> bool {`
`205`	`205`	`args.len() == 1 && if let ty::TyStr =`
`206`		`- walk_ptrs_ty(cx.tcx.expr_ty(&*args[0])).sty { true } else { false }`
	`206`	`+ walk_ptrs_ty(cx.tcx.expr_ty(&args[0])).sty { true } else { false }`
`207`	`207`	`}`
`208`	`208`
`209`	`209`	`declare_lint!(pub MODULO_ONE, Warn, "taking a number modulo 1, which always returns 0");`
Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ impl ReturnPass {`
`50`	`50`	`// a match expr, check all arms`
`51`	`51`	`ExprMatch(_, ref arms, _) => {`
`52`	`52`	`for arm in arms {`
`53`		`- self.check_final_expr(cx, &*arm.body);`
	`53`	`+ self.check_final_expr(cx, &arm.body);`
`54`	`54`	`}`
`55`	`55`	`}`
`56`	`56`	`_ => { }`
`@@ -76,7 +76,7 @@ impl ReturnPass {`
`76`	`76`	`let PatIdent(_, Spanned { node: id, .. }, _) = local.pat.node,`
`77`	`77`	`let Some(ref retexpr) = block.expr,`
`78`	`78`	`let ExprPath(_, ref path) = retexpr.node,`
`79`		`- match_path(path, &[&*id.name.as_str()])`
	`79`	`+ match_path(path, &[&id.name.as_str()])`
`80`	`80`	`], {`
`81`	`81`	`self.emit_let_lint(cx, retexpr.span, initexpr.span);`
`82`	`82`	`}`
Original file line number	Diff line number	Diff line change
`@@ -70,8 +70,8 @@ fn is_add(cx: &Context, src: &Expr, target: &Expr) -> bool {`
`70`	`70`	`is_exp_equal(cx, target, left),`
`71`	`71`	`ExprBlock(ref block) => block.stmts.is_empty() &&`
`72`	`72`	`block.expr.as_ref().map_or(false,`
`73`		`- \|expr\| is_add(cx, &*expr, target)),`
`74`		`- ExprParen(ref expr) => is_add(cx, &*expr, target),`
	`73`	`+ \|expr\| is_add(cx, expr, target)),`
	`74`	`+ ExprParen(ref expr) => is_add(cx, expr, target),`
`75`	`75`	`_ => false`
`76`	`76`	`}`
`77`	`77`	`}`