]> git.lizzy.rs Git - rust.git/blob - clippy_lints/src/methods/unnecessary_filter_map.rs
Auto merge of #77144 - flip1995:clippyup, r=Manishearth
[rust.git] / clippy_lints / src / methods / unnecessary_filter_map.rs
1 use crate::utils::paths;
2 use crate::utils::usage::mutated_variables;
3 use crate::utils::{match_qpath, match_trait_method, span_lint};
4 use rustc_hir as hir;
5 use rustc_hir::def::Res;
6 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
7 use rustc_lint::LateContext;
8 use rustc_middle::hir::map::Map;
9
10 use if_chain::if_chain;
11
12 use super::UNNECESSARY_FILTER_MAP;
13
14 pub(super) fn lint(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
15     if !match_trait_method(cx, expr, &paths::ITERATOR) {
16         return;
17     }
18
19     if let hir::ExprKind::Closure(_, _, body_id, ..) = args[1].kind {
20         let body = cx.tcx.hir().body(body_id);
21         let arg_id = body.params[0].pat.hir_id;
22         let mutates_arg =
23             mutated_variables(&body.value, cx).map_or(true, |used_mutably| used_mutably.contains(&arg_id));
24
25         let (mut found_mapping, mut found_filtering) = check_expression(&cx, arg_id, &body.value);
26
27         let mut return_visitor = ReturnVisitor::new(&cx, arg_id);
28         return_visitor.visit_expr(&body.value);
29         found_mapping |= return_visitor.found_mapping;
30         found_filtering |= return_visitor.found_filtering;
31
32         if !found_filtering {
33             span_lint(
34                 cx,
35                 UNNECESSARY_FILTER_MAP,
36                 expr.span,
37                 "this `.filter_map` can be written more simply using `.map`",
38             );
39             return;
40         }
41
42         if !found_mapping && !mutates_arg {
43             span_lint(
44                 cx,
45                 UNNECESSARY_FILTER_MAP,
46                 expr.span,
47                 "this `.filter_map` can be written more simply using `.filter`",
48             );
49             return;
50         }
51     }
52 }
53
54 // returns (found_mapping, found_filtering)
55 fn check_expression<'tcx>(cx: &LateContext<'tcx>, arg_id: hir::HirId, expr: &'tcx hir::Expr<'_>) -> (bool, bool) {
56     match &expr.kind {
57         hir::ExprKind::Call(ref func, ref args) => {
58             if_chain! {
59                 if let hir::ExprKind::Path(ref path) = func.kind;
60                 then {
61                     if match_qpath(path, &paths::OPTION_SOME) {
62                         if_chain! {
63                             if let hir::ExprKind::Path(path) = &args[0].kind;
64                             if let Res::Local(ref local) = cx.qpath_res(path, args[0].hir_id);
65                             then {
66                                 if arg_id == *local {
67                                     return (false, false)
68                                 }
69                             }
70                         }
71                         return (true, false);
72                     } else {
73                         // We don't know. It might do anything.
74                         return (true, true);
75                     }
76                 }
77             }
78             (true, true)
79         },
80         hir::ExprKind::Block(ref block, _) => block
81             .expr
82             .as_ref()
83             .map_or((false, false), |expr| check_expression(cx, arg_id, &expr)),
84         hir::ExprKind::Match(_, arms, _) => {
85             let mut found_mapping = false;
86             let mut found_filtering = false;
87             for arm in *arms {
88                 let (m, f) = check_expression(cx, arg_id, &arm.body);
89                 found_mapping |= m;
90                 found_filtering |= f;
91             }
92             (found_mapping, found_filtering)
93         },
94         hir::ExprKind::Path(path) if match_qpath(path, &paths::OPTION_NONE) => (false, true),
95         _ => (true, true),
96     }
97 }
98
99 struct ReturnVisitor<'a, 'tcx> {
100     cx: &'a LateContext<'tcx>,
101     arg_id: hir::HirId,
102     // Found a non-None return that isn't Some(input)
103     found_mapping: bool,
104     // Found a return that isn't Some
105     found_filtering: bool,
106 }
107
108 impl<'a, 'tcx> ReturnVisitor<'a, 'tcx> {
109     fn new(cx: &'a LateContext<'tcx>, arg_id: hir::HirId) -> ReturnVisitor<'a, 'tcx> {
110         ReturnVisitor {
111             cx,
112             arg_id,
113             found_mapping: false,
114             found_filtering: false,
115         }
116     }
117 }
118
119 impl<'a, 'tcx> Visitor<'tcx> for ReturnVisitor<'a, 'tcx> {
120     type Map = Map<'tcx>;
121
122     fn visit_expr(&mut self, expr: &'tcx hir::Expr<'_>) {
123         if let hir::ExprKind::Ret(Some(expr)) = &expr.kind {
124             let (found_mapping, found_filtering) = check_expression(self.cx, self.arg_id, expr);
125             self.found_mapping |= found_mapping;
126             self.found_filtering |= found_filtering;
127         } else {
128             walk_expr(self, expr);
129         }
130     }
131
132     fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
133         NestedVisitorMap::None
134     }
135 }