Better suggestions when returning macro calls.
Suggest changeing all the break expressions in a loop, not just the final statement.
Don't lint divergent functions.
Don't suggest returning the result of any divergent fuction.
-use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::match_panic_def_id;
-use clippy_utils::source::snippet_opt;
-use if_chain::if_chain;
+use clippy_utils::{
+ diagnostics::span_lint_and_sugg,
+ source::{snippet_with_applicability, snippet_with_context, walk_span_to_context},
+ visitors::visit_break_exprs,
+};
use rustc_errors::Applicability;
use rustc_hir::intravisit::FnKind;
-use rustc_hir::{Body, Expr, ExprKind, FnDecl, HirId, MatchSource, StmtKind};
-use rustc_lint::{LateContext, LateLintPass};
+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::source_map::Span;
+use rustc_span::{Span, SyntaxContext};
declare_clippy_lint! {
/// **What it does:** Checks for missing return statements at the end of a block.
declare_lint_pass!(ImplicitReturn => [IMPLICIT_RETURN]);
-static LINT_BREAK: &str = "change `break` to `return` as shown";
-static LINT_RETURN: &str = "add `return` as shown";
-
-fn lint(cx: &LateContext<'_>, outer_span: Span, inner_span: Span, msg: &str) {
- let outer_span = outer_span.source_callsite();
- let inner_span = inner_span.source_callsite();
-
- span_lint_and_then(cx, IMPLICIT_RETURN, outer_span, "missing `return` statement", |diag| {
- if let Some(snippet) = snippet_opt(cx, inner_span) {
- diag.span_suggestion(
- outer_span,
- msg,
- format!("return {}", snippet),
- Applicability::MachineApplicable,
- );
- }
- });
+fn lint_return(cx: &LateContext<'_>, span: Span) {
+ let mut app = Applicability::MachineApplicable;
+ let snip = snippet_with_applicability(cx, span, "..", &mut app);
+ span_lint_and_sugg(
+ cx,
+ IMPLICIT_RETURN,
+ span,
+ "missing `return` statement",
+ "add `return` as shown",
+ format!("return {}", snip),
+ app,
+ );
+}
+
+fn lint_break(cx: &LateContext<'_>, 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_and_sugg(
+ cx,
+ IMPLICIT_RETURN,
+ break_span,
+ "missing `return` statement",
+ "change `break` to `return` as shown",
+ format!("return {}", snip),
+ app,
+ )
+}
+
+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 expr_match(cx: &LateContext<'_>, expr: &Expr<'_>) {
+ fn is_parent(&self) -> bool {
+ matches!(*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<'tcx>,
+ expr: &'tcx 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 {
- // loops could be using `break` instead of `return`
- ExprKind::Block(block, ..) | ExprKind::Loop(block, ..) => {
- if let Some(expr) = &block.expr {
- expr_match(cx, expr);
- }
- // only needed in the case of `break` with `;` at the end
- else if let Some(stmt) = block.stmts.last() {
- if_chain! {
- if let StmtKind::Semi(expr, ..) = &stmt.kind;
- // make sure it's a break, otherwise we want to skip
- if let ExprKind::Break(.., Some(break_expr)) = &expr.kind;
- then {
- lint(cx, expr.span, break_expr.span, LINT_BREAK);
- }
- }
- }
- },
- // use `return` instead of `break`
- ExprKind::Break(.., break_expr) => {
- if let Some(break_expr) = break_expr {
- lint(cx, expr.span, break_expr.span, LINT_BREAK);
+ 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::If(.., if_expr, else_expr) => {
- expr_match(cx, if_expr);
- if let Some(else_expr) = else_expr {
- expr_match(cx, else_expr);
+ 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::Match(.., arms, source) => {
- let check_all_arms = match source {
- MatchSource::IfLetDesugar {
- contains_else_clause: has_else,
- } => has_else,
- _ => true,
- };
-
- if check_all_arms {
- for arm in arms {
- expr_match(cx, arm.body);
+
+ ExprKind::Loop(block, ..) => {
+ let mut add_return = false;
+ visit_break_exprs(block, |break_expr, dest, sub_expr| {
+ if dest.target_id.ok() == Some(expr.hir_id) {
+ if call_site_span.is_none() && break_expr.span.ctxt() == ctxt {
+ lint_break(cx, break_expr.span, sub_expr.unwrap().span);
+ } else {
+ // the break expression is from a macro call, add a return to the loop
+ add_return = true;
+ }
+ }
+ });
+ if add_return {
+ #[allow(clippy::option_if_let_else)]
+ if let Some(span) = call_site_span {
+ lint_return(cx, span);
+ LintLocation::Parent
+ } else {
+ lint_return(cx, expr.span);
+ LintLocation::Inner
}
} else {
- expr_match(cx, arms.first().expect("`if let` doesn't have a single arm").body);
+ LintLocation::Inner
}
},
- // skip if it already has a return statement
- ExprKind::Ret(..) => (),
- // make sure it's not a call that panics
- ExprKind::Call(expr, ..) => {
- if_chain! {
- if let ExprKind::Path(qpath) = &expr.kind;
- if let Some(path_def_id) = cx.qpath_res(qpath, expr.hir_id).opt_def_id();
- if match_panic_def_id(cx, path_def_id);
- then { }
- else {
- lint(cx, expr.span, expr.span, LINT_RETURN)
- }
+
+ // 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
+ },
+
+ _ =>
+ {
+ #[allow(clippy::option_if_let_else)]
+ if let Some(span) = call_site_span {
+ lint_return(cx, span);
+ LintLocation::Parent
+ } else {
+ lint_return(cx, expr.span);
+ LintLocation::Inner
}
},
- // everything else is missing `return`
- _ => lint(cx, expr.span, expr.span, LINT_RETURN),
}
}
fn check_fn(
&mut self,
cx: &LateContext<'tcx>,
- _: FnKind<'tcx>,
- _: &'tcx FnDecl<'_>,
+ kind: FnKind<'tcx>,
+ decl: &'tcx FnDecl<'_>,
body: &'tcx Body<'_>,
span: Span,
_: HirId,
) {
- if span.from_expansion() {
+ if (!matches!(kind, FnKind::Closure) && matches!(decl.output, FnRetTy::DefaultReturn(_)))
+ || span.ctxt() != body.value.span.ctxt()
+ || in_external_macro(cx.sess(), span)
+ {
return;
}
- let body = cx.tcx.hir().body(body.id());
- if cx.typeck_results().expr_ty(&body.value).is_unit() {
+
+ let res_ty = cx.typeck_results().expr_ty(&body.value);
+ if res_ty.is_unit() || res_ty.is_never() {
return;
}
- expr_match(cx, &body.value);
+
+ lint_implicit_returns(cx, &body.value, body.value.span.ctxt(), None);
}
}
default: &'a str,
applicability: &mut Applicability,
) -> (Cow<'a, str>, bool) {
- let outer_span = hygiene::walk_chain(span, outer);
- let (span, is_macro_call) = if outer_span.ctxt() == outer {
- (outer_span, span.ctxt() != outer)
- } else {
- // The span is from a macro argument, and the outer context is the macro using the argument
- if *applicability != Applicability::Unspecified {
- *applicability = Applicability::MaybeIncorrect;
- }
- // TODO: get the argument span.
- (span, false)
- };
+ let (span, is_macro_call) = walk_span_to_context(span, outer).map_or_else(
+ || {
+ // The span is from a macro argument, and the outer context is the macro using the argument
+ if *applicability != Applicability::Unspecified {
+ *applicability = Applicability::MaybeIncorrect;
+ }
+ // TODO: get the argument span.
+ (span, false)
+ },
+ |outer_span| (outer_span, span.ctxt() != outer),
+ );
(
snippet_with_applicability(cx, span, default, applicability),
)
}
+/// Walks the span up to the target context, thereby returning the macro call site if the span is
+/// inside a macro expansion, or the original span if it is not. Note this will return `None` in the
+/// case of the span being in a macro expansion, but the target context is from expanding a macro
+/// argument.
+pub fn walk_span_to_context(span: Span, outer: SyntaxContext) -> Option<Span> {
+ let outer_span = hygiene::walk_chain(span, outer);
+ (outer_span.ctxt() == outer).then(|| outer_span)
+}
+
/// Removes block comments from the given `Vec` of lines.
///
/// # Examples
use crate::path_to_local_id;
use rustc_hir as hir;
-use rustc_hir::intravisit::{self, walk_expr, NestedVisitorMap, Visitor};
-use rustc_hir::{Arm, Body, Expr, HirId, Stmt};
+use rustc_hir::intravisit::{self, walk_expr, ErasedMap, NestedVisitorMap, Visitor};
+use rustc_hir::{Arm, Block, Body, Destination, Expr, ExprKind, HirId, Stmt};
use rustc_lint::LateContext;
use rustc_middle::hir::map::Map;
NestedVisitorMap::OnlyBodies(self.hir)
}
}
+
+pub trait Visitable<'tcx> {
+ fn visit<V: Visitor<'tcx>>(self, v: &mut V);
+}
+impl Visitable<'tcx> for &'tcx Expr<'tcx> {
+ fn visit<V: Visitor<'tcx>>(self, v: &mut V) {
+ v.visit_expr(self)
+ }
+}
+impl Visitable<'tcx> for &'tcx Block<'tcx> {
+ fn visit<V: Visitor<'tcx>>(self, v: &mut V) {
+ v.visit_block(self)
+ }
+}
+impl<'tcx> Visitable<'tcx> for &'tcx Stmt<'tcx> {
+ fn visit<V: Visitor<'tcx>>(self, v: &mut V) {
+ v.visit_stmt(self)
+ }
+}
+impl<'tcx> Visitable<'tcx> for &'tcx Body<'tcx> {
+ fn visit<V: Visitor<'tcx>>(self, v: &mut V) {
+ v.visit_body(self)
+ }
+}
+impl<'tcx> Visitable<'tcx> for &'tcx Arm<'tcx> {
+ fn visit<V: Visitor<'tcx>>(self, v: &mut V) {
+ v.visit_arm(self)
+ }
+}
+
+pub fn visit_break_exprs<'tcx>(
+ node: impl Visitable<'tcx>,
+ f: impl FnMut(&'tcx Expr<'tcx>, Destination, Option<&'tcx Expr<'tcx>>),
+) {
+ struct V<F>(F);
+ impl<'tcx, F: FnMut(&'tcx Expr<'tcx>, Destination, Option<&'tcx Expr<'tcx>>)> Visitor<'tcx> for V<F> {
+ type Map = ErasedMap<'tcx>;
+ fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+ NestedVisitorMap::None
+ }
+
+ fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
+ if let ExprKind::Break(dest, sub_expr) = e.kind {
+ self.0(e, dest, sub_expr)
+ }
+ walk_expr(self, e);
+ }
+ }
+
+ node.visit(&mut V(f));
+}
// run-rustfix
#![warn(clippy::implicit_return)]
-#![allow(clippy::needless_return, unused)]
+#![allow(clippy::needless_return, clippy::needless_bool, unused, clippy::never_loop)]
fn test_end_of_fn() -> bool {
if true {
return true
}
-#[allow(clippy::needless_bool)]
fn test_if_block() -> bool {
if true { return true } else { return false }
}
}
}
-#[allow(clippy::needless_return)]
fn test_match_with_unreachable(x: bool) -> bool {
match x {
true => return false,
}
}
-#[allow(clippy::never_loop)]
fn test_loop() -> bool {
loop {
return true;
}
}
-#[allow(clippy::never_loop)]
fn test_loop_with_block() -> bool {
loop {
{
}
}
-#[allow(clippy::never_loop)]
fn test_loop_with_nests() -> bool {
loop {
if true {
return format!("test {}", "test")
}
-fn main() {
- let _ = test_end_of_fn();
- let _ = test_if_block();
- let _ = test_match(true);
- let _ = test_match_with_unreachable(true);
- let _ = test_loop();
- let _ = test_loop_with_block();
- let _ = test_loop_with_nests();
- let _ = test_loop_with_if_let();
- test_closure();
- let _ = test_return_macro();
+fn macro_branch_test() -> bool {
+ macro_rules! m {
+ ($t:expr, $f:expr) => {
+ if true { $t } else { $f }
+ };
+ }
+ return m!(true, false)
+}
+
+fn loop_test() -> bool {
+ 'outer: loop {
+ if true {
+ return true;
+ }
+
+ let _ = loop {
+ if false {
+ return false;
+ }
+ if true {
+ break true;
+ }
+ };
+ }
}
+
+fn loop_macro_test() -> bool {
+ macro_rules! m {
+ ($e:expr) => {
+ break $e
+ };
+ }
+ return loop {
+ m!(true);
+ }
+}
+
+fn divergent_test() -> bool {
+ fn diverge() -> ! {
+ panic!()
+ }
+ diverge()
+}
+
+fn main() {}
// run-rustfix
#![warn(clippy::implicit_return)]
-#![allow(clippy::needless_return, unused)]
+#![allow(clippy::needless_return, clippy::needless_bool, unused, clippy::never_loop)]
fn test_end_of_fn() -> bool {
if true {
true
}
-#[allow(clippy::needless_bool)]
fn test_if_block() -> bool {
if true { true } else { false }
}
}
}
-#[allow(clippy::needless_return)]
fn test_match_with_unreachable(x: bool) -> bool {
match x {
true => return false,
}
}
-#[allow(clippy::never_loop)]
fn test_loop() -> bool {
loop {
break true;
}
}
-#[allow(clippy::never_loop)]
fn test_loop_with_block() -> bool {
loop {
{
}
}
-#[allow(clippy::never_loop)]
fn test_loop_with_nests() -> bool {
loop {
if true {
format!("test {}", "test")
}
-fn main() {
- let _ = test_end_of_fn();
- let _ = test_if_block();
- let _ = test_match(true);
- let _ = test_match_with_unreachable(true);
- let _ = test_loop();
- let _ = test_loop_with_block();
- let _ = test_loop_with_nests();
- let _ = test_loop_with_if_let();
- test_closure();
- let _ = test_return_macro();
+fn macro_branch_test() -> bool {
+ macro_rules! m {
+ ($t:expr, $f:expr) => {
+ if true { $t } else { $f }
+ };
+ }
+ m!(true, false)
}
+
+fn loop_test() -> bool {
+ 'outer: loop {
+ if true {
+ break true;
+ }
+
+ let _ = loop {
+ if false {
+ break 'outer false;
+ }
+ if true {
+ break true;
+ }
+ };
+ }
+}
+
+fn loop_macro_test() -> bool {
+ macro_rules! m {
+ ($e:expr) => {
+ break $e
+ };
+ }
+ loop {
+ m!(true);
+ }
+}
+
+fn divergent_test() -> bool {
+ fn diverge() -> ! {
+ panic!()
+ }
+ diverge()
+}
+
+fn main() {}
= note: `-D clippy::implicit-return` implied by `-D warnings`
error: missing `return` statement
- --> $DIR/implicit_return.rs:17:15
+ --> $DIR/implicit_return.rs:16:15
|
LL | if true { true } else { false }
| ^^^^ help: add `return` as shown: `return true`
error: missing `return` statement
- --> $DIR/implicit_return.rs:17:29
+ --> $DIR/implicit_return.rs:16:29
|
LL | if true { true } else { false }
| ^^^^^ help: add `return` as shown: `return false`
error: missing `return` statement
- --> $DIR/implicit_return.rs:23:17
+ --> $DIR/implicit_return.rs:22:17
|
LL | true => false,
| ^^^^^ help: add `return` as shown: `return false`
error: missing `return` statement
- --> $DIR/implicit_return.rs:24:20
+ --> $DIR/implicit_return.rs:23:20
|
LL | false => { true },
| ^^^^ help: add `return` as shown: `return true`
error: missing `return` statement
- --> $DIR/implicit_return.rs:39:9
+ --> $DIR/implicit_return.rs:36:9
|
LL | break true;
| ^^^^^^^^^^ help: change `break` to `return` as shown: `return true`
error: missing `return` statement
- --> $DIR/implicit_return.rs:47:13
+ --> $DIR/implicit_return.rs:43:13
|
LL | break true;
| ^^^^^^^^^^ help: change `break` to `return` as shown: `return true`
error: missing `return` statement
- --> $DIR/implicit_return.rs:56:13
+ --> $DIR/implicit_return.rs:51:13
|
LL | break true;
| ^^^^^^^^^^ help: change `break` to `return` as shown: `return true`
error: missing `return` statement
- --> $DIR/implicit_return.rs:74:18
+ --> $DIR/implicit_return.rs:69:18
|
LL | let _ = || { true };
| ^^^^ help: add `return` as shown: `return true`
error: missing `return` statement
- --> $DIR/implicit_return.rs:75:16
+ --> $DIR/implicit_return.rs:70:16
|
LL | let _ = || true;
| ^^^^ help: add `return` as shown: `return true`
error: missing `return` statement
- --> $DIR/implicit_return.rs:83:5
+ --> $DIR/implicit_return.rs:78:5
|
LL | format!("test {}", "test")
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: add `return` as shown: `return format!("test {}", "test")`
-error: aborting due to 11 previous errors
+error: missing `return` statement
+ --> $DIR/implicit_return.rs:87:5
+ |
+LL | m!(true, false)
+ | ^^^^^^^^^^^^^^^ help: add `return` as shown: `return m!(true, false)`
+
+error: missing `return` statement
+ --> $DIR/implicit_return.rs:93:13
+ |
+LL | break true;
+ | ^^^^^^^^^^ help: change `break` to `return` as shown: `return true`
+
+error: missing `return` statement
+ --> $DIR/implicit_return.rs:98:17
+ |
+LL | break 'outer false;
+ | ^^^^^^^^^^^^^^^^^^ help: change `break` to `return` as shown: `return false`
+
+error: missing `return` statement
+ --> $DIR/implicit_return.rs:113:5
+ |
+LL | / loop {
+LL | | m!(true);
+LL | | }
+ | |_____^
+ |
+help: add `return` as shown
+ |
+LL | return loop {
+LL | m!(true);
+LL | }
+ |
+
+error: aborting due to 15 previous errors
projects / rust.git / commitdiff