cargo fix inserts invalid trait bound + use<>, compiles silently without error

[alfredjstanley]

Summary

During an edition migration (2021 → 2024), running cargo fix --edition inserted the following return type:

fn get_id_hash_sets(id_sets: &[&[(IdType, &str)]]) -> impl Iterator<Item = IdHashSet> + use<> {

Despite use being a reserved keyword and not a valid trait, the compiler accepts this code without any errors or warnings. This behavior occurs both in test modules and in regular code, potentially leading to undetected bugs.

---

Reproduction Steps

1. Create a new Rust project.

2. Add the following code to main.rs:

   fn get_stuff() -> impl Iterator<Item = u32> + use<> {
       vec![1, 2, 3].into_iter()
   }
   
   fn main() {
       for i in get_stuff() {
           println!("{}", i);
       }
   }

3. Run cargo check or cargo build.

---

Expected Behavior

The compiler should produce an error indicating that use is a reserved keyword and cannot be used as a trait bound.

---

Actual Behavior

The code compiles successfully without any errors or warnings.

---

Version Information

$ rustc --version
rustc 1.87.0 (17067e9ac 2025-05-09)

$ cargo --version
cargo 1.87.0

---

Additional Notes

• This issue was discovered after running cargo fix --edition, which inserted the invalid trait bound.

• The problem persists in both test modules and regular code.

• The compiler's silent acceptance of invalid syntax could lead to subtle bugs and undermines Rust's safety guarantees.

---

Labels

• C-bug

• T-compiler

• T-cargo

• A-impl-trait

• A-suggestion-diagnostics

[ShE3py]

This is not a trait bound, but valid syntax:
https://doc.rust-lang.org/reference/types/impl-trait.html#precise-capturing

In Rust ⩽ 2021, this fails to compile:

fn iter(slice: &[u8]) -> impl Iterator<Item = u8> {
    slice.iter().copied()
    //^ this borrows `slice`, but the no lifetimes is present in the return type
}

As this is desugared to:

fn iter<'a>(slice: &'a [u8]) -> impl Iterator<Item = u8> + use<> {
    slice.iter().copied()
    //^ this borrows `slice` for `'a`, but the return type don't borrows `'a`
}

While Rust 2024 desugar this to:

fn iter<'a>(slice: &'a [u8]) -> impl Iterator<Item = u8> + use<'a> {
    slice.iter().copied()
    //^ okay, the return types borrows `'a`
}

Which compiles fine. To preserve Rust 2021 semantics, an explicit use<> is added to avoid borrowing the hidden lifetime, as otherwise it may leads to regressions:

fn iter(_: &[u8]) -> impl Iterator<Item = u8> {
    std::iter::empty()
}

fn foo() {
    let mut array = [0; 4];
    let iter = iter(&array);
    array[0] = 2;
    //^ compiles fine in Rust 2021,
    //| but fails to compile in Rust 2024 (as `iter()` borrows `array`)
}

[fmease]

Closing as works as intended as elaborated by ShE3py.