RPIT(IT)s "leak" internal implementation details of lifetime capturing via boundedness

[Y-jiji]

I tried this code:

trait A {
    type B<'a>;
}

struct Foo(u64);

impl A for Foo {
    type B<'a> = Bar<'a>;
}

struct Bar<'a>(&'a Foo);

trait X<Y: A> {
    fn method<'a, 'b>(&'a self, bar: Y::B<'b>) -> impl Iterator<Item=usize>;
}

struct Eric;

impl X<Foo> for Eric {
    fn method<'a, 'b>(&'a self, _bar: <Foo as A>::B<'b>) -> impl Iterator<Item=usize> {
        vec![1, 2].into_iter()
    }
}

struct Jack;

impl X<Foo> for Jack {
    fn method<'a, 'b>(&'a self, _bar: Bar<'b>) -> impl Iterator<Item=usize> {
        vec![1, 2].into_iter()
    }
}

fn main() {}

I expected to see this happen: implementation of X<Foo> on Jack compiles without error

• As you can see, Bar<'a> and <Foo as A>::B<'a> are exactly the same type.
• Therefore, implementation of X<Foo> on Jack and Eric should have identical behavior.
• Implementation of X<Foo> on Eric compiles.

Instead, this happened: implementation of X<Foo> on Jack gives the following error

error[E0195]: lifetime parameters or bounds on method `method` do not match the trait declaration
  --> gat-borrow-checking-bug.rs:28:14
   |
14 |     fn method<'a, 'b>(&'a self, bar: Y::B<'b>) -> impl Iterator<Item=usize>;
   |              -------- lifetimes in impl do not match this method in trait
...
28 |     fn method<'a, 'b>(&'a self, _bar: Bar<'b>) -> impl Iterator<Item=usize> {
   |              ^^^^^^^^ lifetimes do not match method in trait

error: aborting due to 1 previous error

Meta

rustc --version --verbose:

rustc 1.85.1 (4eb161250 2025-03-15)

Using the nightly version, it still doesn't work

rust version 1.88.0-nightly (74509131e 2025-04-29)

[Y-jiji]

@fmease @jieyouxu I'm willing to take some effort to fix this, but I'm absolutely a newbie in rust compiler. Can I get some help to get started?

[fmease]

You've encountered a detail of the type system: "Boundedness".

The 'b defined on assoc fn method in the last trait impl is late-bound but the 'b in the trait decl is early-bound and thus there's a mismatch. If you add where 'b: (sic!) or where 'b: 'b to the bottom-most method, then your linked code will compile because the where-clause forces that 'b to be early-bound thus matching the trait definition.

[fmease]

I guess you could call this an implementation detail of RPIT(IT)s leaking through (existential impl-Trait in return position). If an RPIT captures an in-scope lifetime, it forces it to be early-bound.

So if you have:

fn f0<'a>() {} // 'a is late-bound
fn f1<'a>() where 'a: {} // 'a is early-bound

fn f2<'a>() -> impl Sized {} // 'a is late-bound in Rust <2024 and early-bound in Rust >=2024
fn f3<'a>() -> impl Sized + use<> {} // 'a is late-bound
fn f4<'a>() -> impl Sized + use<'a> {} // 'a is early-bound

[fmease]

I g2g can't finish my explanation rn. Later then.

[fmease]

Okay, but there are indeed super fishy things going on...

1. In trait Trait { fn f<'a>() -> impl Sized; }, 'a is early-bound (as alluded to above).
2. However, in trait Trait { fn f<'a>(_: &'a ()) -> impl Sized; }, 'a is suddenly late-bound! What?
3. Moreover, in trait Trait { fn f<'a>(_: <&'a () as Identity>::Output) -> impl Sized; }, 'a is suddenly early-bound!

This is what this issue essentially boils down to!

Doesn't need RPITIT, RPIT also exhibits this behavior:

Code (Rust 2024, w.l.o.g.)	Boundedness of 'a
fn f<'a>() -> impl Sized {}	early
fn f<'a>(_: &'a ()) -> impl Sized {} → 'a	late
fn f<'a>(_: <&'a () as Identity>::Output) -> impl Sized {}	early
fn f<'a>(_: HideIdentity<&'a ()>) -> impl Sized {}1	late

Footnotes

1. With struct HideIdentity<T>(<T as Identity>::Output);. Meaning this doesn't directly have to do with variance, it seems. ↩

[fmease]

cc @compiler-errors

[fmease]

Let's look what #![rustc_variance_of_opaques] has to say for the last four examples:

Code	Variances of the opaque
fn f<'a>() -> impl Sized {}	['a: *, 'a: o]
fn f<'a>(_: &'a ()) -> impl Sized {} → 'a	['a: o]
fn f<'a>(_: <&'a () as Identity>::Output) -> impl Sized {}	['a: *, 'a: o]
fn f<'a>(_: HideIdentity<&'a ()>) -> impl Sized {}[^1]	['a: o]

but that doesn't tell us anything we don't already know.

[fmease]

Like, I obviously know of lifetime duplication for RPITITs (RPITs, too??) but that's not necessarily related.

The rules observed above seem super "arbitrary" just looking at these four examples. I obviously haven't looked into the compiler impl yet, I first need to find the relevant place. So I don't yet know if this is intentional, WONTFIX or 'worth fixing'.

Edit: Aye, I'm pretty sure what we observe here gets fully determined in fn is_late_bound_map. Likely relating to constrainedness.