Type checker is not aware that `impl Trait for T` implies that `T:Trait`

[pkgw]

At least, that's my naive take on what's going on. This example doesn't compile for me, while it seems to me like it should:

pub trait Super { }

pub trait Main {
    fn callreflect<T: Reflector> (&self, v: T);
}

pub trait Reflector {
    fn reflect<T: Main> (&self, h: &T);
}

impl<S: Super> Main for S {
    fn callreflect<T: Reflector> (&self, v: T) {
        v.reflect (self);
    }
}

I get:

testcase.rs:13:8: 13:25 error: failed to find an implementation of trait Main for S
testcase.rs:13         v.reflect (self);

Seeing as this error is in fact triggered inside the implementation of Main, it seems bogus to me. Or am I missing something?

[Kimundi]

Well, you have to implement Reflector too.

[pkgw]

To actually run the code in practice you'd need something that implements Reflector, but this example should be able to compile on its own, I think. Adding a basic implementation of Reflector for int doesn't change the error message.

[Kimundi]

Ah sorry, confused your Main with the main function. Hm, your code ought to work in theory, but afaik there are bugs in generic impls with trait bounds.

[nikomatsakis]

the problem here has nothing to do with mutally referential traits, but rather that the type checker does not consider S to implement Main because the bounds of S are Super, not Super+Main. You expect this to work, I imagine, because you are in the process of implementing Main for S, but the type checker doesn't take this into account currently. I guess it could, haven't thought about it very hard. Updated issue title.

[huonw]

IIRC, @msullivan has been working in this area.

[pkgw]

Yep, 906264b just fixed this.

[nikomatsakis]

Interesting. I reviewed that change but didn't realize that supporting this use case would be a consequence of that, but I guess it makes sense when I think about it a bit more.