1 use super::WHILE_LET_LOOP
;
2 use clippy_utils
::diagnostics
::span_lint_and_sugg
;
3 use clippy_utils
::source
::snippet_with_applicability
;
4 use rustc_errors
::Applicability
;
5 use rustc_hir
::{Block, Expr, ExprKind, MatchSource, StmtKind}
;
6 use rustc_lint
::{LateContext, LintContext}
;
7 use rustc_middle
::lint
::in_external_macro
;
9 pub(super) fn check(cx
: &LateContext
<'tcx
>, expr
: &'tcx Expr
<'_
>, loop_block
: &'tcx Block
<'_
>) {
10 // extract the expression from the first statement (if any) in a block
11 let inner_stmt_expr
= extract_expr_from_first_stmt(loop_block
);
12 // or extract the first expression (if any) from the block
13 if let Some(inner
) = inner_stmt_expr
.or_else(|| extract_first_expr(loop_block
)) {
14 if let ExprKind
::Match(matchexpr
, arms
, ref source
) = inner
.kind
{
15 // ensure "if let" compatible match structure
17 MatchSource
::Normal
| MatchSource
::IfLetDesugar { .. }
=> {
19 && arms
[0].guard
.is_none()
20 && arms
[1].guard
.is_none()
21 && is_simple_break_expr(arms
[1].body
)
23 if in_external_macro(cx
.sess(), expr
.span
) {
27 // NOTE: we used to build a body here instead of using
28 // ellipsis, this was removed because:
29 // 1) it was ugly with big bodies;
30 // 2) it was not indented properly;
31 // 3) it wasn’t very smart (see #675).
32 let mut applicability
= Applicability
::HasPlaceholders
;
37 "this loop could be written as a `while let` loop",
40 "while let {} = {} {{ .. }}",
41 snippet_with_applicability(cx
, arms
[0].pat
.span
, "..", &mut applicability
),
42 snippet_with_applicability(cx
, matchexpr
.span
, "..", &mut applicability
),
54 /// If a block begins with a statement (possibly a `let` binding) and has an
55 /// expression, return it.
56 fn extract_expr_from_first_stmt
<'tcx
>(block
: &Block
<'tcx
>) -> Option
<&'tcx Expr
<'tcx
>> {
57 if block
.stmts
.is_empty() {
60 if let StmtKind
::Local(local
) = block
.stmts
[0].kind
{
61 local
.init
//.map(|expr| expr)
67 /// If a block begins with an expression (with or without semicolon), return it.
68 fn extract_first_expr
<'tcx
>(block
: &Block
<'tcx
>) -> Option
<&'tcx Expr
<'tcx
>> {
70 Some(expr
) if block
.stmts
.is_empty() => Some(expr
),
71 None
if !block
.stmts
.is_empty() => match block
.stmts
[0].kind
{
72 StmtKind
::Expr(expr
) | StmtKind
::Semi(expr
) => Some(expr
),
73 StmtKind
::Local(..) | StmtKind
::Item(..) => None
,
79 /// Returns `true` if expr contains a single break expr without destination label
81 /// passed expression. The expression may be within a block.
82 fn is_simple_break_expr(expr
: &Expr
<'_
>) -> bool
{
84 ExprKind
::Break(dest
, ref passed_expr
) if dest
.label
.is_none() && passed_expr
.is_none() => true,
85 ExprKind
::Block(b
, _
) => extract_first_expr(b
).map_or(false, |subexpr
| is_simple_break_expr(subexpr
)),