rust/tests/ui/explicit_counter_loop.rs

#![warn(clippy::explicit_counter_loop)]
#![allow(clippy::useless_vec)]
//@no-rustfix: suggestion does not remove the `+= 1`
fn main() {
    let mut vec = vec![1, 2, 3, 4];
    let mut _index = 0;
    for _v in &vec {
        //~^ explicit_counter_loop

        _index += 1
    }

    let mut _index = 1;
    _index = 0;
    for _v in &vec {
        //~^ explicit_counter_loop

        _index += 1
    }

    let mut _index = 0;
    for _v in &mut vec {
        //~^ explicit_counter_loop

        _index += 1;
    }

    let mut _index = 0;
    for _v in vec {
        //~^ explicit_counter_loop

        _index += 1;
    }

    let vec = [1, 2, 3, 4];
    let mut _index = 0;
    _index = 1;
    for _v in &vec {
        //~^ explicit_counter_loop
        _index += 1
    }

    let mut _index = 0;
    _index += 1;
    for _v in &vec {
        _index += 1
    }

    let mut _index = 0;
    for _v in &vec {
        _index = 1;
        _index += 1
    }

    let mut _index = 0;
    for _v in &vec {
        let mut _index = 0;
        _index += 1
    }

    let mut _index = 0;
    for _v in &vec {
        _index += 1;
        _index = 0;
    }

    let mut _index = 0;
    if true {
        _index = 1
    };
    for _v in &vec {
        _index += 1
    }

    let mut _index = 1;
    if false {
        _index = 0
    };
    for _v in &vec {
        _index += 1
    }
}

mod issue_1219 {
    pub fn test() {
        // should not trigger the lint because variable is used after the loop #473
        let vec = vec![1, 2, 3];
        let mut index = 0;
        for _v in &vec {
            index += 1
        }
        println!("index: {index}");

        // should not trigger the lint because the count is conditional #1219
        let text = "banana";
        let mut count = 0;
        for ch in text.chars() {
            println!("{count}");
            if ch == 'a' {
                continue;
            }
            count += 1;
        }

        // should not trigger the lint because the count is conditional
        let text = "banana";
        let mut count = 0;
        for ch in text.chars() {
            println!("{count}");
            if ch == 'a' {
                count += 1;
            }
        }

        // should trigger the lint because the count is not conditional
        let text = "banana";
        let mut count = 0;
        for ch in text.chars() {
            //~^ explicit_counter_loop

            println!("{count}");
            count += 1;
            if ch == 'a' {
                continue;
            }
        }

        // should trigger the lint because the count is not conditional
        let text = "banana";
        let mut count = 0;
        for ch in text.chars() {
            //~^ explicit_counter_loop

            println!("{count}");
            count += 1;
            for i in 0..2 {
                let _ = 123;
            }
        }

        // should not trigger the lint because the count is incremented multiple times
        let text = "banana";
        let mut count = 0;
        for ch in text.chars() {
            println!("{count}");
            count += 1;
            for i in 0..2 {
                count += 1;
            }
        }
    }
}

mod issue_3308 {
    pub fn test() {
        // should not trigger the lint because the count is incremented multiple times
        let mut skips = 0;
        let erasures = vec![];
        for i in 0..10 {
            println!("{skips}");
            while erasures.contains(&(i + skips)) {
                skips += 1;
            }
        }

        // should not trigger the lint because the count is incremented multiple times
        let mut skips = 0;
        for i in 0..10 {
            println!("{skips}");
            let mut j = 0;
            while j < 5 {
                skips += 1;
                j += 1;
            }
        }

        // should not trigger the lint because the count is incremented multiple times
        let mut skips = 0;
        for i in 0..10 {
            println!("{skips}");
            for j in 0..5 {
                skips += 1;
            }
        }
    }
}

mod issue_1670 {
    pub fn test() {
        let mut count = 0;
        for _i in 3..10 {
            //~^ explicit_counter_loop

            count += 1;
        }
    }
}

mod issue_4732 {
    pub fn test() {
        let slice = &[1, 2, 3];
        let mut index = 0;

        // should not trigger the lint because the count is used after the loop
        for _v in slice {
            index += 1
        }
        let _closure = || println!("index: {index}");
    }
}

mod issue_4677 {
    pub fn test() {
        let slice = &[1, 2, 3];

        // should not trigger the lint because the count is used after incremented
        let mut count = 0;
        for _i in slice {
            count += 1;
            println!("{count}");
        }
    }
}

mod issue_7920 {
    pub fn test() {
        let slice = &[1, 2, 3];

        let index_usize: usize = 0;
        let mut idx_usize: usize = 0;

        // should suggest `enumerate`
        for _item in slice {
            //~^ explicit_counter_loop

            if idx_usize == index_usize {
                break;
            }

            idx_usize += 1;
        }

        let index_u32: u32 = 0;
        let mut idx_u32: u32 = 0;

        // should suggest `zip`
        for _item in slice {
            //~^ explicit_counter_loop

            if idx_u32 == index_u32 {
                break;
            }

            idx_u32 += 1;
        }
    }
}

mod issue_10058 {
    pub fn test() {
        // should not lint since we are increasing counter potentially more than once in the loop
        let values = [0, 1, 0, 1, 1, 1, 0, 1, 0, 1];
        let mut counter = 0;
        for value in values {
            counter += 1;

            if value == 0 {
                continue;
            }

            counter += 1;
        }
    }

    pub fn test2() {
        // should not lint since we are increasing counter potentially more than once in the loop
        let values = [0, 1, 0, 1, 1, 1, 0, 1, 0, 1];
        let mut counter = 0;
        for value in values {
            counter += 1;

            if value != 0 {
                counter += 1;
            }
        }
    }
}

mod issue_13123 {
    pub fn test() {
        let mut vec = vec![1, 2, 3, 4];
        let mut _index = 0;
        'label: for v in vec {
            //~^ explicit_counter_loop
            _index += 1;
            if v == 1 {
                break 'label;
            }
        }
    }
}

fn issue16612(v: Vec<u8>, s: i64) {
    use std::hint::black_box;

    let mut i = 1;
    for item in &v {
        //~^ explicit_counter_loop
        black_box((i, *item));
        i += 1;
    }

    let mut j = s + 1;
    for item in &v {
        //~^ explicit_counter_loop
        black_box((j, *item));
        j += 1;
    }
}

fn issue16640(x: &[u8]) {
    struct Priority(u8);

    impl core::ops::AddAssign<u8> for Priority {
        fn add_assign(&mut self, rhs: u8) {
            self.0 += rhs
        }
    }

    let mut priority = Priority(1);
    for _val in x {
        priority += 1;
    }
}

pub fn issue_16642() {
    let mut base = 100;
    const MAX: usize = 10;
    for _ in 0..MAX {
        //~^ explicit_counter_loop
        base += 1;
    }

    let mut base = 100;

    let nums = vec![1, 2, 3, 4];
    for _ in nums {
        //~^ explicit_counter_loop
        base += 1;
    }

    // inclusive range: should not suggest .take()
    let mut base = 100;
    for _ in 0..=MAX {
        //~^ explicit_counter_loop
        base += 1;
    }

    // non-zero start: should not suggest .take(), falls through to zip
    let mut base = 100;
    for _ in 5..MAX {
        //~^ explicit_counter_loop
        base += 1;
    }
}