clippy_lints/src/implicit_return.rs

   1 // Copyright 2014-2018 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution.
   3 //
   4 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   5 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   6 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   7 // option. This file may not be copied, modified, or distributed
   8 // except according to those terms.
   9
  10 use crate::rustc::hir::{intravisit::FnKind, Body, ExprKind, FnDecl};
  11 use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
  12 use crate::rustc::{declare_tool_lint, lint_array};
  13 use crate::rustc_errors::Applicability;
  14 use crate::syntax::{ast::NodeId, source_map::Span};
  15 use crate::utils::{snippet_opt, span_lint_and_then};
  16
  17 /// **What it does:** Checks for missing return statements at the end of a block.
  18 ///
  19 /// **Why is this bad?** Actually omitting the return keyword is idiomatic Rust code. Programmers
  20 /// coming from other languages might prefer the expressiveness of `return`. It's possible to miss
  21 /// the last returning statement because the only difference is a missing `;`. Especially in bigger
  22 /// code with multiple return paths having a `return` keyword makes it easier to find the
  23 /// corresponding statements.
  24 ///
  25 /// **Known problems:** None.
  26 ///
  27 /// **Example:**
  28 /// ```rust
  29 /// fn foo(x: usize) {
  30 ///     x
  31 /// }
  32 /// ```
  33 /// add return
  34 /// ```rust
  35 /// fn foo(x: usize) {
  36 ///     return x;
  37 /// }
  38 /// ```
  39 declare_clippy_lint! {
  40     pub IMPLICIT_RETURN,
  41     restriction,
  42     "use a return statement like `return expr` instead of an expression"
  43 }
  44
  45 pub struct Pass;
  46
  47 impl Pass {
  48     fn expr_match(cx: &LateContext<'_, '_>, expr: &rustc::hir::Expr) {
  49         match &expr.node {
  50             ExprKind::Block(block, ..) => {
  51                 if let Some(expr) = &block.expr {
  52                     Self::expr_match(cx, expr);
  53                 }
  54                 // only needed in the case of `break` with `;` at the end
  55                 else if let Some(stmt) = block.stmts.last() {
  56                     if let rustc::hir::StmtKind::Semi(expr, ..) = &stmt.node {
  57                         Self::expr_match(cx, expr);
  58                     }
  59                 }
  60             },
  61             // use `return` instead of `break`
  62             ExprKind::Break(.., break_expr) => {
  63                 if let Some(break_expr) = break_expr {
  64                     span_lint_and_then(cx, IMPLICIT_RETURN, expr.span, "missing return statement", |db| {
  65                         if let Some(snippet) = snippet_opt(cx, break_expr.span) {
  66                             db.span_suggestion_with_applicability(
  67                                 expr.span,
  68                                 "change `break` to `return` as shown",
  69                                 format!("return {}", snippet),
  70                                 Applicability::MachineApplicable,
  71                             );
  72                         }
  73                     });
  74                 }
  75             },
  76             ExprKind::If(.., if_expr, else_expr) => {
  77                 Self::expr_match(cx, if_expr);
  78
  79                 if let Some(else_expr) = else_expr {
  80                     Self::expr_match(cx, else_expr);
  81                 }
  82             },
  83             ExprKind::Match(_, arms, ..) => {
  84                 for arm in arms {
  85                     Self::expr_match(cx, &arm.body);
  86                 }
  87             },
  88             // loops could be using `break` instead of `return`
  89             ExprKind::Loop(block, ..) => {
  90                 if let Some(expr) = &block.expr {
  91                     Self::expr_match(cx, expr);
  92                 }
  93             },
  94             // skip if it already has a return statement
  95             ExprKind::Ret(..) => (),
  96             // everything else is missing `return`
  97             _ => span_lint_and_then(cx, IMPLICIT_RETURN, expr.span, "missing return statement", |db| {
  98                 if let Some(snippet) = snippet_opt(cx, expr.span) {
  99                     db.span_suggestion_with_applicability(
 100                         expr.span,
 101                         "add `return` as shown",
 102                         format!("return {}", snippet),
 103                         Applicability::MachineApplicable,
 104                     );
 105                 }
 106             }),
 107         }
 108     }
 109 }
 110
 111 impl LintPass for Pass {
 112     fn get_lints(&self) -> LintArray {
 113         lint_array!(IMPLICIT_RETURN)
 114     }
 115 }
 116
 117 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
 118     fn check_fn(
 119         &mut self,
 120         cx: &LateContext<'a, 'tcx>,
 121         _: FnKind<'tcx>,
 122         _: &'tcx FnDecl,
 123         body: &'tcx Body,
 124         _: Span,
 125         _: NodeId,
 126     ) {
 127         let def_id = cx.tcx.hir.body_owner_def_id(body.id());
 128         let mir = cx.tcx.optimized_mir(def_id);
 129
 130         // checking return type through MIR, HIR is not able to determine inferred closure return types
 131         if !mir.return_ty().is_unit() {
 132             Self::expr_match(cx, &body.value);
 133         }
 134     }
 135 }