Error messages can be ambiguous between types and type parameters

[leo60228]

Someone I know was learning Rust as a beginner. They defined a function like this:

fn test<T>(t: T) -> i32 {
    5_i32 + <i32 as From<T>>::from(t)
}

This resulted in an error:

error[E0277]: the trait bound `i32: From<T>` is not satisfied
 --> src/lib.rs:2:13
  |
2 |     5_i32 + <i32 as From<T>>::from(t)
  |             ^^^^^^^^^^^^^^^^^^^^^^ the trait `From<T>` is not implemented for `i32`
  |
  = note: required by `from`

Based on this error, they attempted to add an i32: From<T> bound:

fn test<T, i32: From<T>>(t: T) -> i32 {
    5_i32 + <i32 as From<T>>::from(t)
}

This leads to a different, very misleading error:

error[E0277]: cannot add `i32` to `i32`
 --> src/lib.rs:2:11
  |
2 |     5_i32 + <i32 as From<T>>::from(t)
  |           ^ no implementation for `i32 + i32`
  |
  = help: the trait `Add<i32>` is not implemented for `i32`

#[warn(non_camel_case_types)] can give a hint, but I think that the error message should stand on its own. In addition, they appear to have added #![allow(non_camel_case_types)] for unrelated reasons.

Meta

rustc --version --verbose: (N/A, on playground)

[estebank]

For the benefit of anyone learning Rust that might encounter this ticket while trying to understand how to fix their code, what is needed is to constrain the type parameter with Into<i32> instead:

fn test<T: Into<i32>>(t: T) -> i32 {
    5_i32 + t.into()
}

[estebank]

There are two different problems that need to be handled here. The first error is slightly misleading and can only be solved by knowing about the From/Into dichotomy, but the later is problematic because a new type parameter is masking the i32 type. In type errors we clarify what is happening:

error[E0308]: mismatched types
 --> src/lib.rs:2:18
  |
1 | fn test<T, i32: From<T>>(t: T) -> i32 {
  |            --- this type parameter
2 |     let x: i32 = 0i32;
  |            ---   ^^^^ expected type parameter `i32`, found `i32`
  |            |
  |            expected due to this
  |
  = note: expected type parameter `i32` (type parameter `i32`)
                       found type `i32` (`i32`)

We should do the same for E0277.

[leo60228]

For what it's worth, I believe this error actually came from https://stackoverflow.com/questions/66082378/how-to-add-trait-bound-to-a-non-generic-type (which was linked on Reddit). I just assumed that they ran into the issue (it wasn't clear from context/phrasing). This isn't relevant to the issue itself, though.

[leo60228]

The first error is slightly misleading and can only be solved by knowing about the From/Into dichotomy

You could also write fn test<T>(t: T) -> i32 where i32: From<T>.

[leo60228]

You could also write fn test<T>(t: T) -> i32 where i32: From<T>.

After thinking about it, I feel like it's probably best for rustc to always suggest this form. It'd probably make sense to have a clippy lint suggesting rewriting this to the more idiomatic T: Into<i32>, however.

[leo60228]

There's a draft PR for that: rust-lang/rust-clippy#6620

[estebank]

@leo60228 one consideration is that clippy lints don't always necessarily trigger and having multiple errors can be confusing to people (not everyone reads everything before figuring out what the problem is). Because of that I would also like to extend the existing error to account for this case. :)

[estebank]

The first case is now handled, the second case of type params masking types is yet to be resolved. I think at least pointing out that that has happened on all E0277 by visiting every type involved in the obligation and seeing if there's any type parameter with the same name as another type in scope and emitting a note explaining that that's what's happening would improve the situation.

[estebank]

Current output for the first case:

error[E0277]: the trait bound `i32: From<T>` is not satisfied
 --> src/lib.rs:4:36
  |
4 |     5_i32 + <i32 as From<T>>::from(t)
  |             ---------------------- ^ the trait `From<T>` is not implemented for `i32`
  |             |
  |             required by a bound introduced by this call
  |
help: consider introducing a `where` clause, but there might be an alternative better way to express this requirement
  |
3 | fn test<T>(t: T) -> i32 where i32: From<T> {
  |                         ++++++++++++++++++

and for the second case

error[E0277]: cannot add `i32` to `i32`
 --> src/lib.rs:4:11
  |
4 |     5_i32 + <i32 as From<T>>::from(t)
  |           ^ no implementation for `i32 + i32`
  |
  = help: the trait `Add<i32>` is not implemented for `i32`
help: consider introducing a `where` clause, but there might be an alternative better way to express this requirement
  |
3 | fn test<T, i32: From<T>>(t: T) -> i32 where i32: Add<i32> {
  |                                       +++++++++++++++++++