Prefer where clauses to impls in trait resolution (not vice versa).

[nikomatsakis]

Prefer where clauses to impls in trait resolution (not vice versa).

Fixes #18453.

r? @aturon

[nikomatsakis]

@aturon actually this patch is more specialization-friendly than before, but yes.

[adrientetar]

typo

[carllerche]

I tried out this patch, but it didn't seem to fix the following case. I am not 100% sure this is the same issue, if it is not, feel free to open a new ticket.

#![feature(unboxed_closures)]
#![feature(overloaded_calls)]

trait Callback<S, V> {
    fn invoke(self, s: S, v: V);
}

impl<S, V, F: FnOnce(V)> Callback<S, V> for F {
    fn invoke(self, _: S, v: V) {
        self.call_once((v,));
    }
}

impl<S, V> Callback<S, V> for fn(S, V) {
    fn invoke(self, s: S, v: V) {
        self(s, v);
    }
}

fn invoke<S, V, F: Callback<S, V>>(s: S, v: V, f: F) {
    f.invoke(s, v);
}

struct Foo {
    val: uint,
}

impl Foo {
    fn action(&self) {
        invoke(self, "zomg", move |:val| println!("val: {}", val));
        invoke(self, "hi2u", Foo::callback);
    }

    fn callback(&self, val: &'static str) {
        println!("self: {}; val={}", self.val, val);
    }
}

pub fn main() {
    let f = Foo { val: 123u };
    f.action();
}

output:

$ rustc callback.rs
callback.rs:31:9: 31:15 error: the trait `core::ops::FnOnce<(&str,), ()>` is not implemented for the type `fn(&Foo, &str)`
callback.rs:31         invoke(self, "hi2u", Foo::callback);
                       ^~~~~~
callback.rs:31:9: 31:15 note: the trait `core::ops::FnOnce` must be implemented because it is required by `invoke`
callback.rs:31         invoke(self, "hi2u", Foo::callback);
                       ^~~~~~
error: aborting due to previous error

[nikomatsakis]

@carllerche I think that will be fixed by PR #18388 -- which failed to land for some reason I have yet to investigate.