lint for unused lvalue statement

[huonw]

fn main() {
    let p = box 1i;

    let _ = p; // doesn't move
    p; // does move


    p; // error: use of moved value
}

<anon>:8:5: 8:6 error: use of moved value: `p`
<anon>:8     p;
             ^
<anon>:5:5: 5:6 note: `p` moved here because it has type `&mut int`, which is non-copyable (perhaps you meant to use clone()?)
<anon>:5     p; // does move
             ^

(Adapted from this question, using Box to avoid possible confusion from reborrowing of &mut.)

It seems strange that an unassigned useless path differs to a useless path assigned to _.

cc @nikomatsakis

[steveklabnik]

This is still true (and I agree, odd) today.

[steveklabnik]

Updated code:

#![feature(box_syntax)]

fn main() {
    let p = box 1;

    let _ = p; // doesn't move
    p; // does move


    p; // error: use of moved value
}

Still agree that this is pretty strange.

[nikomatsakis]

I guess this is odd. Seems like something we could address in MIR land.

[nikomatsakis]

I wonder though -- it'd be a breaking change, e.g. if p had a destructor.

[arielb1]

Of course, the root cause here is that StmtSemi evaluates its expression to an rvalue and then drops it immediately, while match evaluates its expression to some odd mix of lvalue and rvalue.

Having StmtSemi evaluate its expression to an lvalue would e.g. mean that

    ptr::read(some_raw_ptr);

drops its argument at the end of the block rather than immediately, which would be a nontrivial breaking change.

[pnkfelix]

cc me

[Mark-Simulacrum]

Based on discussion above, this is a breaking change, so should be tagged with rust-2-breakage-wishlist, correct?

[nikomatsakis]

Personally I'm inclined to leave it as is and not change it.

[Mark-Simulacrum]

Nominating for lang team discussion -- I believe we should leave this as is and close.

[joshtriplett]

I think it'd be worth adding a lint for this specific case. If you have an expression statement that's a simple path, you can either eliminate it or replace it with a call to drop, depending on what you want.

[nikomatsakis]

General consensus:

• we will not change the dynamic semantics here.
• seems like a very easy thing to lint for and to suggest invoking mem::drop, as @joshtriplett said.

Specifically:

For an lvalue expression used in statement position, lint.