]>
Commit | Line | Data |
---|---|---|
cdc7bbd5 XL |
1 | use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then}; |
2 | use clippy_utils::source::snippet_opt; | |
3 | use clippy_utils::{fn_def_id, in_macro, path_to_local_id}; | |
f20569fa XL |
4 | use if_chain::if_chain; |
5 | use rustc_ast::ast::Attribute; | |
6 | use rustc_errors::Applicability; | |
7 | use rustc_hir::intravisit::{walk_expr, FnKind, NestedVisitorMap, Visitor}; | |
8 | use rustc_hir::{Block, Body, Expr, ExprKind, FnDecl, HirId, MatchSource, PatKind, StmtKind}; | |
9 | use rustc_lint::{LateContext, LateLintPass, LintContext}; | |
10 | use rustc_middle::hir::map::Map; | |
11 | use rustc_middle::lint::in_external_macro; | |
12 | use rustc_middle::ty::subst::GenericArgKind; | |
13 | use rustc_session::{declare_lint_pass, declare_tool_lint}; | |
c295e0f8 | 14 | use rustc_span::hygiene::DesugaringKind; |
f20569fa XL |
15 | use rustc_span::source_map::Span; |
16 | use rustc_span::sym; | |
17 | ||
f20569fa | 18 | declare_clippy_lint! { |
94222f64 XL |
19 | /// ### What it does |
20 | /// Checks for `let`-bindings, which are subsequently | |
f20569fa XL |
21 | /// returned. |
22 | /// | |
94222f64 XL |
23 | /// ### Why is this bad? |
24 | /// It is just extraneous code. Remove it to make your code | |
f20569fa XL |
25 | /// more rusty. |
26 | /// | |
94222f64 | 27 | /// ### Example |
f20569fa XL |
28 | /// ```rust |
29 | /// fn foo() -> String { | |
30 | /// let x = String::new(); | |
31 | /// x | |
32 | /// } | |
33 | /// ``` | |
34 | /// instead, use | |
35 | /// ``` | |
36 | /// fn foo() -> String { | |
37 | /// String::new() | |
38 | /// } | |
39 | /// ``` | |
40 | pub LET_AND_RETURN, | |
41 | style, | |
42 | "creating a let-binding and then immediately returning it like `let x = expr; x` at the end of a block" | |
43 | } | |
44 | ||
45 | declare_clippy_lint! { | |
94222f64 XL |
46 | /// ### What it does |
47 | /// Checks for return statements at the end of a block. | |
f20569fa | 48 | /// |
94222f64 XL |
49 | /// ### Why is this bad? |
50 | /// Removing the `return` and semicolon will make the code | |
f20569fa XL |
51 | /// more rusty. |
52 | /// | |
94222f64 | 53 | /// ### Example |
f20569fa XL |
54 | /// ```rust |
55 | /// fn foo(x: usize) -> usize { | |
56 | /// return x; | |
57 | /// } | |
58 | /// ``` | |
59 | /// simplify to | |
60 | /// ```rust | |
61 | /// fn foo(x: usize) -> usize { | |
62 | /// x | |
63 | /// } | |
64 | /// ``` | |
65 | pub NEEDLESS_RETURN, | |
66 | style, | |
67 | "using a return statement like `return expr;` where an expression would suffice" | |
68 | } | |
69 | ||
70 | #[derive(PartialEq, Eq, Copy, Clone)] | |
71 | enum RetReplacement { | |
72 | Empty, | |
73 | Block, | |
74 | } | |
75 | ||
76 | declare_lint_pass!(Return => [LET_AND_RETURN, NEEDLESS_RETURN]); | |
77 | ||
78 | impl<'tcx> LateLintPass<'tcx> for Return { | |
79 | fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'_>) { | |
80 | // we need both a let-binding stmt and an expr | |
81 | if_chain! { | |
82 | if let Some(retexpr) = block.expr; | |
83 | if let Some(stmt) = block.stmts.iter().last(); | |
84 | if let StmtKind::Local(local) = &stmt.kind; | |
85 | if local.ty.is_none(); | |
86 | if cx.tcx.hir().attrs(local.hir_id).is_empty(); | |
87 | if let Some(initexpr) = &local.init; | |
cdc7bbd5 XL |
88 | if let PatKind::Binding(_, local_id, _, _) = local.pat.kind; |
89 | if path_to_local_id(retexpr, local_id); | |
f20569fa XL |
90 | if !last_statement_borrows(cx, initexpr); |
91 | if !in_external_macro(cx.sess(), initexpr.span); | |
92 | if !in_external_macro(cx.sess(), retexpr.span); | |
93 | if !in_external_macro(cx.sess(), local.span); | |
94 | if !in_macro(local.span); | |
95 | then { | |
96 | span_lint_and_then( | |
97 | cx, | |
98 | LET_AND_RETURN, | |
99 | retexpr.span, | |
100 | "returning the result of a `let` binding from a block", | |
101 | |err| { | |
102 | err.span_label(local.span, "unnecessary `let` binding"); | |
103 | ||
104 | if let Some(mut snippet) = snippet_opt(cx, initexpr.span) { | |
cdc7bbd5 | 105 | if !cx.typeck_results().expr_adjustments(retexpr).is_empty() { |
f20569fa XL |
106 | snippet.push_str(" as _"); |
107 | } | |
108 | err.multipart_suggestion( | |
109 | "return the expression directly", | |
110 | vec![ | |
111 | (local.span, String::new()), | |
112 | (retexpr.span, snippet), | |
113 | ], | |
114 | Applicability::MachineApplicable, | |
115 | ); | |
116 | } else { | |
117 | err.span_help(initexpr.span, "this expression can be directly returned"); | |
118 | } | |
119 | }, | |
120 | ); | |
121 | } | |
122 | } | |
123 | } | |
124 | ||
125 | fn check_fn( | |
126 | &mut self, | |
127 | cx: &LateContext<'tcx>, | |
128 | kind: FnKind<'tcx>, | |
129 | _: &'tcx FnDecl<'tcx>, | |
130 | body: &'tcx Body<'tcx>, | |
131 | _: Span, | |
132 | _: HirId, | |
133 | ) { | |
134 | match kind { | |
135 | FnKind::Closure => { | |
136 | // when returning without value in closure, replace this `return` | |
137 | // with an empty block to prevent invalid suggestion (see #6501) | |
138 | let replacement = if let ExprKind::Ret(None) = &body.value.kind { | |
139 | RetReplacement::Block | |
140 | } else { | |
141 | RetReplacement::Empty | |
142 | }; | |
17df50a5 | 143 | check_final_expr(cx, &body.value, Some(body.value.span), replacement); |
f20569fa XL |
144 | }, |
145 | FnKind::ItemFn(..) | FnKind::Method(..) => { | |
cdc7bbd5 | 146 | if let ExprKind::Block(block, _) = body.value.kind { |
f20569fa XL |
147 | check_block_return(cx, block); |
148 | } | |
149 | }, | |
150 | } | |
151 | } | |
152 | } | |
153 | ||
154 | fn attr_is_cfg(attr: &Attribute) -> bool { | |
155 | attr.meta_item_list().is_some() && attr.has_name(sym::cfg) | |
156 | } | |
157 | ||
158 | fn check_block_return<'tcx>(cx: &LateContext<'tcx>, block: &Block<'tcx>) { | |
159 | if let Some(expr) = block.expr { | |
160 | check_final_expr(cx, expr, Some(expr.span), RetReplacement::Empty); | |
161 | } else if let Some(stmt) = block.stmts.iter().last() { | |
162 | match stmt.kind { | |
cdc7bbd5 | 163 | StmtKind::Expr(expr) | StmtKind::Semi(expr) => { |
f20569fa XL |
164 | check_final_expr(cx, expr, Some(stmt.span), RetReplacement::Empty); |
165 | }, | |
166 | _ => (), | |
167 | } | |
168 | } | |
169 | } | |
170 | ||
171 | fn check_final_expr<'tcx>( | |
172 | cx: &LateContext<'tcx>, | |
173 | expr: &'tcx Expr<'tcx>, | |
174 | span: Option<Span>, | |
175 | replacement: RetReplacement, | |
176 | ) { | |
177 | match expr.kind { | |
178 | // simple return is always "bad" | |
179 | ExprKind::Ret(ref inner) => { | |
180 | // allow `#[cfg(a)] return a; #[cfg(b)] return b;` | |
181 | let attrs = cx.tcx.hir().attrs(expr.hir_id); | |
182 | if !attrs.iter().any(attr_is_cfg) { | |
183 | let borrows = inner.map_or(false, |inner| last_statement_borrows(cx, inner)); | |
184 | if !borrows { | |
185 | emit_return_lint( | |
186 | cx, | |
187 | span.expect("`else return` is not possible"), | |
188 | inner.as_ref().map(|i| i.span), | |
189 | replacement, | |
190 | ); | |
191 | } | |
192 | } | |
193 | }, | |
194 | // a whole block? check it! | |
cdc7bbd5 | 195 | ExprKind::Block(block, _) => { |
f20569fa XL |
196 | check_block_return(cx, block); |
197 | }, | |
198 | ExprKind::If(_, then, else_clause_opt) => { | |
cdc7bbd5 | 199 | if let ExprKind::Block(ifblock, _) = then.kind { |
f20569fa XL |
200 | check_block_return(cx, ifblock); |
201 | } | |
202 | if let Some(else_clause) = else_clause_opt { | |
c295e0f8 XL |
203 | if expr.span.desugaring_kind() != Some(DesugaringKind::LetElse) { |
204 | check_final_expr(cx, else_clause, None, RetReplacement::Empty); | |
205 | } | |
f20569fa XL |
206 | } |
207 | }, | |
208 | // a match expr, check all arms | |
209 | // an if/if let expr, check both exprs | |
210 | // note, if without else is going to be a type checking error anyways | |
211 | // (except for unit type functions) so we don't match it | |
c295e0f8 XL |
212 | ExprKind::Match(_, arms, MatchSource::Normal) => { |
213 | for arm in arms.iter() { | |
214 | check_final_expr(cx, arm.body, Some(arm.body.span), RetReplacement::Block); | |
215 | } | |
f20569fa | 216 | }, |
cdc7bbd5 | 217 | ExprKind::DropTemps(expr) => check_final_expr(cx, expr, None, RetReplacement::Empty), |
f20569fa XL |
218 | _ => (), |
219 | } | |
220 | } | |
221 | ||
222 | fn emit_return_lint(cx: &LateContext<'_>, ret_span: Span, inner_span: Option<Span>, replacement: RetReplacement) { | |
223 | if ret_span.from_expansion() { | |
224 | return; | |
225 | } | |
226 | match inner_span { | |
227 | Some(inner_span) => { | |
228 | if in_external_macro(cx.tcx.sess, inner_span) || inner_span.from_expansion() { | |
229 | return; | |
230 | } | |
231 | ||
232 | span_lint_and_then(cx, NEEDLESS_RETURN, ret_span, "unneeded `return` statement", |diag| { | |
233 | if let Some(snippet) = snippet_opt(cx, inner_span) { | |
234 | diag.span_suggestion(ret_span, "remove `return`", snippet, Applicability::MachineApplicable); | |
235 | } | |
17df50a5 | 236 | }); |
f20569fa XL |
237 | }, |
238 | None => match replacement { | |
239 | RetReplacement::Empty => { | |
240 | span_lint_and_sugg( | |
241 | cx, | |
242 | NEEDLESS_RETURN, | |
243 | ret_span, | |
244 | "unneeded `return` statement", | |
245 | "remove `return`", | |
246 | String::new(), | |
247 | Applicability::MachineApplicable, | |
248 | ); | |
249 | }, | |
250 | RetReplacement::Block => { | |
251 | span_lint_and_sugg( | |
252 | cx, | |
253 | NEEDLESS_RETURN, | |
254 | ret_span, | |
255 | "unneeded `return` statement", | |
256 | "replace `return` with an empty block", | |
257 | "{}".to_string(), | |
258 | Applicability::MachineApplicable, | |
259 | ); | |
260 | }, | |
261 | }, | |
262 | } | |
263 | } | |
264 | ||
265 | fn last_statement_borrows<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool { | |
266 | let mut visitor = BorrowVisitor { cx, borrows: false }; | |
267 | walk_expr(&mut visitor, expr); | |
268 | visitor.borrows | |
269 | } | |
270 | ||
271 | struct BorrowVisitor<'a, 'tcx> { | |
272 | cx: &'a LateContext<'tcx>, | |
273 | borrows: bool, | |
274 | } | |
275 | ||
276 | impl<'tcx> Visitor<'tcx> for BorrowVisitor<'_, 'tcx> { | |
277 | type Map = Map<'tcx>; | |
278 | ||
279 | fn visit_expr(&mut self, expr: &'tcx Expr<'_>) { | |
280 | if self.borrows { | |
281 | return; | |
282 | } | |
283 | ||
284 | if let Some(def_id) = fn_def_id(self.cx, expr) { | |
285 | self.borrows = self | |
286 | .cx | |
287 | .tcx | |
288 | .fn_sig(def_id) | |
289 | .output() | |
290 | .skip_binder() | |
94222f64 | 291 | .walk(self.cx.tcx) |
f20569fa XL |
292 | .any(|arg| matches!(arg.unpack(), GenericArgKind::Lifetime(_))); |
293 | } | |
294 | ||
295 | walk_expr(self, expr); | |
296 | } | |
297 | ||
298 | fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> { | |
299 | NestedVisitorMap::None | |
300 | } | |
301 | } |