Error in trait solving

[b-naber]

Related to #78113. In the following example the trait system cannot resolve the trait object A in Box<dyn A + 'a> to Foo, even though Foo implements A:

#![feature(generic_associated_types)]

trait A {}

struct Foo {}

impl A for Foo {}

impl<'a> A for &'a Box<dyn A + 'a> {}

trait X {
  type T<'a> : A;
}

struct B {}

impl X for B {
  type T<'a> = &'a Box<dyn A + 'a>;
}

impl B {
  fn foo<'a>(&self, arg : &'a Box<Foo>) -> <Self as X>::T<'a> {
    arg
  }

}

fn main() {}

This yields the error:

error[E0308]: mismatched types
  --> /Users/bn/Documents/Rust/rust_error_samples/gat_type_alias_lifetime.rs:23:5
   |
23 |     arg
   |     ^^^ expected trait object `dyn A`, found struct `Foo`
   |
   = note: expected reference `&'a Box<(dyn A + 'a)>`
              found reference `&'a Box<Foo>`

error: aborting due to previous error; 1 warning emitted

If we don't provide a lifetime bound in the implementation of A for &'a Box<dyn A> (impl<'a> A for &'a Box<dyn A>) then we get an additional lifetime error since this trait impl is resolved to impl<'a> A for &'a Box<dyn A + 'static>, resulting in two errors:

error[E0308]: mismatched types
  --> /Users/bn/Documents/Rust/rust_error_samples/gat_type_alias_lifetime.rs:18:3
   |
18 |   type T<'a> = &'a Box<dyn A + 'a>;
   |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ lifetime mismatch
   |
   = note: expected trait `A`
              found trait `A`
note: the lifetime `'a` as defined on the associated item at 18:10...
  --> /Users/bn/Documents/Rust/rust_error_samples/gat_type_alias_lifetime.rs:18:10
   |
18 |   type T<'a> = &'a Box<dyn A + 'a>;
   |          ^^
   = note: ...does not necessarily outlive the static lifetime

error[E0308]: mismatched types
  --> /Users/bn/Documents/Rust/rust_error_samples/gat_type_alias_lifetime.rs:23:5
   |
23 |     arg
   |     ^^^ expected trait object `dyn A`, found struct `Foo`
   |
   = note: expected reference `&'a Box<(dyn A + 'a)>`
              found reference `&'a Box<Foo>`

error: aborting due to 2 previous errors; 1 warning emitted

[matthewjasper]

The error here is correct, there is no coercion from &'a Box<Foo> to &'a Box<(dyn A + 'a)> because there are two layers of indirection here. The diagnostic could probably be more helpful though.

[estebank]

Current output:

error[E0308]: mismatched types
  --> src/main.rs:21:5
   |
20 |   fn foo<'a>(&self, arg : &'a Box<Foo>) -> <Self as X>::T<'a> {
   |                                            ------------------ expected `&'a Box<(dyn A + 'a)>` because of return type
21 |     arg
   |     ^^^ expected `&Box<dyn A>`, found `&Box<Foo>`
   |
   = note: expected reference `&'a Box<(dyn A + 'a)>`
              found reference `&'a Box<Foo>`