96 lines
4 KiB
Rust
96 lines
4 KiB
Rust
#![allow(unused_imports)]
|
|
|
|
use super::ITER_KV_MAP;
|
|
use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_sugg, span_lint_and_then};
|
|
use clippy_utils::source::{snippet, snippet_with_applicability};
|
|
use clippy_utils::sugg;
|
|
use clippy_utils::ty::is_type_diagnostic_item;
|
|
use clippy_utils::visitors::is_local_used;
|
|
use rustc_hir::{BindingAnnotation, Body, BorrowKind, ByRef, Expr, ExprKind, Mutability, Pat, PatKind};
|
|
use rustc_lint::{LateContext, LintContext};
|
|
use rustc_middle::ty;
|
|
use rustc_span::{sym, Span};
|
|
|
|
/// lint use of:
|
|
/// - `hashmap.iter().map(|(_, v)| v)`
|
|
/// - `hashmap.into_iter().map(|(_, v)| v)`
|
|
/// on `HashMaps` and `BTreeMaps` in std
|
|
|
|
pub(super) fn check<'tcx>(
|
|
cx: &LateContext<'tcx>,
|
|
map_type: &'tcx str, // iter / into_iter
|
|
expr: &'tcx Expr<'tcx>, // .iter().map(|(_, v_| v))
|
|
recv: &'tcx Expr<'tcx>, // hashmap
|
|
m_arg: &'tcx Expr<'tcx>, // |(_, v)| v
|
|
) {
|
|
if_chain! {
|
|
if !expr.span.from_expansion();
|
|
if let ExprKind::Closure(c) = m_arg.kind;
|
|
if let Body {params: [p], value: body_expr, generator_kind: _ } = cx.tcx.hir().body(c.body);
|
|
if let PatKind::Tuple([key_pat, val_pat], _) = p.pat.kind;
|
|
|
|
let (replacement_kind, annotation, bound_ident) = match (&key_pat.kind, &val_pat.kind) {
|
|
(key, PatKind::Binding(ann, _, value, _)) if pat_is_wild(cx, key, m_arg) => ("value", ann, value),
|
|
(PatKind::Binding(ann, _, key, _), value) if pat_is_wild(cx, value, m_arg) => ("key", ann, key),
|
|
_ => return,
|
|
};
|
|
|
|
let ty = cx.typeck_results().expr_ty(recv);
|
|
if is_type_diagnostic_item(cx, ty, sym::HashMap) || is_type_diagnostic_item(cx, ty, sym::BTreeMap);
|
|
|
|
then {
|
|
let mut applicability = rustc_errors::Applicability::MachineApplicable;
|
|
let recv_snippet = snippet_with_applicability(cx, recv.span, "map", &mut applicability);
|
|
let into_prefix = if map_type == "into_iter" {"into_"} else {""};
|
|
|
|
if_chain! {
|
|
if let ExprKind::Path(rustc_hir::QPath::Resolved(_, path)) = body_expr.kind;
|
|
if let [local_ident] = path.segments;
|
|
if local_ident.ident.as_str() == bound_ident.as_str();
|
|
|
|
then {
|
|
span_lint_and_sugg(
|
|
cx,
|
|
ITER_KV_MAP,
|
|
expr.span,
|
|
&format!("iterating on a map's {replacement_kind}s"),
|
|
"try",
|
|
format!("{recv_snippet}.{into_prefix}{replacement_kind}s()"),
|
|
applicability,
|
|
);
|
|
} else {
|
|
let ref_annotation = if annotation.0 == ByRef::Yes {
|
|
"ref "
|
|
} else {
|
|
""
|
|
};
|
|
let mut_annotation = if annotation.1 == Mutability::Mut {
|
|
"mut "
|
|
} else {
|
|
""
|
|
};
|
|
span_lint_and_sugg(
|
|
cx,
|
|
ITER_KV_MAP,
|
|
expr.span,
|
|
&format!("iterating on a map's {replacement_kind}s"),
|
|
"try",
|
|
format!("{recv_snippet}.{into_prefix}{replacement_kind}s().map(|{ref_annotation}{mut_annotation}{bound_ident}| {})",
|
|
snippet_with_applicability(cx, body_expr.span, "/* body */", &mut applicability)),
|
|
applicability,
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Returns `true` if the pattern is a `PatWild`, or is an ident prefixed with `_`
|
|
/// that is not locally used.
|
|
fn pat_is_wild<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx PatKind<'_>, body: &'tcx Expr<'_>) -> bool {
|
|
match *pat {
|
|
PatKind::Wild => true,
|
|
PatKind::Binding(_, id, ident, None) if ident.as_str().starts_with('_') => !is_local_used(cx, body, id),
|
|
_ => false,
|
|
}
|
|
}
|