fix(while_let_loop): detect the pattern when the loop has a label

fixes #17590

Author: durationextender

clippy_lints/src/loops/while_let_loop.rs

@@ -4,7 +4,7 @@ use clippy_utils::source::{snippet, snippet_indent, snippet_opt};
 use clippy_utils::ty::needs_ordered_drop;
 use clippy_utils::visitors::any_temporaries_need_ordered_drop;
 use clippy_utils::{higher, peel_blocks};
-use rustc_ast::BindingMode;
+use rustc_ast::{BindingMode, Label};
 use rustc_errors::Applicability;
 use rustc_hir::{Block, Expr, ExprKind, LetStmt, MatchSource, Pat, PatKind, Path, QPath, StmtKind, Ty};
 use rustc_lint::LateContext;
@@ -26,10 +26,14 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, loop_blo
         _ => return,
     };
     let has_trailing_exprs = loop_block.stmts.len() + usize::from(loop_block.expr.is_some()) > 1;
-
+    let loop_label = if let ExprKind::Loop(_, label, ..) = expr.kind {
+        label
+    } else {
+        None
+    };
     if let Some(if_let) = higher::IfLet::hir(cx, init)
         && let Some(else_expr) = if_let.if_else
-        && is_simple_break_expr(else_expr)
+        && is_simple_break_expr(else_expr, loop_label)
     {
         could_be_while_let(
             cx,
@@ -40,14 +44,14 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, loop_blo
             let_info,
             Some(if_let.if_then),
         );
-    } else if els.is_some_and(is_simple_break_block)
+    } else if els.is_some_and(|b| is_simple_break_block(b, loop_label))
         && let Some((pat, _)) = let_info
     {
         could_be_while_let(cx, expr, pat, init, has_trailing_exprs, let_info, None);
     } else if let ExprKind::Match(scrutinee, [arm1, arm2], MatchSource::Normal) = init.kind
         && arm1.guard.is_none()
         && arm2.guard.is_none()
-        && is_simple_break_expr(arm2.body)
+        && is_simple_break_expr(arm2.body, loop_label)
     {
         could_be_while_let(
             cx,
@@ -61,22 +65,22 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, loop_blo
     }
 }
 
-/// Checks if `block` contains a single unlabeled `break` expression or statement, possibly embedded
-/// inside other blocks.
-fn is_simple_break_block(block: &Block<'_>) -> bool {
+/// Checks if `block` contains a single unlabeled and importantly now also a labeled `break`
+/// expression or statement, possibly embedded inside other blocks.
+fn is_simple_break_block(block: &Block<'_>, looplabel: Option<Label>) -> bool {
     match (block.stmts, block.expr) {
-        ([s], None) => matches!(s.kind, StmtKind::Expr(e) | StmtKind::Semi(e) if is_simple_break_expr(e)),
-        ([], Some(e)) => is_simple_break_expr(e),
+        ([s], None) => matches!(s.kind, StmtKind::Expr(e) | StmtKind::Semi(e) if is_simple_break_expr(e, looplabel)),
+        ([], Some(e)) => is_simple_break_expr(e, looplabel),
         _ => false,
     }
 }
 
-/// Checks if `expr` contains a single unlabeled `break` expression or statement, possibly embedded
-/// inside other blocks.
-fn is_simple_break_expr(expr: &Expr<'_>) -> bool {
+/// Checks if `expr` contains a single unlabeled and importantly now also a labeled `break`
+/// expression or statement, possibly embedded inside other blocks.
+fn is_simple_break_expr(expr: &Expr<'_>, looplabel: Option<Label>) -> bool {
     match expr.kind {
-        ExprKind::Block(b, _) => is_simple_break_block(b),
-        ExprKind::Break(dest, None) => dest.label.is_none(),
+        ExprKind::Block(b, _) => is_simple_break_block(b, looplabel),
+        ExprKind::Break(dest, None) => dest.label.is_none() || dest.label == looplabel,
         _ => false,
     }
 }

tests/ui/while_let_loop.rs

@@ -274,3 +274,35 @@ fn issue16378() {
         println!("x = {x}");
     }
 }
+
+fn issue17590_labeled_loop() {
+    let mut it = [1, 2, 3].iter();
+    'cool: loop {
+        //~^ while_let_loop
+        match it.next() {
+            Some(_) => {},
+            None => break 'cool,
+        }
+    }
+}
+
+fn issue17590_labeled_if_let() {
+    let mut it = [1, 2, 3].iter();
+    'outer: loop {
+        //~^ while_let_loop
+        if let Some(x) = it.next() {
+            println!("{x}");
+        } else {
+            break 'outer;
+        }
+    }
+}
+
+fn issue17590_labeled_let_else() {
+    let mut it = [1, 2, 3].iter();
+    'outer: loop {
+        //~^ while_let_loop
+        let Some(x) = it.next() else { break 'outer };
+        println!("{x}");
+    }
+}

tests/ui/while_let_loop.stderr

@@ -186,5 +186,37 @@ LL +         ..
 LL +     }
    |
 
-error: aborting due to 12 previous errors
+error: this loop could be written as a `while let` loop
+  --> tests/ui/while_let_loop.rs:280:5
+   |
+LL | /     'cool: loop {
+LL | |
+LL | |         match it.next() {
+LL | |             Some(_) => {},
+...  |
+LL | |     }
+   | |_____^ help: try: `while let Some(_) = it.next() { .. }`
+
+error: this loop could be written as a `while let` loop
+  --> tests/ui/while_let_loop.rs:291:5
+   |
+LL | /     'outer: loop {
+LL | |
+LL | |         if let Some(x) = it.next() {
+LL | |             println!("{x}");
+...  |
+LL | |     }
+   | |_____^ help: try: `while let Some(x) = it.next() { .. }`
+
+error: this loop could be written as a `while let` loop
+  --> tests/ui/while_let_loop.rs:303:5
+   |
+LL | /     'outer: loop {
+LL | |
+LL | |         let Some(x) = it.next() else { break 'outer };
+LL | |         println!("{x}");
+LL | |     }
+   | |_____^ help: try: `while let Some(x) = it.next() { .. }`
+
+error: aborting due to 15 previous errors