1 use super::utils::clone_or_copy_needed;
2 use clippy_utils::diagnostics::span_lint;
3 use clippy_utils::ty::is_copy;
4 use clippy_utils::usage::mutated_variables;
5 use clippy_utils::{is_lang_ctor, is_trait_method, path_to_local_id};
7 use rustc_hir::intravisit::{walk_expr, Visitor};
8 use rustc_hir::LangItem::{OptionNone, OptionSome};
9 use rustc_lint::LateContext;
13 use super::UNNECESSARY_FILTER_MAP;
14 use super::UNNECESSARY_FIND_MAP;
16 pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, arg: &hir::Expr<'_>, name: &str) {
17 if !is_trait_method(cx, expr, sym::Iterator) {
21 if let hir::ExprKind::Closure(_, _, body_id, ..) = arg.kind {
22 let body = cx.tcx.hir().body(body_id);
23 let arg_id = body.params[0].pat.hir_id;
25 mutated_variables(&body.value, cx).map_or(true, |used_mutably| used_mutably.contains(&arg_id));
26 let (clone_or_copy_needed, _) = clone_or_copy_needed(cx, body.params[0].pat, &body.value);
28 let (mut found_mapping, mut found_filtering) = check_expression(cx, arg_id, &body.value);
30 let mut return_visitor = ReturnVisitor::new(cx, arg_id);
31 return_visitor.visit_expr(&body.value);
32 found_mapping |= return_visitor.found_mapping;
33 found_filtering |= return_visitor.found_filtering;
35 let in_ty = cx.typeck_results().node_type(body.params[0].hir_id);
36 let sugg = if !found_filtering {
37 if name == "filter_map" { "map" } else { "map(..).next()" }
38 } else if !found_mapping && !mutates_arg && (!clone_or_copy_needed || is_copy(cx, in_ty)) {
39 match cx.typeck_results().expr_ty(&body.value).kind() {
41 if cx.tcx.is_diagnostic_item(sym::Option, adt.did()) && in_ty == subst.type_at(0) =>
43 if name == "filter_map" { "filter" } else { "find" }
52 if name == "filter_map" {
53 UNNECESSARY_FILTER_MAP
58 &format!("this `.{}` can be written more simply using `.{}`", name, sugg),
63 // returns (found_mapping, found_filtering)
64 fn check_expression<'tcx>(cx: &LateContext<'tcx>, arg_id: hir::HirId, expr: &'tcx hir::Expr<'_>) -> (bool, bool) {
66 hir::ExprKind::Call(func, args) => {
67 if let hir::ExprKind::Path(ref path) = func.kind {
68 if is_lang_ctor(cx, path, OptionSome) {
69 if path_to_local_id(&args[0], arg_id) {
70 return (false, false);
77 hir::ExprKind::Block(block, _) => block
80 .map_or((false, false), |expr| check_expression(cx, arg_id, expr)),
81 hir::ExprKind::Match(_, arms, _) => {
82 let mut found_mapping = false;
83 let mut found_filtering = false;
85 let (m, f) = check_expression(cx, arg_id, arm.body);
89 (found_mapping, found_filtering)
91 // There must be an else_arm or there will be a type error
92 hir::ExprKind::If(_, if_arm, Some(else_arm)) => {
93 let if_check = check_expression(cx, arg_id, if_arm);
94 let else_check = check_expression(cx, arg_id, else_arm);
95 (if_check.0 | else_check.0, if_check.1 | else_check.1)
97 hir::ExprKind::Path(path) if is_lang_ctor(cx, path, OptionNone) => (false, true),
102 struct ReturnVisitor<'a, 'tcx> {
103 cx: &'a LateContext<'tcx>,
105 // Found a non-None return that isn't Some(input)
107 // Found a return that isn't Some
108 found_filtering: bool,
111 impl<'a, 'tcx> ReturnVisitor<'a, 'tcx> {
112 fn new(cx: &'a LateContext<'tcx>, arg_id: hir::HirId) -> ReturnVisitor<'a, 'tcx> {
116 found_mapping: false,
117 found_filtering: false,
122 impl<'a, 'tcx> Visitor<'tcx> for ReturnVisitor<'a, 'tcx> {
123 fn visit_expr(&mut self, expr: &'tcx hir::Expr<'_>) {
124 if let hir::ExprKind::Ret(Some(expr)) = &expr.kind {
125 let (found_mapping, found_filtering) = check_expression(self.cx, self.arg_id, expr);
126 self.found_mapping |= found_mapping;
127 self.found_filtering |= found_filtering;
129 walk_expr(self, expr);