mismatches types [E0308] doesn't offer enough information to fix the error

[gnzlbg]

I get an error message like this:

src/x86/bmi2/mod.rs:51:35: 51:36 error: mismatched types [E0308]
src/x86/bmi2/mod.rs:51         unsafe { intrinsics::bzhi(x, bit_position) }
                                                         ^
src/x86/bmi2/mod.rs:51:35: 51:36 help: run `rustc --explain E0308` to see a detailed explanation
src/x86/bmi2/mod.rs:51:35: 51:36 note: expected type `()`
src/x86/bmi2/mod.rs:51:35: 51:36 note:    found type `T`

This tells me "what the error is", but gives me too little context (or no context at all) to actually solve it: I have to go to the intrinsics module, find the bzhi function, read its signature, and in my case, I end up baffled because it actually takes a T (so the expected type () makes no sense).

I still haven't figured out what is going on, but it would be good if when rustc detects a type error when calling a function, it would not only tell me where the error is, which type i am passing, and what type is expected, but where exactly the function is and what's its complete signature so that if needed I know where to go to read up the comments. Probably the real error here is that I am calling a function with the same name but from a different module, so it might be even better if rustc would check all functions in all modules in scope for functions with the same name and the type signature I am passing it and make a suggestion like "did you meant to call the bzhi function from the bar module instead?".

In particular the next error is a type error on the second function argument, so it would be even better if rustc could collapse these two errors into one.

---

EDIT: An example of the error is given here:

https://play.rust-lang.org/?gist=841b50e5845c61f2a1ebfd141673c151&version=nightly&backtrace=0

where the following error message is not very helpful:

error[E0308]: mismatched types
  --> src/main.rs:21:14
   |
21 |     bar::bar(x.zero())
   |              ^^^^^^^^ expected (), found type parameter
   |
   = note: expected type `()`
              found type `T`
   = help: here are some functions which might fulfill your needs:
           - .zero()

In particular the expected (), found type parameter T is very misleading.

[gnzlbg]

This was the error (see the comment):

https://play.rust-lang.org/?gist=841b50e5845c61f2a1ebfd141673c151&version=nightly&backtrace=0

The error message is just completely help less.

[gmatht]

Errors from rustc are usually so helpful that I can learn rust without documentation, just by reading the error messages. The first thing that I couldn't learn from error messages was how to convert types. Even with something as simple as: let x : u32 = 0; let y : i32 = x, and after reading --explain E0308 it wasn't at all clear that I was meant to use as. Maybe the error could also suggest the conversion that we should use, similar to how it suggests adding .iter() to for [...] {...}?

[GuillaumeGomez]

I think this error has been fixed long ago and improved recently with the add of method suggestions. I'm closing it then.

[gnzlbg]

@GuillaumeGomez You are correct that right now there is a method suggestion, which is nice.

But the error right now is the same as the error back then: expected type (). This hasn't changed, and it's still useless.

So I don't think this has been fixed at all. And while it has improved a little bit, it is far from being a good error message.

---

Just check the playground link.

[GuillaumeGomez]

You didn't add the playground link. Reopening the issue.

[gnzlbg]

Sorry, the playground example was in the second comment on this issue. I've added it to the issue as well so that it cannot be missed.

[estebank]

The compiler now suggests adding a semicolon:

error[E0308]: mismatched types
  --> src/main.rs:23:5
   |
23 |     x.zero()
   |     ^^^^^^^^- help: did you mean to add a semicolon here?: `;`
   |     |
   |     expected (), found type parameter
   |
   = note: expected type `()`
              found type `T`

When following the suggestion, it (correctly) complains about visibility, after fixing that, it complains about using a moved value, adding a constraint on T: Copy, it compiles.

There're still 3 errors when only one is actually relevant.

---

The lack of Copy constraint should be clearer:

error[E0382]: use of moved value: `x`
  --> src/main.rs:25:3
   |
   | pub fn baz<T: Foo>(x: T) -> T {
   |            ------ help: consider adding a `Copy` constraint here: `T: Foo + Copy`
   |   if 0 == 1 {
21 |     bar::bar(x.zero())
   |              - value moved here
...
25 |   x.zero()
   |   ^ value used here after move
   |
   = note: move occurs because `x` has type `T`, which does not implement the `Copy` trait