Rust-clippy: New lint: `while let Some(&x) = slice.iter().next()` is infinite loop

Created on 19 Sep 2019 · 9Comments · Source: rust-lang/rust-clippy

This code is an infinite loop: (Do not run this in playpen)

fn main() {
    let a = [1, 2, 3];
    while let Some(&x) = a.iter().next() {
        println!("{:?}", x);
    }
}

A-correctness A-suggestion L-lint good-first-issue hacktoberfest

Source

lzutao

All 9 comments

Basically calling _.iter() in the while let expression will lead to an infinite loop (except the collection is empty).

flip1995 on 19 Sep 2019

I'd love to contribute to Clippy. Since this is a good first issue I was hoping I could start working on it. Could I get some pointers on where in the code to get started?

pop on 26 Sep 2019

Cool! I usually start by writing a test case (create a new .rs file in tests/ui, see the other files there for examples). Then I look into where the lint fits in, for example clippy_lints/src/loops.rs might be a good fit. There you first need to add the lint declaration and add the lint to the LintPass. Finally you need some code to check for iter calls whose expr_ty implements Iterator.

llogiq on 26 Sep 2019

🚀1

I'm a little late, but this doc gives you step by step instructions on how to write a new lint. For this lint the Author lint chapter is probably interesting for you.

flip1995 on 30 Sep 2019

👀1

Hi all, if @pop is not going to tackle this issue, I'd like to take it. I've already taken a look at the resources, thanks @llogiq and @flip1995.
I think a LateLintPass fits here because we need the type information of the match arm.
From what I've seen this is the place where we should detect this condition and emit the lint message:

https://github.com/rust-lang/rust-clippy/blob/54bf4ffd626970e831bb80c037f804a3b3450835/clippy_lints/src/loops.rs#L560

This "desugars" the while let into a loop match, which in our case would be:

while let Some(&x) = a.iter().next() {
    println!("{:?}", x);
}

into

loop {
    match a.iter().next() {
        Some(&x) => { println!("{:?}", x); },
        _ => (),
        }
    }
}

Afterwards it decomposes the first arm using the pattern kind and the match_expre using the expression kind as well,

https://github.com/rust-lang/rust-clippy/blob/54bf4ffd626970e831bb80c037f804a3b3450835/clippy_lints/src/loops.rs#L561-L566

So that, roughly speaking:

pat is Some(&x) => { println!("{:?}", x); },
match_expr is a Method call => a.iter().next()

Where I get lost is how to get the type information from the qpath, and method_path.
I've looked into match_type in utils, but it seems it expects a different type, than qpath, which is a hir::QPath or in method_path case it is hir::PathSegment.

I'll keep looking into it, but if you have any useful pointers into what I should look into (HIR, MIR, Ty) or examples I would greatly appreciate it, specially since I'm new to clippy and rustc internals.