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. :)