1 use super::utils::make_iterator_snippet;
3 use clippy_utils::diagnostics::span_lint_and_then;
4 use clippy_utils::higher::ForLoop;
5 use clippy_utils::source::snippet;
6 use rustc_errors::Applicability;
7 use rustc_hir::{Block, Destination, Expr, ExprKind, HirId, InlineAsmOperand, Pat, Stmt, StmtKind};
8 use rustc_lint::LateContext;
10 use std::iter::{once, Iterator};
17 for_loop: Option<&ForLoop<'_>>,
19 match never_loop_block(block, &mut Vec::new(), loop_id) {
20 NeverLoopResult::AlwaysBreak => {
21 span_lint_and_then(cx, NEVER_LOOP, span, "this loop never actually loops", |diag| {
29 // Suggests using an `if let` instead. This is `Unspecified` because the
30 // loop may (probably) contain `break` statements which would be invalid
32 diag.span_suggestion_verbose(
33 for_span.with_hi(iterator.span.hi()),
34 "if you need the first element of the iterator, try writing",
35 for_to_if_let_sugg(cx, iterator, pat),
36 Applicability::Unspecified,
41 NeverLoopResult::MayContinueMainLoop | NeverLoopResult::Otherwise => (),
45 #[derive(Copy, Clone)]
46 enum NeverLoopResult {
47 // A break/return always get triggered but not necessarily for the main loop.
49 // A continue may occur for the main loop.
55 fn absorb_break(arg: NeverLoopResult) -> NeverLoopResult {
57 NeverLoopResult::AlwaysBreak | NeverLoopResult::Otherwise => NeverLoopResult::Otherwise,
58 NeverLoopResult::MayContinueMainLoop => NeverLoopResult::MayContinueMainLoop,
62 // Combine two results for parts that are called in order.
64 fn combine_seq(first: NeverLoopResult, second: NeverLoopResult) -> NeverLoopResult {
66 NeverLoopResult::AlwaysBreak | NeverLoopResult::MayContinueMainLoop => first,
67 NeverLoopResult::Otherwise => second,
71 // Combine two results where both parts are called but not necessarily in order.
73 fn combine_both(left: NeverLoopResult, right: NeverLoopResult) -> NeverLoopResult {
75 (NeverLoopResult::MayContinueMainLoop, _) | (_, NeverLoopResult::MayContinueMainLoop) => {
76 NeverLoopResult::MayContinueMainLoop
78 (NeverLoopResult::AlwaysBreak, _) | (_, NeverLoopResult::AlwaysBreak) => NeverLoopResult::AlwaysBreak,
79 (NeverLoopResult::Otherwise, NeverLoopResult::Otherwise) => NeverLoopResult::Otherwise,
83 // Combine two results where only one of the part may have been executed.
85 fn combine_branches(b1: NeverLoopResult, b2: NeverLoopResult) -> NeverLoopResult {
87 (NeverLoopResult::AlwaysBreak, NeverLoopResult::AlwaysBreak) => NeverLoopResult::AlwaysBreak,
88 (NeverLoopResult::MayContinueMainLoop, _) | (_, NeverLoopResult::MayContinueMainLoop) => {
89 NeverLoopResult::MayContinueMainLoop
91 (NeverLoopResult::Otherwise, _) | (_, NeverLoopResult::Otherwise) => NeverLoopResult::Otherwise,
95 fn never_loop_block(block: &Block<'_>, ignore_ids: &mut Vec<HirId>, main_loop_id: HirId) -> NeverLoopResult {
99 .filter_map(stmt_to_expr)
100 .chain(block.expr.map(|expr| (expr, None)));
102 iter.map(|(e, els)| {
103 let e = never_loop_expr(e, ignore_ids, main_loop_id);
104 // els is an else block in a let...else binding
105 els.map_or(e, |els| {
106 combine_branches(e, never_loop_block(els, ignore_ids, main_loop_id))
109 .fold(NeverLoopResult::Otherwise, combine_seq)
112 fn stmt_to_expr<'tcx>(stmt: &Stmt<'tcx>) -> Option<(&'tcx Expr<'tcx>, Option<&'tcx Block<'tcx>>)> {
114 StmtKind::Semi(e) | StmtKind::Expr(e) => Some((e, None)),
115 // add the let...else expression (if present)
116 StmtKind::Local(local) => local.init.map(|init| (init, local.els)),
117 StmtKind::Item(..) => None,
121 #[allow(clippy::too_many_lines)]
122 fn never_loop_expr(expr: &Expr<'_>, ignore_ids: &mut Vec<HirId>, main_loop_id: HirId) -> NeverLoopResult {
125 | ExprKind::Unary(_, e)
126 | ExprKind::Cast(e, _)
127 | ExprKind::Type(e, _)
128 | ExprKind::Field(e, _)
129 | ExprKind::AddrOf(_, _, e)
130 | ExprKind::Repeat(e, _)
131 | ExprKind::DropTemps(e) => never_loop_expr(e, ignore_ids, main_loop_id),
132 ExprKind::Let(let_expr) => never_loop_expr(let_expr.init, ignore_ids, main_loop_id),
133 ExprKind::Array(es) | ExprKind::Tup(es) => never_loop_expr_all(&mut es.iter(), ignore_ids, main_loop_id),
134 ExprKind::MethodCall(_, receiver, es, _) => never_loop_expr_all(
135 &mut std::iter::once(receiver).chain(es.iter()),
139 ExprKind::Struct(_, fields, base) => {
140 let fields = never_loop_expr_all(&mut fields.iter().map(|f| f.expr), ignore_ids, main_loop_id);
141 if let Some(base) = base {
142 combine_both(fields, never_loop_expr(base, ignore_ids, main_loop_id))
147 ExprKind::Call(e, es) => never_loop_expr_all(&mut once(e).chain(es.iter()), ignore_ids, main_loop_id),
148 ExprKind::Binary(_, e1, e2)
149 | ExprKind::Assign(e1, e2, _)
150 | ExprKind::AssignOp(_, e1, e2)
151 | ExprKind::Index(e1, e2) => never_loop_expr_all(&mut [e1, e2].iter().copied(), ignore_ids, main_loop_id),
152 ExprKind::Loop(b, _, _, _) => {
153 // Break can come from the inner loop so remove them.
154 absorb_break(never_loop_block(b, ignore_ids, main_loop_id))
156 ExprKind::If(e, e2, e3) => {
157 let e1 = never_loop_expr(e, ignore_ids, main_loop_id);
158 let e2 = never_loop_expr(e2, ignore_ids, main_loop_id);
159 let e3 = e3.as_ref().map_or(NeverLoopResult::Otherwise, |e| {
160 never_loop_expr(e, ignore_ids, main_loop_id)
162 combine_seq(e1, combine_branches(e2, e3))
164 ExprKind::Match(e, arms, _) => {
165 let e = never_loop_expr(e, ignore_ids, main_loop_id);
169 let arms = never_loop_expr_branch(&mut arms.iter().map(|a| a.body), ignore_ids, main_loop_id);
173 ExprKind::Block(b, l) => {
175 ignore_ids.push(b.hir_id);
177 let ret = never_loop_block(b, ignore_ids, main_loop_id);
181 ExprKind::Continue(d) => {
184 .expect("target ID can only be missing in the presence of compilation errors");
185 if id == main_loop_id {
186 NeverLoopResult::MayContinueMainLoop
188 NeverLoopResult::AlwaysBreak
191 // checks if break targets a block instead of a loop
192 ExprKind::Break(Destination { target_id: Ok(t), .. }, e) if ignore_ids.contains(&t) => e
193 .map_or(NeverLoopResult::Otherwise, |e| {
194 combine_seq(never_loop_expr(e, ignore_ids, main_loop_id), NeverLoopResult::Otherwise)
196 ExprKind::Break(_, e) | ExprKind::Ret(e) => e.as_ref().map_or(NeverLoopResult::AlwaysBreak, |e| {
198 never_loop_expr(e, ignore_ids, main_loop_id),
199 NeverLoopResult::AlwaysBreak,
202 ExprKind::InlineAsm(asm) => asm
205 .map(|(o, _)| match o {
206 InlineAsmOperand::In { expr, .. } | InlineAsmOperand::InOut { expr, .. } => {
207 never_loop_expr(expr, ignore_ids, main_loop_id)
209 InlineAsmOperand::Out { expr, .. } => {
210 never_loop_expr_all(&mut expr.iter().copied(), ignore_ids, main_loop_id)
212 InlineAsmOperand::SplitInOut { in_expr, out_expr, .. } => never_loop_expr_all(
213 &mut once(*in_expr).chain(out_expr.iter().copied()),
217 InlineAsmOperand::Const { .. }
218 | InlineAsmOperand::SymFn { .. }
219 | InlineAsmOperand::SymStatic { .. } => NeverLoopResult::Otherwise,
221 .fold(NeverLoopResult::Otherwise, combine_both),
222 ExprKind::Yield(_, _)
223 | ExprKind::Closure { .. }
225 | ExprKind::ConstBlock(_)
227 | ExprKind::Err => NeverLoopResult::Otherwise,
231 fn never_loop_expr_all<'a, T: Iterator<Item = &'a Expr<'a>>>(
233 ignore_ids: &mut Vec<HirId>,
235 ) -> NeverLoopResult {
236 es.map(|e| never_loop_expr(e, ignore_ids, main_loop_id))
237 .fold(NeverLoopResult::Otherwise, combine_both)
240 fn never_loop_expr_branch<'a, T: Iterator<Item = &'a Expr<'a>>>(
242 ignore_ids: &mut Vec<HirId>,
244 ) -> NeverLoopResult {
245 e.map(|e| never_loop_expr(e, ignore_ids, main_loop_id))
246 .fold(NeverLoopResult::AlwaysBreak, combine_branches)
249 fn for_to_if_let_sugg(cx: &LateContext<'_>, iterator: &Expr<'_>, pat: &Pat<'_>) -> String {
250 let pat_snippet = snippet(cx, pat.span, "_");
251 let iter_snippet = make_iterator_snippet(cx, iterator, &mut Applicability::Unspecified);
253 format!("if let Some({pat_snippet}) = {iter_snippet}.next()")