Lifetime annotation not respected in recursive function with RPIT

Edit: See this comment for an unsoundness (in the old solver).

I tried this code:

fn conjure<T>() -> T { panic!() }

#[expect(unconditional_recursion)]
pub fn foo<'a: 'a>() -> impl Sized + use<> {
    let _: Contra<'a> = foo::<'a>();
    conjure()
}

struct Contra<'a>(fn(&'a ()));

I expect a compile error. Due to the use<>, the return type has to be Contra<'static>, which shouldn't be coercible to Contra<'a>. However, the above code compiles fine.

Changing let _ to let _x gives me the following error I expect:

error[E0700]: hidden type for `impl Sized` captures lifetime that does not appear in bounds
 --> src/lib.rs:5:26
  |
4 | pub fn foo<'a: 'a>() -> impl Sized + use<> {
  |            --           ------------------ opaque type defined here
  |            |
  |            hidden type `Contra<'a>` captures the lifetime `'a` as defined here
5 |     let _x: Contra<'a> = foo::<'a>();
  |                          ^^^^^^^^^^^
  |
help: add `'a` to the `use<...>` bound to explicitly capture it
  |
4 | pub fn foo<'a: 'a>() -> impl Sized + use<'a> {
  |                                          ++

For more information about this error, try `rustc --explain E0700`.

Meta

Reproducible on the playground with version 1.96.0-nightly (2026-03-08 b41f22de2a13a0babd28)

Start by running the src/lib.rs reproducer from the issue on the stated nightly version. Trace RPIT lifetime capture for the recursive foo::<’a>() call and compare it with the let _x case that reports E0700. Done means the original let _ case is rejected appropriately, with regression coverage added for the reproducer.