Detect call to `_::foo(&mut self)` confused with `_::foo(&self) -> Self`

[estebank]

Code

fn main() {
    let mut values = vec![3, 1, 2];
    let sorted = values.sort();
    println!("{}", sorted[0]);
    //~^ ERROR cannot index into a value of type `()`
}

Current output

error[E0608]: cannot index into a value of type `()`
 --> src/main.rs:4:26
  |
4 |     println!("{}", sorted[0]);
  |                          ^^^
  |
  = help: tuples are indexed with a dot and a literal index: `tuple.0`, `tuple.1`, etc.

Desired output

error[E0608]: cannot index into a value of type `()`
 --> src/main.rs:4:26
  |
2 |     let mut values = vec![3, 1, 2];
3 |     let sorted = values.sort();
  |                         ------ this method call modifies `values` in-place
4 |     println!("{}", sorted[0]);
  |                          ^^^
  |
note: `Vec::sort` takes `&mut Self` and returns `()`
   |
LL | ...
   |
help: you might have meant to use `values` after calling `sort`
  |
3 -     let sorted = values.sort();
4 -     println!("{}", sorted[0]);
3 +     values.sort();
4 +     println!("{}", values);
  |

Rationale and extra context

At the very least we should be pointing at the place where a binding was turned into ().

Other cases

We need to account for this in assignments, binops, unops, method calls and returns.

Rust Version

1.97

Anything else?

No response

[EvoPot]

Question about the suggestion for the unit type, an empty tuple, isn't it kinda strange that the compiler is suggesting to access elements of the unit type? I am talking about this diagnostic right here :

error[E0608]: cannot index into a value of type `()`
 --> src/main.rs:4:26
  |
4 |     println!("{}", sorted[0]);
  |                          ^^^
  |
  = help: tuples are indexed with a dot and a literal index: `tuple.0`, `tuple.1`, etc.

Tuples indeed are indexed like that, but the unit type is not meant to be used as a value for the data it stores. Is it not strange that the compiler is making a suggestion on how to use tuples better when we are working with something representing a different meaning than a regular tuple a user would write like (u32,u32)?