Unused warnings should trigger for swaps

[catamorphism]

From @jruderman 's comment on #1832:

IMO, the "unused" warning should be per-assignment, not per-variable.

fn main() {
   let mut x = 10;
   x = 20;
   log(error, x);
}

should warn because the first assignment to x is unused.

fn main() {
   let mut x = 10;
   log(error, x);
   x = 20;
}

should warn because the second assignment to x is unused. Finally, the original example,

fn main() {
   let mut x = 10, y = 20;
   x <-> y;
   log(error, y);
}

should warn because the second assignment to x is unused.

[eholk]

I don't think the third case should warn. We have a pattern cropping up that goes something like this:

let mut x = some(thing);
do some(foo).map |foo| {
    let mut y = none;
    x <-> y;
    let x = option::unwrap(y);
    // do stuff with x
}

This is basically the dance that's needed to get an uncopyable into a closure in a way that you can move it to other places.

[eholk]

Actually, I guess the problem is not whether the third example warns, but the fact that we have to do all that with it'd be nice to do stuff like...

let x = thing;
do some(foo).map |foo, move x| {
    // do stuff with x, including possibly giving up ownership.
}

[nikomatsakis]

The first and second example already issue warnings at the correct places.

[catamorphism]

Sounds like this is done, then.

[jruderman]

The warning wouldn't apply in eholk's case because the lhs of the swap is an upvar. I still think my third case should warn.

[nikomatsakis]

I am inclined to agree.

[alexcrichton]

Since the swap operator no longer exists, I think this can be closed (if I'm wrong, feel free to reopen!)