error: the trait `Foo` is not implemented for the type `Box<Bar>`

[tomaka]

This code:

trait Foo {
    fn do_foo(&self);
}

trait Bar {
    fn do_bar(&self);
}

impl<T> Bar for T where T: Foo {
    fn do_bar(&self) {
        self.do_foo()
    }
}

struct Obj {
    obj: Box<Bar + 'static>
}

impl Obj {    
    fn process(&self) {
        self.obj.do_bar();
    }
}

(http://is.gd/hTCzJI)

Produces:

<anon>:21:9: 21:26 error: the trait `Foo` is not implemented for the type `Box<Bar>`
<anon>:21         self.obj.do_bar();

I think that this kind of code used to work in the past, so it could be a regression.
Even if this code is not supposed to work, the error message makes no sense.

[conradkleinespel]

Hey @tomaka, thanks for taking the time to report this :-) I'm not sure how Box works, but could this be related to #18040 ?

[tomaka]

The error message of #18040 is different from mine, and I'm confident that my code is actually supposed to work and not produce an error (contrary to #18040).

[conradkleinespel]

Same with #18040, which is about a change in rustc as of 0.13.0.

May I ask what version of rustc you're compiling your code with ? If you're unsure, you can get it via rustc -v, I think.

[tomaka]

I tried with today's nightly before reporting this. I've now installed an older nightly so I can't tell the exact version. This issue is already there in the 2014-10-16 and the 2014-10-10 nightlies, and the playpen.
Althought I'm not sure, I think that this code used to work with the 2014-10-06 nightlies.

What I mean by "I'm not sure" is that this issue is a simplification of a real code which used to work with 2014-10-06 (I'm sure about this), but no longer works with 2014-10-10, 2014-10-16, or 2014-10-19, and produces the same error message.

I suspect #17669 to be the cause.

[ftxqxd]

I think this might have been caused by #17464. The code can easily be fixed by explicitly dereferencing the trait object:

trait Foo {
    fn do_foo(&self);
}

trait Bar {
    fn do_bar(&self);
}

impl<T> Bar for T where T: Foo {
    fn do_bar(&self) {
        self.do_foo()
    }
}

struct Obj {
    obj: Box<Bar + 'static>
}

impl Obj {    
    fn process(&self) {
        (*self.obj).do_bar();
    }
}

[nrc]

cc @nikomatsakis sounds like a multi-dispatch regression

[nikomatsakis]

I agree with @P1start that this is likely caused by #17464. I don't think it's a multidispatch regression per se, though there is an interaction with the condtiional dispatch algorithm. In particular, the algorithm decides that it will use the trait method do_bar invoked on Box<Bar>, before it derefs to Bar and finds the object method. You might be surprised since you would expect that it would evaluate the T:Foo requirement before deciding on the impl, but in fact since there is only one potentially applicable impl, it forgoes evaluating the condition. This is an important part of the algorithm, since otherwise you wind up requiring a lot more type annotations to resolve methods.

My inclination is to close this as "working as expected".

[nikomatsakis]

Closing.