]>
Commit | Line | Data |
---|---|---|
f20569fa XL |
1 | use if_chain::if_chain; |
2 | use rustc_errors::Applicability; | |
3 | use rustc_hir::{def_id, Expr, ExprKind, Param, PatKind, QPath}; | |
4 | use rustc_lint::{LateContext, LateLintPass, LintContext}; | |
5 | use rustc_middle::lint::in_external_macro; | |
6 | use rustc_middle::ty::{self, Ty}; | |
7 | use rustc_session::{declare_lint_pass, declare_tool_lint}; | |
8 | ||
9 | use crate::utils::{ | |
10 | implements_trait, is_adjusted, iter_input_pats, snippet_opt, span_lint_and_sugg, span_lint_and_then, | |
11 | type_is_unsafe_function, | |
12 | }; | |
13 | use clippy_utils::higher; | |
14 | use clippy_utils::higher::VecArgs; | |
15 | ||
16 | declare_clippy_lint! { | |
17 | /// **What it does:** Checks for closures which just call another function where | |
18 | /// the function can be called directly. `unsafe` functions or calls where types | |
19 | /// get adjusted are ignored. | |
20 | /// | |
21 | /// **Why is this bad?** Needlessly creating a closure adds code for no benefit | |
22 | /// and gives the optimizer more work. | |
23 | /// | |
24 | /// **Known problems:** If creating the closure inside the closure has a side- | |
25 | /// effect then moving the closure creation out will change when that side- | |
26 | /// effect runs. | |
27 | /// See [#1439](https://github.com/rust-lang/rust-clippy/issues/1439) for more details. | |
28 | /// | |
29 | /// **Example:** | |
30 | /// ```rust,ignore | |
31 | /// // Bad | |
32 | /// xs.map(|x| foo(x)) | |
33 | /// | |
34 | /// // Good | |
35 | /// xs.map(foo) | |
36 | /// ``` | |
37 | /// where `foo(_)` is a plain function that takes the exact argument type of | |
38 | /// `x`. | |
39 | pub REDUNDANT_CLOSURE, | |
40 | style, | |
41 | "redundant closures, i.e., `|a| foo(a)` (which can be written as just `foo`)" | |
42 | } | |
43 | ||
44 | declare_clippy_lint! { | |
45 | /// **What it does:** Checks for closures which only invoke a method on the closure | |
46 | /// argument and can be replaced by referencing the method directly. | |
47 | /// | |
48 | /// **Why is this bad?** It's unnecessary to create the closure. | |
49 | /// | |
50 | /// **Known problems:** [#3071](https://github.com/rust-lang/rust-clippy/issues/3071), | |
51 | /// [#3942](https://github.com/rust-lang/rust-clippy/issues/3942), | |
52 | /// [#4002](https://github.com/rust-lang/rust-clippy/issues/4002) | |
53 | /// | |
54 | /// | |
55 | /// **Example:** | |
56 | /// ```rust,ignore | |
57 | /// Some('a').map(|s| s.to_uppercase()); | |
58 | /// ``` | |
59 | /// may be rewritten as | |
60 | /// ```rust,ignore | |
61 | /// Some('a').map(char::to_uppercase); | |
62 | /// ``` | |
63 | pub REDUNDANT_CLOSURE_FOR_METHOD_CALLS, | |
64 | pedantic, | |
65 | "redundant closures for method calls" | |
66 | } | |
67 | ||
68 | declare_lint_pass!(EtaReduction => [REDUNDANT_CLOSURE, REDUNDANT_CLOSURE_FOR_METHOD_CALLS]); | |
69 | ||
70 | impl<'tcx> LateLintPass<'tcx> for EtaReduction { | |
71 | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) { | |
72 | if in_external_macro(cx.sess(), expr.span) { | |
73 | return; | |
74 | } | |
75 | ||
76 | match expr.kind { | |
77 | ExprKind::Call(_, args) | ExprKind::MethodCall(_, _, args, _) => { | |
78 | for arg in args { | |
79 | // skip `foo(macro!())` | |
80 | if arg.span.ctxt() == expr.span.ctxt() { | |
81 | check_closure(cx, arg) | |
82 | } | |
83 | } | |
84 | }, | |
85 | _ => (), | |
86 | } | |
87 | } | |
88 | } | |
89 | ||
90 | fn check_closure(cx: &LateContext<'_>, expr: &Expr<'_>) { | |
91 | if let ExprKind::Closure(_, ref decl, eid, _, _) = expr.kind { | |
92 | let body = cx.tcx.hir().body(eid); | |
93 | let ex = &body.value; | |
94 | ||
95 | if ex.span.ctxt() != expr.span.ctxt() { | |
96 | if let Some(VecArgs::Vec(&[])) = higher::vec_macro(cx, ex) { | |
97 | // replace `|| vec![]` with `Vec::new` | |
98 | span_lint_and_sugg( | |
99 | cx, | |
100 | REDUNDANT_CLOSURE, | |
101 | expr.span, | |
102 | "redundant closure", | |
103 | "replace the closure with `Vec::new`", | |
104 | "std::vec::Vec::new".into(), | |
105 | Applicability::MachineApplicable, | |
106 | ); | |
107 | } | |
108 | // skip `foo(|| macro!())` | |
109 | return; | |
110 | } | |
111 | ||
112 | if_chain!( | |
113 | if let ExprKind::Call(ref caller, ref args) = ex.kind; | |
114 | ||
115 | if let ExprKind::Path(_) = caller.kind; | |
116 | ||
117 | // Not the same number of arguments, there is no way the closure is the same as the function return; | |
118 | if args.len() == decl.inputs.len(); | |
119 | ||
120 | // Are the expression or the arguments type-adjusted? Then we need the closure | |
121 | if !(is_adjusted(cx, ex) || args.iter().any(|arg| is_adjusted(cx, arg))); | |
122 | ||
123 | let fn_ty = cx.typeck_results().expr_ty(caller); | |
124 | ||
125 | if matches!(fn_ty.kind(), ty::FnDef(_, _) | ty::FnPtr(_) | ty::Closure(_, _)); | |
126 | ||
127 | if !type_is_unsafe_function(cx, fn_ty); | |
128 | ||
129 | if compare_inputs(&mut iter_input_pats(decl, body), &mut args.iter()); | |
130 | ||
131 | then { | |
132 | span_lint_and_then(cx, REDUNDANT_CLOSURE, expr.span, "redundant closure", |diag| { | |
133 | if let Some(snippet) = snippet_opt(cx, caller.span) { | |
134 | diag.span_suggestion( | |
135 | expr.span, | |
136 | "replace the closure with the function itself", | |
137 | snippet, | |
138 | Applicability::MachineApplicable, | |
139 | ); | |
140 | } | |
141 | }); | |
142 | } | |
143 | ); | |
144 | ||
145 | if_chain!( | |
146 | if let ExprKind::MethodCall(ref path, _, ref args, _) = ex.kind; | |
147 | ||
148 | // Not the same number of arguments, there is no way the closure is the same as the function return; | |
149 | if args.len() == decl.inputs.len(); | |
150 | ||
151 | // Are the expression or the arguments type-adjusted? Then we need the closure | |
152 | if !(is_adjusted(cx, ex) || args.iter().skip(1).any(|arg| is_adjusted(cx, arg))); | |
153 | ||
154 | let method_def_id = cx.typeck_results().type_dependent_def_id(ex.hir_id).unwrap(); | |
155 | if !type_is_unsafe_function(cx, cx.tcx.type_of(method_def_id)); | |
156 | ||
157 | if compare_inputs(&mut iter_input_pats(decl, body), &mut args.iter()); | |
158 | ||
159 | if let Some(name) = get_ufcs_type_name(cx, method_def_id, &args[0]); | |
160 | ||
161 | then { | |
162 | span_lint_and_sugg( | |
163 | cx, | |
164 | REDUNDANT_CLOSURE_FOR_METHOD_CALLS, | |
165 | expr.span, | |
166 | "redundant closure", | |
167 | "replace the closure with the method itself", | |
168 | format!("{}::{}", name, path.ident.name), | |
169 | Applicability::MachineApplicable, | |
170 | ); | |
171 | } | |
172 | ); | |
173 | } | |
174 | } | |
175 | ||
176 | /// Tries to determine the type for universal function call to be used instead of the closure | |
177 | fn get_ufcs_type_name(cx: &LateContext<'_>, method_def_id: def_id::DefId, self_arg: &Expr<'_>) -> Option<String> { | |
178 | let expected_type_of_self = &cx.tcx.fn_sig(method_def_id).inputs_and_output().skip_binder()[0]; | |
179 | let actual_type_of_self = &cx.typeck_results().node_type(self_arg.hir_id); | |
180 | ||
181 | if let Some(trait_id) = cx.tcx.trait_of_item(method_def_id) { | |
182 | if match_borrow_depth(expected_type_of_self, &actual_type_of_self) | |
183 | && implements_trait(cx, actual_type_of_self, trait_id, &[]) | |
184 | { | |
185 | return Some(cx.tcx.def_path_str(trait_id)); | |
186 | } | |
187 | } | |
188 | ||
189 | cx.tcx.impl_of_method(method_def_id).and_then(|_| { | |
190 | //a type may implicitly implement other type's methods (e.g. Deref) | |
191 | if match_types(expected_type_of_self, &actual_type_of_self) { | |
192 | return Some(get_type_name(cx, &actual_type_of_self)); | |
193 | } | |
194 | None | |
195 | }) | |
196 | } | |
197 | ||
198 | fn match_borrow_depth(lhs: Ty<'_>, rhs: Ty<'_>) -> bool { | |
199 | match (&lhs.kind(), &rhs.kind()) { | |
200 | (ty::Ref(_, t1, mut1), ty::Ref(_, t2, mut2)) => mut1 == mut2 && match_borrow_depth(&t1, &t2), | |
201 | (l, r) => !matches!((l, r), (ty::Ref(_, _, _), _) | (_, ty::Ref(_, _, _))), | |
202 | } | |
203 | } | |
204 | ||
205 | fn match_types(lhs: Ty<'_>, rhs: Ty<'_>) -> bool { | |
206 | match (&lhs.kind(), &rhs.kind()) { | |
207 | (ty::Bool, ty::Bool) | |
208 | | (ty::Char, ty::Char) | |
209 | | (ty::Int(_), ty::Int(_)) | |
210 | | (ty::Uint(_), ty::Uint(_)) | |
211 | | (ty::Str, ty::Str) => true, | |
212 | (ty::Ref(_, t1, mut1), ty::Ref(_, t2, mut2)) => mut1 == mut2 && match_types(t1, t2), | |
213 | (ty::Array(t1, _), ty::Array(t2, _)) | (ty::Slice(t1), ty::Slice(t2)) => match_types(t1, t2), | |
214 | (ty::Adt(def1, _), ty::Adt(def2, _)) => def1 == def2, | |
215 | (_, _) => false, | |
216 | } | |
217 | } | |
218 | ||
219 | fn get_type_name(cx: &LateContext<'_>, ty: Ty<'_>) -> String { | |
220 | match ty.kind() { | |
221 | ty::Adt(t, _) => cx.tcx.def_path_str(t.did), | |
222 | ty::Ref(_, r, _) => get_type_name(cx, &r), | |
223 | _ => ty.to_string(), | |
224 | } | |
225 | } | |
226 | ||
227 | fn compare_inputs( | |
228 | closure_inputs: &mut dyn Iterator<Item = &Param<'_>>, | |
229 | call_args: &mut dyn Iterator<Item = &Expr<'_>>, | |
230 | ) -> bool { | |
231 | for (closure_input, function_arg) in closure_inputs.zip(call_args) { | |
232 | if let PatKind::Binding(_, _, ident, _) = closure_input.pat.kind { | |
233 | // XXXManishearth Should I be checking the binding mode here? | |
234 | if let ExprKind::Path(QPath::Resolved(None, ref p)) = function_arg.kind { | |
235 | if p.segments.len() != 1 { | |
236 | // If it's a proper path, it can't be a local variable | |
237 | return false; | |
238 | } | |
239 | if p.segments[0].ident.name != ident.name { | |
240 | // The two idents should be the same | |
241 | return false; | |
242 | } | |
243 | } else { | |
244 | return false; | |
245 | } | |
246 | } else { | |
247 | return false; | |
248 | } | |
249 | } | |
250 | true | |
251 | } |