1 use if_chain::if_chain;
2 use rustc_ast::ast::Attribute;
3 use rustc_errors::Applicability;
4 use rustc_hir::intravisit::{walk_expr, FnKind, NestedVisitorMap, Visitor};
5 use rustc_hir::{Block, Body, Expr, ExprKind, FnDecl, HirId, MatchSource, PatKind, StmtKind};
6 use rustc_lint::{LateContext, LateLintPass, LintContext};
7 use rustc_middle::hir::map::Map;
8 use rustc_middle::lint::in_external_macro;
9 use rustc_middle::ty::subst::GenericArgKind;
10 use rustc_session::{declare_lint_pass, declare_tool_lint};
11 use rustc_span::source_map::Span;
14 use crate::utils::{fn_def_id, in_macro, match_qpath, snippet_opt, span_lint_and_sugg, span_lint_and_then};
16 declare_clippy_lint! {
17 /// **What it does:** Checks for `let`-bindings, which are subsequently
20 /// **Why is this bad?** It is just extraneous code. Remove it to make your code
23 /// **Known problems:** None.
27 /// fn foo() -> String {
28 /// let x = String::new();
34 /// fn foo() -> String {
40 "creating a let-binding and then immediately returning it like `let x = expr; x` at the end of a block"
43 declare_clippy_lint! {
44 /// **What it does:** Checks for return statements at the end of a block.
46 /// **Why is this bad?** Removing the `return` and semicolon will make the code
49 /// **Known problems:** None.
53 /// fn foo(x: usize) -> usize {
59 /// fn foo(x: usize) -> usize {
65 "using a return statement like `return expr;` where an expression would suffice"
68 #[derive(PartialEq, Eq, Copy, Clone)]
74 declare_lint_pass!(Return => [LET_AND_RETURN, NEEDLESS_RETURN]);
76 impl<'tcx> LateLintPass<'tcx> for Return {
77 fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'_>) {
78 // we need both a let-binding stmt and an expr
80 if let Some(retexpr) = block.expr;
81 if let Some(stmt) = block.stmts.iter().last();
82 if let StmtKind::Local(local) = &stmt.kind;
83 if local.ty.is_none();
84 if local.attrs.is_empty();
85 if let Some(initexpr) = &local.init;
86 if let PatKind::Binding(.., ident, _) = local.pat.kind;
87 if let ExprKind::Path(qpath) = &retexpr.kind;
88 if match_qpath(qpath, &[&*ident.name.as_str()]);
89 if !last_statement_borrows(cx, initexpr);
90 if !in_external_macro(cx.sess(), initexpr.span);
91 if !in_external_macro(cx.sess(), retexpr.span);
92 if !in_external_macro(cx.sess(), local.span);
93 if !in_macro(local.span);
99 "returning the result of a `let` binding from a block",
101 err.span_label(local.span, "unnecessary `let` binding");
103 if let Some(mut snippet) = snippet_opt(cx, initexpr.span) {
104 if !cx.typeck_results().expr_adjustments(&retexpr).is_empty() {
105 snippet.push_str(" as _");
107 err.multipart_suggestion(
108 "return the expression directly",
110 (local.span, String::new()),
111 (retexpr.span, snippet),
113 Applicability::MachineApplicable,
116 err.span_help(initexpr.span, "this expression can be directly returned");
126 cx: &LateContext<'tcx>,
128 _: &'tcx FnDecl<'tcx>,
129 body: &'tcx Body<'tcx>,
134 FnKind::Closure(_) => check_final_expr(cx, &body.value, Some(body.value.span), RetReplacement::Empty),
135 FnKind::ItemFn(..) | FnKind::Method(..) => {
136 if let ExprKind::Block(ref block, _) = body.value.kind {
137 check_block_return(cx, block);
144 fn attr_is_cfg(attr: &Attribute) -> bool {
145 attr.meta_item_list().is_some() && attr.has_name(sym::cfg)
148 fn check_block_return<'tcx>(cx: &LateContext<'tcx>, block: &Block<'tcx>) {
149 if let Some(expr) = block.expr {
150 check_final_expr(cx, expr, Some(expr.span), RetReplacement::Empty);
151 } else if let Some(stmt) = block.stmts.iter().last() {
153 StmtKind::Expr(ref expr) | StmtKind::Semi(ref expr) => {
154 check_final_expr(cx, expr, Some(stmt.span), RetReplacement::Empty);
161 fn check_final_expr<'tcx>(
162 cx: &LateContext<'tcx>,
163 expr: &'tcx Expr<'tcx>,
165 replacement: RetReplacement,
168 // simple return is always "bad"
169 ExprKind::Ret(ref inner) => {
170 // allow `#[cfg(a)] return a; #[cfg(b)] return b;`
171 if !expr.attrs.iter().any(attr_is_cfg) {
172 let borrows = inner.map_or(false, |inner| last_statement_borrows(cx, inner));
176 span.expect("`else return` is not possible"),
177 inner.as_ref().map(|i| i.span),
183 // a whole block? check it!
184 ExprKind::Block(ref block, _) => {
185 check_block_return(cx, block);
187 ExprKind::If(_, then, else_clause_opt) => {
188 if let ExprKind::Block(ref ifblock, _) = then.kind {
189 check_block_return(cx, ifblock);
191 if let Some(else_clause) = else_clause_opt {
192 check_final_expr(cx, else_clause, None, RetReplacement::Empty);
195 // a match expr, check all arms
196 // an if/if let expr, check both exprs
197 // note, if without else is going to be a type checking error anyways
198 // (except for unit type functions) so we don't match it
199 ExprKind::Match(_, ref arms, source) => match source {
200 MatchSource::Normal => {
201 for arm in arms.iter() {
202 check_final_expr(cx, &arm.body, Some(arm.body.span), RetReplacement::Block);
205 MatchSource::IfLetDesugar {
206 contains_else_clause: true,
208 if let ExprKind::Block(ref ifblock, _) = arms[0].body.kind {
209 check_block_return(cx, ifblock);
211 check_final_expr(cx, arms[1].body, None, RetReplacement::Empty);
219 fn emit_return_lint(cx: &LateContext<'_>, ret_span: Span, inner_span: Option<Span>, replacement: RetReplacement) {
220 if ret_span.from_expansion() {
224 Some(inner_span) => {
225 if in_external_macro(cx.tcx.sess, inner_span) || inner_span.from_expansion() {
229 span_lint_and_then(cx, NEEDLESS_RETURN, ret_span, "unneeded `return` statement", |diag| {
230 if let Some(snippet) = snippet_opt(cx, inner_span) {
231 diag.span_suggestion(ret_span, "remove `return`", snippet, Applicability::MachineApplicable);
235 None => match replacement {
236 RetReplacement::Empty => {
241 "unneeded `return` statement",
244 Applicability::MachineApplicable,
247 RetReplacement::Block => {
252 "unneeded `return` statement",
253 "replace `return` with an empty block",
255 Applicability::MachineApplicable,
262 fn last_statement_borrows<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
263 let mut visitor = BorrowVisitor { cx, borrows: false };
264 walk_expr(&mut visitor, expr);
268 struct BorrowVisitor<'a, 'tcx> {
269 cx: &'a LateContext<'tcx>,
273 impl<'tcx> Visitor<'tcx> for BorrowVisitor<'_, 'tcx> {
274 type Map = Map<'tcx>;
276 fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
281 if let Some(def_id) = fn_def_id(self.cx, expr) {
289 .any(|arg| matches!(arg.unpack(), GenericArgKind::Lifetime(_)));
292 walk_expr(self, expr);
295 fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
296 NestedVisitorMap::None