Unrecognized associated type bound on another associated type

[kvark]

trait Bar<T> { fn dummy(&self); }
trait Car<T> { fn dummy(&self); }

trait Foo {
    type A;
    type B: Bar<Self::A>;
    type C: Car<Self::A>;

    fn get_b(&self) -> &Self::B;
}

fn test_bar<A, B: Bar<A>>(_: &B) {}

fn test<A, F: Foo<A=A>>(f: &F) {
    test_bar(f.get_b());
}

Gives me:

<anon>:15:16: 15:23 error: the trait `Bar<A>` is not implemented for the type `<F as Foo>::B` [E0277]
<anon>:15     test_bar(f.get_b());
                         ^~~~~~~
<anon>:15:16: 15:23 error: the trait `Car<A>` is not implemented for the type `<F as Foo>::C` [E0277]
<anon>:15     test_bar(f.get_b());
                         ^~~~~~~
error: aborting due to 2 previous errors
playpen: application terminated with error code 101

There is a workaround:

fn test<A, B: Bar<A>, C: Car<A>, F: Foo<A=A, B=B, C=C>>(f: &F) {
    test_bar(f.get_b());
}

But it's ugly and should not be necessary.

We hit this problem a lot with gfx::Device, and I'd like to see cleaner use of it without explicit CommandBuffer bounds that we use as a workaround.

[apasel422]

This may be related to #23481.

[Mark-Simulacrum]

Edited original post to remove PhantomFn bounds, they're no longer needed. Issue still reproduces:

error[E0277]: the trait bound `<F as Foo>::B: Bar<A>` is not satisfied
  --> test.rs:14:1
   |
14 | / fn test<A, F: Foo<A=A>>(f: &F) {
15 | |     test_bar(f.get_b());
16 | | }
   | |_^ the trait `Bar<A>` is not implemented for `<F as Foo>::B`
   |
   = help: consider adding a `where <F as Foo>::B: Bar<A>` bound
   = note: required by `Foo`

error[E0277]: the trait bound `<F as Foo>::C: Car<A>` is not satisfied
  --> test.rs:14:1
   |
14 | / fn test<A, F: Foo<A=A>>(f: &F) {
15 | |     test_bar(f.get_b());
16 | | }
   | |_^ the trait `Car<A>` is not implemented for `<F as Foo>::C`
   |
   = help: consider adding a `where <F as Foo>::C: Car<A>` bound
   = note: required by `Foo`

error: aborting due to 2 previous errors

[rkarp]

A lot of related issues for this have been opened over time.

Duplicates: #37808, #39532, #40093, #48674, #54375, #54844

Probably same underlying cause: #32722, #37883, #38917, #43475, #47897, #54149

There's also a related discussion on the Rust forums: https://users.rust-lang.org/t/bounds-on-associated-types-enforced-too-soon/12948

[nikomatsakis]

Mildly simplified:

trait Bar<T> { fn dummy(&self); }

trait Foo {
    type A;
    type B: Bar<Self::A>;

    fn get_b(&self) -> &Self::B;
}

fn test_bar<A, B: Bar<A>>(_: &B) {}

fn test<A, F: Foo<A=A>>(f: &F) {
    test_bar(f.get_b());
}

fn main() { }

So, probably the fix is "just" that we need to do some normalization somewhere or other. My preference is to fix this by moving over to lazy normalization and chalk, which will do away with these sorts of shortcomings for good. But it's probably worth looking to see if this can be fixed a touch more rapidly by adding a normalization in the right place. I'll try to do that in a bit and mentor/open a fix if it seems reasonable.