rust-clippy/clippy_lints/src/map_clone.rs

131 lines
5.6 KiB
Rust
Raw Normal View History

2015-10-31 04:58:37 +00:00
use rustc::lint::*;
use rustc::hir::*;
use syntax::ast;
use utils::{is_adjusted, match_path, match_trait_method, match_type, remove_blocks, paths, snippet,
span_help_and_lint, walk_ptrs_ty, walk_ptrs_ty_depth, iter_input_pats};
2015-10-31 04:58:37 +00:00
/// **What it does:** Checks for mapping `clone()` over an iterator.
2015-12-14 12:31:28 +00:00
///
/// **Why is this bad?** It makes the code less readable than using the
/// `.cloned()` adapter.
2015-12-14 12:31:28 +00:00
///
/// **Known problems:** None.
2015-12-14 12:31:28 +00:00
///
2016-07-15 22:25:44 +00:00
/// **Example:**
/// ```rust
/// x.map(|e| e.clone());
/// ```
declare_lint! {
pub MAP_CLONE,
Warn,
"using `.map(|x| x.clone())` to clone an iterator or option's contents"
}
2015-10-31 04:58:37 +00:00
#[derive(Copy, Clone)]
2016-06-10 14:17:20 +00:00
pub struct Pass;
2015-10-31 04:58:37 +00:00
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
2015-11-05 16:11:41 +00:00
// call to .map()
if let ExprMethodCall(name, _, ref args) = expr.node {
if &*name.node.as_str() == "map" && args.len() == 2 {
2015-11-05 16:11:41 +00:00
match args[1].node {
ExprClosure(_, ref decl, closure_eid, _) => {
let body = cx.tcx.map.body(closure_eid);
let closure_expr = remove_blocks(&body.value);
2016-06-06 00:09:19 +00:00
if_let_chain! {[
2015-11-05 16:11:41 +00:00
// nothing special in the argument, besides reference bindings
// (e.g. .map(|&x| x) )
let Some(first_arg) = iter_input_pats(decl, body).next(),
let Some(arg_ident) = get_arg_name(&first_arg.pat),
2015-11-05 16:11:41 +00:00
// the method is being called on a known type (option or iterator)
let Some(type_name) = get_type_name(cx, expr, &args[0])
2016-06-06 00:09:19 +00:00
], {
// look for derefs, for .map(|x| *x)
if only_derefs(cx, &*closure_expr, arg_ident) &&
// .cloned() only removes one level of indirection, don't lint on more
walk_ptrs_ty_depth(cx.tcx.tables().pat_ty(&first_arg.pat)).1 == 1
2016-06-06 00:09:19 +00:00
{
span_help_and_lint(cx, MAP_CLONE, expr.span, &format!(
"you seem to be using .map() to clone the contents of an {}, consider \
using `.cloned()`", type_name),
&format!("try\n{}.cloned()", snippet(cx, args[0].span, "..")));
}
// explicit clone() calls ( .map(|x| x.clone()) )
else if let ExprMethodCall(clone_call, _, ref clone_args) = closure_expr.node {
if &*clone_call.node.as_str() == "clone" &&
2016-06-06 00:09:19 +00:00
clone_args.len() == 1 &&
match_trait_method(cx, closure_expr, &paths::CLONE_TRAIT) &&
expr_eq_name(&clone_args[0], arg_ident)
2015-11-05 16:11:41 +00:00
{
span_help_and_lint(cx, MAP_CLONE, expr.span, &format!(
"you seem to be using .map() to clone the contents of an {}, consider \
using `.cloned()`", type_name),
&format!("try\n{}.cloned()", snippet(cx, args[0].span, "..")));
}
}
2016-06-06 00:09:19 +00:00
}}
2016-12-20 17:21:30 +00:00
},
ExprPath(ref path) => {
2016-04-14 16:13:15 +00:00
if match_path(path, &paths::CLONE) {
2015-11-05 16:11:41 +00:00
let type_name = get_type_name(cx, expr, &args[0]).unwrap_or("_");
2016-01-04 04:26:12 +00:00
span_help_and_lint(cx,
MAP_CLONE,
expr.span,
&format!("you seem to be using .map() to clone the contents of an \
{}, consider using `.cloned()`",
type_name),
&format!("try\n{}.cloned()", snippet(cx, args[0].span, "..")));
2015-11-05 16:11:41 +00:00
}
2016-12-20 17:21:30 +00:00
},
2015-11-05 16:11:41 +00:00
_ => (),
2015-10-31 04:58:37 +00:00
}
}
}
}
}
fn expr_eq_name(expr: &Expr, id: ast::Name) -> bool {
2015-10-31 04:58:37 +00:00
match expr.node {
ExprPath(QPath::Resolved(None, ref path)) => {
2016-01-04 04:26:12 +00:00
let arg_segment = [PathSegment {
name: id,
2016-01-04 04:26:12 +00:00
parameters: PathParameters::none(),
}];
!path.is_global() && path.segments[..] == arg_segment
2016-12-20 17:21:30 +00:00
},
2015-10-31 04:58:37 +00:00
_ => false,
}
}
fn get_type_name(cx: &LateContext, expr: &Expr, arg: &Expr) -> Option<&'static str> {
if match_trait_method(cx, expr, &paths::ITERATOR) {
2015-10-31 04:58:37 +00:00
Some("iterator")
} else if match_type(cx, walk_ptrs_ty(cx.tcx.tables().expr_ty(arg)), &paths::OPTION) {
2015-10-31 04:58:37 +00:00
Some("Option")
} else {
None
}
}
fn get_arg_name(pat: &Pat) -> Option<ast::Name> {
2015-10-31 04:58:37 +00:00
match pat.node {
PatKind::Binding(_, _, name, None) => Some(name.node),
PatKind::Ref(ref subpat, _) => get_arg_name(subpat),
2015-10-31 04:58:37 +00:00
_ => None,
}
}
fn only_derefs(cx: &LateContext, expr: &Expr, id: ast::Name) -> bool {
2015-11-04 03:11:40 +00:00
match expr.node {
2016-01-04 04:26:12 +00:00
ExprUnary(UnDeref, ref subexpr) if !is_adjusted(cx, subexpr) => only_derefs(cx, subexpr, id),
_ => expr_eq_name(expr, id),
2015-10-31 04:58:37 +00:00
}
}
2016-06-10 14:17:20 +00:00
impl LintPass for Pass {
2015-10-31 04:58:37 +00:00
fn get_lints(&self) -> LintArray {
lint_array!(MAP_CLONE)
}
}