Improve wording of "cannot multiply" type error

[camelid]

For example, if you had this code:

fn foo(x: i32, y: f32) -> f32 {
    x * y
}

You would get this error:

error[E0277]: cannot multiply `f32` to `i32`
 --> src/lib.rs:2:7
  |
2 |     x * y
  |       ^ no implementation for `i32 * f32`
  |
  = help: the trait `Mul<f32>` is not implemented for `i32`

However, that's not usually how people describe multiplication. People
usually describe multiplication like how the division error words it:

error[E0277]: cannot divide `i32` by `f32`
 --> src/lib.rs:2:7
  |
2 |     x / y
  |       ^ no implementation for `i32 / f32`
  |
  = help: the trait `Div<f32>` is not implemented for `i32`

So that's what this change does. It changes this:

error[E0277]: cannot multiply `f32` to `i32`
 --> src/lib.rs:2:7
  |
2 |     x * y
  |       ^ no implementation for `i32 * f32`
  |
  = help: the trait `Mul<f32>` is not implemented for `i32`

To this:

error[E0277]: cannot multiply `i32` by `f32`
 --> src/lib.rs:2:7
  |
2 |     x * y
  |       ^ no implementation for `i32 * f32`
  |
  = help: the trait `Mul<f32>` is not implemented for `i32`

[rust-highfive]

r? @oli-obk

(rust_highfive has picked a reviewer for you, use r? to override)

[camelid]

For some reason it only seems to be working for some types – the old error persists for others, even though I can't find any other spot in the compiler that generates this error. Maybe my build cache is corrupted or something...

[jyn514]

Do you need this new test case? This is tested in plenty of other places.

[camelid]

I couldn't find a place where a simple case of the error was tested, and I wanted a sanity check since this is behaving weirdly. But if you think I should remove it once we figure out what's going awry, I guess I could. I just wanted extra coverage while I figured it out :)

[camelid]

I think I'm going to keep this test unless there are significant objections since this helped catch a spot that I didn't know to update.

[camelid]

@estebank What could explain this test failure from CI? I've been scratching my head and I also asked @jyn514 but neither of us could think of what this could be.

error: /checkout/src/test/ui/binop/binop-mul-i32-f32.rs:2: unexpected error: '2:7: 2:8: cannot multiply `f32` to `i32` [E0277]'

error: /checkout/src/test/ui/binop/binop-mul-i32-f32.rs:2: expected error not found: cannot multiply `i32` by `f32`

It seems the old error is being reported in some cases, and the new one in others.

[camelid]

I grepped through the whole compiler, but couldn't find anything even close to this error other than the spot I changed:

$ grep 'cannot multiply' -r compiler
compiler/rustc_typeck/src/check/op.rs:                                format!("cannot multiply `{}` by `{}`", lhs_ty, rhs_ty),

[SNCPlay42]

It's from the rustc_on_unimplemented attribute on the Mul trait itself:

rust/library/core/src/ops/arith.rs

Lines 304 to 309 in cbc42a0

	#[rustc_on_unimplemented(
	message = "cannot multiply `{Rhs}` to `{Self}`",
	label = "no implementation for `{Self} * {Rhs}`"
	)]
	#[doc(alias = "*")]
	pub trait Mul<Rhs = Self> {

[qigangxu]

I grepped through the whole compiler, but couldn't find anything even close to this error other than the spot I changed:

$ grep 'cannot multiply' -r compiler
compiler/rustc_typeck/src/check/op.rs:                                format!("cannot multiply `{}` by `{}`", lhs_ty, rhs_ty),

There are two lines of code similar in the library directory:

library/core/src/ops/arith.rs:305:    message = "cannot multiply `{Rhs}` to `{Self}`",
library/core/src/ops/arith.rs:829:    message = "cannot multiply-assign `{Rhs}` to `{Self}`",

[camelid]

Wow, thank you! I didn't think to look in library/.

[camelid]

Why would the error be produced in the compiler and the standard library?

[SNCPlay42]

rustc_on_unimplemented is for getting a nicer wording than "the trait std::ops::Mul<f32> is not implemented for i32" on trait errors in general, which might not directly involve actually using the operation, e.g.

use std::ops::Add;
fn incr<T:Add<i32>>(x: T) -> T::Output {
    x + 1 // this is fine
}

fn main() {
    incr(()); //~ ERROR cannot add `i32` to `()`
}

It's an attribute placeable on library traits rather than hardcoded into the compiler because it's used on all sorts of stdlib traits (not just the binops) that might not even be lang items, e.g. Display.

We get that kind of error in your test because the diagnostics in check_overloaded_binop only fire if the LHS type doesn't implement the relevant trait at all, and another code path handles other cases (see also #77304), and obviously i32 does implement Mul<T> for some values of T.

[estebank]

@bors r+

[bors]

📌 Commit 7b33ae6 has been approved by estebank