blob: c6bcf3ba40c54bfe07e9c16db4a2b1e4f645c2af [file] [log] [blame]
use clippy_utils::diagnostics::span_lint_hir_and_then;
use clippy_utils::source::{snippet_with_applicability, snippet_with_context, walk_span_to_context};
use clippy_utils::visitors::for_each_expr;
use clippy_utils::{get_async_fn_body, is_async_fn};
use core::ops::ControlFlow;
use rustc_errors::Applicability;
use rustc_hir::intravisit::FnKind;
use rustc_hir::{Block, Body, Expr, ExprKind, FnDecl, FnRetTy, HirId};
use rustc_lint::{LateContext, LateLintPass, LintContext};
use rustc_middle::lint::in_external_macro;
use rustc_session::{declare_lint_pass, declare_tool_lint};
use rustc_span::def_id::LocalDefId;
use rustc_span::{Span, SyntaxContext};
declare_clippy_lint! {
/// ### What it does
/// Checks for missing return statements at the end of a block.
///
/// ### Why is this bad?
/// Actually omitting the return keyword is idiomatic Rust code. Programmers
/// coming from other languages might prefer the expressiveness of `return`. It's possible to miss
/// the last returning statement because the only difference is a missing `;`. Especially in bigger
/// code with multiple return paths having a `return` keyword makes it easier to find the
/// corresponding statements.
///
/// ### Example
/// ```no_run
/// fn foo(x: usize) -> usize {
/// x
/// }
/// ```
/// add return
/// ```no_run
/// fn foo(x: usize) -> usize {
/// return x;
/// }
/// ```
#[clippy::version = "1.33.0"]
pub IMPLICIT_RETURN,
restriction,
"use a return statement like `return expr` instead of an expression"
}
declare_lint_pass!(ImplicitReturn => [IMPLICIT_RETURN]);
fn lint_return(cx: &LateContext<'_>, emission_place: HirId, span: Span) {
let mut app = Applicability::MachineApplicable;
let snip = snippet_with_applicability(cx, span, "..", &mut app);
span_lint_hir_and_then(
cx,
IMPLICIT_RETURN,
emission_place,
span,
"missing `return` statement",
|diag| {
diag.span_suggestion(span, "add `return` as shown", format!("return {snip}"), app);
},
);
}
fn lint_break(cx: &LateContext<'_>, emission_place: HirId, break_span: Span, expr_span: Span) {
let mut app = Applicability::MachineApplicable;
let snip = snippet_with_context(cx, expr_span, break_span.ctxt(), "..", &mut app).0;
span_lint_hir_and_then(
cx,
IMPLICIT_RETURN,
emission_place,
break_span,
"missing `return` statement",
|diag| {
diag.span_suggestion(
break_span,
"change `break` to `return` as shown",
format!("return {snip}"),
app,
);
},
);
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum LintLocation {
/// The lint was applied to a parent expression.
Parent,
/// The lint was applied to this expression, a child, or not applied.
Inner,
}
impl LintLocation {
fn still_parent(self, b: bool) -> Self {
if b { self } else { Self::Inner }
}
fn is_parent(self) -> bool {
self == Self::Parent
}
}
// Gets the call site if the span is in a child context. Otherwise returns `None`.
fn get_call_site(span: Span, ctxt: SyntaxContext) -> Option<Span> {
(span.ctxt() != ctxt).then(|| walk_span_to_context(span, ctxt).unwrap_or(span))
}
fn lint_implicit_returns(
cx: &LateContext<'_>,
expr: &Expr<'_>,
// The context of the function body.
ctxt: SyntaxContext,
// Whether the expression is from a macro expansion.
call_site_span: Option<Span>,
) -> LintLocation {
match expr.kind {
ExprKind::Block(
Block {
expr: Some(block_expr), ..
},
_,
) => lint_implicit_returns(
cx,
block_expr,
ctxt,
call_site_span.or_else(|| get_call_site(block_expr.span, ctxt)),
)
.still_parent(call_site_span.is_some()),
ExprKind::If(_, then_expr, Some(else_expr)) => {
// Both `then_expr` or `else_expr` are required to be blocks in the same context as the `if`. Don't
// bother checking.
let res = lint_implicit_returns(cx, then_expr, ctxt, call_site_span).still_parent(call_site_span.is_some());
if res.is_parent() {
// The return was added as a parent of this if expression.
return res;
}
lint_implicit_returns(cx, else_expr, ctxt, call_site_span).still_parent(call_site_span.is_some())
},
ExprKind::Match(_, arms, _) => {
for arm in arms {
let res = lint_implicit_returns(
cx,
arm.body,
ctxt,
call_site_span.or_else(|| get_call_site(arm.body.span, ctxt)),
)
.still_parent(call_site_span.is_some());
if res.is_parent() {
// The return was added as a parent of this match expression.
return res;
}
}
LintLocation::Inner
},
ExprKind::Loop(block, ..) => {
let mut add_return = false;
let _: Option<!> = for_each_expr(block, |e| {
if let ExprKind::Break(dest, sub_expr) = e.kind {
if dest.target_id.ok() == Some(expr.hir_id) {
if call_site_span.is_none() && e.span.ctxt() == ctxt {
// At this point sub_expr can be `None` in async functions which either diverge, or return
// the unit type.
if let Some(sub_expr) = sub_expr {
lint_break(cx, e.hir_id, e.span, sub_expr.span);
}
} else {
// the break expression is from a macro call, add a return to the loop
add_return = true;
}
}
}
ControlFlow::Continue(())
});
if add_return {
#[expect(clippy::option_if_let_else)]
if let Some(span) = call_site_span {
lint_return(cx, expr.hir_id, span);
LintLocation::Parent
} else {
lint_return(cx, expr.hir_id, expr.span);
LintLocation::Inner
}
} else {
LintLocation::Inner
}
},
// If expressions without an else clause, and blocks without a final expression can only be the final expression
// if they are divergent, or return the unit type.
ExprKind::If(_, _, None) | ExprKind::Block(Block { expr: None, .. }, _) | ExprKind::Ret(_) => {
LintLocation::Inner
},
// Any divergent expression doesn't need a return statement.
ExprKind::MethodCall(..)
| ExprKind::Call(..)
| ExprKind::Binary(..)
| ExprKind::Unary(..)
| ExprKind::Index(..)
if cx.typeck_results().expr_ty(expr).is_never() =>
{
LintLocation::Inner
},
_ =>
{
#[expect(clippy::option_if_let_else)]
if let Some(span) = call_site_span {
lint_return(cx, expr.hir_id, span);
LintLocation::Parent
} else {
lint_return(cx, expr.hir_id, expr.span);
LintLocation::Inner
}
},
}
}
impl<'tcx> LateLintPass<'tcx> for ImplicitReturn {
fn check_fn(
&mut self,
cx: &LateContext<'tcx>,
kind: FnKind<'tcx>,
decl: &'tcx FnDecl<'_>,
body: &'tcx Body<'_>,
span: Span,
_: LocalDefId,
) {
if (!matches!(kind, FnKind::Closure) && matches!(decl.output, FnRetTy::DefaultReturn(_)))
|| span.ctxt() != body.value.span.ctxt()
|| in_external_macro(cx.sess(), span)
{
return;
}
let res_ty = cx.typeck_results().expr_ty(body.value);
if res_ty.is_unit() || res_ty.is_never() {
return;
}
let expr = if is_async_fn(kind) {
match get_async_fn_body(cx.tcx, body) {
Some(e) => e,
None => return,
}
} else {
body.value
};
lint_implicit_returns(cx, expr, expr.span.ctxt(), None);
}
}