Incorrect diagnostic `error[E0309]: the parameter type `T` may not live long enough`, suggests duplicate bound

[kosayoda]

Code

use std::marker::PhantomData;

trait Unit<'t, T> {}
trait Trait {
    fn frob<'a, T>() -> impl Unit<'a, T>;
}

struct Wrapper<T>(PhantomData<T>);
impl<'a, T> Unit<'a, T> for Wrapper<T> where T: 'a {}

struct Foo;
impl Trait for Foo {
    fn frob<'a, T: 'a>() -> impl Unit<'a, T> {
        Wrapper(PhantomData)
    }
}

Current output

error[E0309]: the parameter type `T` may not live long enough
  --> src/lib.rs:13:29
   |
13 |     fn frob<'a, T: 'a>() -> impl Unit<'a, T> {
   |             --              ^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds...
   |             |
   |             the parameter type `T` must be valid for the lifetime `'a` as defined here...
   |
note: ...that is required by this bound
  --> src/lib.rs:13:20
   |
13 |     fn frob<'a, T: 'a>() -> impl Unit<'a, T> {
   |                    ^^
help: consider adding an explicit lifetime bound
   |
13 |     fn frob<'a, T: 'a + 'a>() -> impl Unit<'a, T> {
   |                       ++++

For more information about this error, try `rustc --explain E0309`.
error: could not compile `testing` (lib) due to 1 previous error

Additional Context

The program compiles fine if frob is a free function, or if frob is not a trait implementation.

trait Unit<'t, T> {}
trait Trait {
    fn frob<'a, T>() -> impl Unit<'a, T>;
}

struct Wrapper<T>(PhantomData<T>);
impl<'a, T> Unit<'a, T> for Wrapper<T> where T: 'a {}

// Not a trait impl
struct Foo;
impl Foo {
    fn frob<'a, T: 'a>() -> impl Unit<'a, T> {
        Wrapper(PhantomData)
    }
}

// Regular function
fn frob<'a, T: 'a>() -> impl Unit<'a, T> {
    Wrapper(PhantomData)
}

Rust Version

rustc 1.85.0-nightly (acabb5248 2024-12-04)
binary: rustc
commit-hash: acabb5248231987ae1f0c215208d1005a5db402d
commit-date: 2024-12-04
host: x86_64-unknown-linux-gnu
release: 1.85.0-nightly
LLVM version: 19.1.5

[QuineDot]

The actual error should be:

error[E0276]: impl has stricter requirements than trait
 --> src/lib.rs:5:nn
   |
5  |         fn frob<'a, T>() -> impl Unit<'a, T>;
   |         ---------------- definition of `frob` from trait
...
13 |     fn frob<'a, T: 'a>() -> impl Unit<'a, T> {
   |                    ^^ impl has extra requirement `T: 'a`

That is, the extra requirements should be rejected and not respected. If the compiler is to try to continue on, a more accurate additional error would be something like (2):

error[E0309]: the parameter type `T` may not live long enough
  --> src/lib.rs:13:29
   |
13 |     fn frob<'a, T: 'a>() -> impl Unit<'a, T> {
   |             --              ^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds...
   |             |
   |             the parameter type `T` must be valid for the lifetime `'a` as defined here...
   |
note: ...that is required by this bound
  --> src/lib.rs:9:nn
   |
 9 |     impl<'a, T> Unit<'a, T> for Wrapper<T> where T: 'a {}
   |                                                     ^^
help: consider adding an explicit lifetime bound to the trait
   |
 5 |     fn frob<'a, T: 'a>() -> impl Unit<'a, T>;
   |                 +++++

That is, the bound on the impl Unit for Wrapper implementation is the actual problematic origin of needing T: 'a on the implementation (but that requires the bound be on the trait as well).

---

For additional context, if you write the trait implementation with no T: 'a bounds, the compiler tells you to add the bound, which leads to the code in the OP:

impl Trait for Foo {
    fn frob<'a, T>() -> impl Unit<'a, T> {
        Wrapper(PhantomData)
    }
}

error[E0309]: the parameter type `T` may not live long enough
  --> src/lib.rs:15:9
   |
14 |     fn frob<'a, T>() -> impl Unit<'a, T> {
   |             -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
15 |         Wrapper(PhantomData)
   |         ^^^^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
   |
help: consider adding an explicit lifetime bound
   |
14 |     fn frob<'a, T: 'a>() -> impl Unit<'a, T> {
   |                  ++++

It should either tell you to add the bound to the trait as well (iff the trait is local) or not tell you to add the bound at all.

Also note that E0276 doesn't fire even when the opaque-ifiied type does not require the added lifetime bound, i.e. you get the same bad suggestion as the OP:

impl<T> Unit<'_, T> for () {}
impl Trait for Foo {
    fn frob<'a, T: 'a>() -> impl Unit<'a, T> {
    }
}

Same error as OP

error[E0309]: the parameter type `T` may not live long enough
  --> src/lib.rs:14:29
   |
14 |     fn frob<'a, T: 'a>() -> impl Unit<'a, T> {
   |             --              ^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds...
   |             |
   |             the parameter type `T` must be valid for the lifetime `'a` as defined here...
   |
note: ...that is required by this bound
  --> src/lib.rs:14:20
   |
14 |     fn frob<'a, T: 'a>() -> impl Unit<'a, T> {
   |                    ^^
help: consider adding an explicit lifetime bound
   |
14 |     fn frob<'a, T: 'a + 'a>() -> impl Unit<'a, T> {
   |                       ++++

So in summary, the opaque return type is somehow interfering with or superceding E0276, and I think that's at the core of the bad diagnostic.

Compare and contrast

Playground.

trait Trait {
    type Assoc<'a, T>: Unit<'a, T>;
    fn frob<'a, T>() -> Self::Assoc<'a, T>;
}

impl Trait for Foo {
    type Assoc<'a, T> = ();
    fn frob<'a, T: 'a>() -> Self::Assoc<'a, T> {
    }
}

error[E0276]: impl has stricter requirements than trait
  --> src/lib.rs:16:20
   |
6  |     fn frob<'a, T>() -> Self::Assoc<'a, T>;
   |     --------------------------------------- definition of `frob` from trait
...
16 |     fn frob<'a, T: 'a>() -> Self::Assoc<'a, T> {
   |                    ^^ impl has extra requirement `T: 'a`

[fmease]

Smaller:

trait Trait {
    fn f<'a, T>() -> impl Sized;
}

impl Trait for () {
    fn f<'a, T: 'a>() -> impl Sized {}
}