Providing a trait object as a type parameter to a function causes nonsense error

[sgrif]

I had mistakenly written this code in crates.io: conn.transaction::<_, CargoError, _>(...) (note: CargoError is a trait). I should have written Box<CargoError>. That resulted in this compiler error, which makes absolutely no sense:

error: the `transaction` method cannot be invoked on a trait object
   --> src/user/mod.rs:546:10
    |
546 |     conn.transaction::<_, CargoError, _>(|| {
    |          ^^^^^^^^^^^
    |
    = note: another candidate was found in the following trait, perhaps add a `use` for it:
            candidate #1: `use diesel::Connection;`

I am not invoking the method on a trait object, nor would use have any effect as the Connection trait is already in scope. For reference, the signature of the method being called is:

fn transaction<T, E, F>(&self, f: F) -> Result<T, E>
where
    F: FnOnce() -> Result<T, E>,
    E: From<Error>,

[comex]

I ran into this too. For the record, it only applies to method calls using dot syntax, not all function calls.

Reproducer: https://play.rust-lang.org/?gist=8460beff8fd0243103d587ebb15006dd&version=nightly

[dtolnay]

We hit this in #rust today with @Yatekii. Retagging as a bug. What makes this confusing is that the following two situations show exactly the same error message even though the nature of the problem is different. The first situation is more common so people recognize the error message as pertaining to that, and don't think to look for the second situation in their code.

trait Trait {
    fn f<T>(&self) where Self: Sized {}
}

struct Param;

fn f(receiver: &dyn Trait) {
    receiver.f::<Param>();
}

fn main() {}

trait Trait {}

struct Receiver;
impl Receiver {
    fn f<T>(&self) {}
}

fn main() {
    let receiver = Receiver;
    type Param = dyn Trait;
    receiver.f::<Param>();
}

error: the `f` method cannot be invoked on a trait object
  --> src/main.rs:11:14
   |
11 |     receiver.f::<Param>();
   |              ^

[estebank]

Would the following output be enough to help in these cases?

error: the `bar` method cannot be invoked on a trait object
  --> file.rs:10:9
   |
5  |     fn bar<T>(&self) {}
   |            - this has a `Sized` requirement
...
10 |     foo.bar::<Trait>(&foo);
   |         ^^^

error: the `f` method cannot be invoked on a trait object
 --> file.rs:8:14
  |
2 |     fn f<T>(&self) where Self: Sized {}
  |                                ----- this has a `Sized` requirement
...
8 |     receiver.f::<Param>();
  |              ^