Add warning about side-effect free expression-statement

[LukasKalbertodt]

A programming beginner could write something like

let x = 0;
x + 1;
println!("{}", x);

I would expect to see a warning about this side effect free expression statement in line 2. However, I can imagine that it could be quite hard to determine if such an expression is side effect free. After all, operators for non-standard types could have side effects, too.

Now I don't think some crazy analysis about side-effect-behavior of an expression is useful in this situation. I just thought that some very basic and specialized lints (just for primitive types for example) could be very helpful -- especially for beginners.

[huonw]

We already have a very simple version of this,

fn main() {
    let x = 1;
    x;
}

<anon>:3:5: 3:7 warning: path statement with no effect, #[warn(path_statements)] on by default
<anon>:3     x;
             ^~

And it doesn't seem that crazy to expand the analysis to include more general effect-less things.

This could be driven by annotations on functions, indicating that they're only interesting for their result, no side-effects, and this could easily end up being similar to #[must_use] rust-lang/rfcs#886.

[sanxiyn]

Clippy includes no_effect lint which warns on x + 1; already. Maybe it should move to rustc and replace path_statements lint.

[LukasKalbertodt]

Fixed in #50149

This code:

let x = 0;
x + 1;
println!("{}", x);

Now (1.27) produces:

warning: unused arithmetic operation which must be used
 --> src/main.rs:3:5
  |
3 |     x + 1;
  |     ^^^^^
  |
  = note: #[warn(unused_must_use)] on by default