"This generic parameter must be used with a generic lifetime parameter" on RPIT with precise capturing

[ugur-a]

I tried this code:

struct Foo<'a> {
    children: Vec<&'a Foo<'a>>,
}

struct Bar;

impl<'a> Foo<'a> {
    fn failing<'p>(&'a self, param: &'p Bar) -> impl Iterator<Item = String> + use<'a, 'p> {
        self.children.iter().flat_map(|child| child.failing(param))
    }
}

I expected to see this happen:
the code compiles, since param gets used by all the children

Or, if the code actually violates ownership rules, get a clearer error message.

Instead, this happened:
compiler complains with "This generic parameter must be used with a generic lifetime parameter"

I've tried the following solutions:

1. use an anonymous lifetime instead of 'p, like this:

fn failing(&'a self, param: &Bar) -> impl Iterator<Item = String> + use<'a, '_> { /* ... */ }

2. make the two lifetimes the same:

fn failing(&'a self, param: &'a Bar) -> impl Iterator<Item = String> + use<'a> { /* ... */ }

And still got the same bizarre error.

Meta

rustc 1.82.0 (f6e511eec 2024-10-15) (built from a source tarball)
binary: rustc
commit-hash: f6e511eec7342f59a25f7c0534f1dbea00d01b14
commit-date: 2024-10-15
host: x86_64-unknown-linux-gnu
release: 1.82.0
LLVM version: 18.1.8

also present on latest stable (1.83.0), beta (1.84.0-beta.6), and nightly (2025-01-05)

Backtrace

error[E0792]: expected generic lifetime parameter, found `'_`
   --> src/tree.rs:656:9
    |
655 |     fn failing<'p>(&'a self, param: &'p Bar) -> impl Iterator<Item = String> + use<'a, 'p> {
    |                                                                                    -- this generic parameter must be used with a generic lifetime parameter
656 |         self.children.iter().flat_map(|child| child.failing(param))
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

[fmease]

Smaller:

//@ edition: 2021

struct Foo<'a> { children: Vec<&'a Foo<'a>> }

impl Foo<'_> {
    fn failing(&self) -> impl Iterator<Item = String> + use<'_> {
        self.children.iter().flat_map(|child| child.failing())
    }
}

//@ edition: 2024

struct Foo<'a> { children: Vec<&'a Foo<'a>> }

impl Foo<'_> {
    fn failing(&self) -> impl Iterator<Item = String> {
        self.children.iter().flat_map(|child| child.failing())
    }
}

[ugur-a]

Oh okay, I though having at least one other parameter was necessary as well. If it's not, then struct Bar; isn't either