Missing suggestion to dereference LHS of assignment when LHS is invalid

[compiler-errors]

Given the following code:

fn main() {
    let mut x: Vec<()> = vec![()];
    x.last_mut().unwrap() = ();
}

The current output is:

error[E0070]: invalid left-hand side of assignment
 --> src/main.rs:3:27
  |
3 |     x.last_mut().unwrap() = ();
  |     --------------------- ^
  |     |
  |     cannot assign to this expression

For more information about this error, try `rustc --explain E0070`.

Ideally the output should look like:

error[E0070]: invalid left-hand side of assignment
 --> src/main.rs:3:27
  |
3 |     x.last_mut().unwrap() = ();
  |     --------------------- ^
  |     |
  |     cannot assign to this expression

Note: consider dereferencing the left-hand side
3 |     *x.last_mut().unwrap() = ();
        +

For more information about this error, try `rustc --explain E0070`.

The root cause seems to be the coersion error being suppressed, since there is already logic that suggest dereferencing the LHS of an assignment operator. In fact, this diagnostic code path is being hit, but somewhere along the way the diagnostic is being canceled (hence the fact that we only see this "invalid left-hand side of assignment" error being emitted and not an error about not being able to relate &mut () and ().)

[ChayimFriedman2]

@rustbot claim

The culprit is here:

rust/compiler/rustc_typeck/src/check/demand.rs

Lines 251 to 255 in b117335

	if !lhs.is_syntactic_place_expr() {
	// We already emitted E0070 "invalid left-hand side of assignment", so we
	// silence this.
	err.delay_as_bug();
	}

I'm not quite sure how to solve this. After all, the comment is correct. Do we want to show both errors? Or just attach the help to the "invalid left-hand side of assignment" error?

[compiler-errors]

@ChayimFriedman2, amazing find!

If we remove that delay-as-bug, do we see a lot of unnecessary new errors being emitted in the ui tests?

On the other hand, it might be useful just to special case this logic and attach it to the "invalid left-hand side" error.

[ChayimFriedman2]

Here's what the compiler emits if I comment the above code out:

error[E0070]: invalid left-hand side of assignment
 --> t.rs:3:27
  |
3 |     x.last_mut().unwrap() = ();
  |     --------------------- ^
  |     |
  |     cannot assign to this expression

error[E0308]: mismatched types
 --> t.rs:3:29
  |
3 |     x.last_mut().unwrap() = ();
  |     ---------------------   ^^ expected `&mut ()`, found `()`
  |     |
  |     expected due to the type of this binding
  |
help: consider dereferencing here to assign to the mutable borrowed piece of memory
  |
3 |     *x.last_mut().unwrap() = ();
  |     +

error: aborting due to 2 previous errors

Some errors have detailed explanations: E0070, E0308.
For more information about an error, try `rustc --explain E0070`.

Not so bad, but maybe it can become more verbose in other cases and not emitting redundant errors is always better. I'll try to update the logic so it'll just append the help.

[estebank]

In the surrounding code to

rust/compiler/rustc_typeck/src/check/expr.rs

Line 1033 in a391d54

self.check_lhs_assignable(lhs, "E0070", *span);

you have access to the types and the expr, so you might be able to easily call the code that provides the suggestion in E0308 from there.

[ChayimFriedman2]

@estebank The problem is that this code is not self-contained; it's inside check_ref() that performs a bunch of other suggestions. I'm working on extracting it and improving it BTW because it has some other reported bugs (#93983, #46276) and I have to refactor it anyway.

[ChayimFriedman2]

@rustbot release-assignment

I don't have time for that now. If somebody wants to pick it and work on it, feel free.

[compiler-errors]

@rustbot claim