zero_len_vec_used for iterating, using vec.len(), or slicing after Vec::with_capacity

[jakubdabek]

What it does

Checks for empty Vecs and usage that requires it to be non-empty to make sense.

Similar to read_zero_byte_vec, but more general.

Advantage

• Catches when someone writes Vec::with_capacity (or Vec::new(), Vec::default(), vec![]) and tries to incorrectly use it as if it was filled.

Drawbacks

• It could suggest a possible resolution, but it won't work in all cases.
• Not sure how it should interact with loops

Example

// 1)
let mut v = Vec::with_capacity(100);
let mut rng = rand::rng();
for elem in &mut v {
    *elem = rng::random::<i32>();
}

// 2)
let mut v = Vec::with_capacity(100);
for (i, elem) in v.iter_mut().enumerate() {
    *elem = i;
}

// 3)
let mut v = Vec::with_capacity(100);
// Will always be 0.
foo(v.len());

// 4)
// slice, not `&mut Vec`, this covers `Read::read` case as well
fn foo(_: &mut [T]) {...}
let mut v = Vec::with_capacity(100);
// Will always be empty.
foo(&mut v);

// 5)
let mut v = Vec::<u32>::with_capacity(100);
// Will always be `None`.
foo(v.pop());

// 6)
let mut v = Vec::<u32>::with_capacity(100);
// Will always be false.
if !v.is_empty() {
    foo();
}

// 7)
let mut v = Vec::with_capacity(100);
loop {
    // always 0
    let len = v.len();
    // code that doesn't modify `v`
}

// 8)
// Should this be linted?
let mut v = Vec::with_capacity(100);
loop {
    // always 0 in the first iteration
    let len = v.len();
    // code that *possibly* modifies `v`
}

// 9)
// Possible interaction with `impossible_comparisons`, `never_loop` or something similar.
let mut v = Vec::with_capacity(100);
// Will never enter the loop.
while v.len() > 0 {
    v.pop();
}

// 10)
let mut v = Vec::with_capacity(100);
// Check patterns too.
// Will never enter the loop.
while let [.., last] = &v[..] {
    v.pop();
}

Could be written as:

let mut v = Vec::with_capacity(100);
// Not always applicable with `Default`.
// Also this could be optimized out, but a generic suggestion
// would not be performance-oriented.
v.resize_with(100, Default::default);
let mut rng = rand::rng();
for elem in &mut v {
    *elem = rng::random::<i32>();
}

// 3)
let mut v = Vec::with_capacity(100);
foo(0); // probably incorrect

// 4)
fn foo(_: &mut [T]) {...}
let mut v = Vec::with_capacity(100);
v.resize_with(100, Default::default);
foo(&mut v);