Kind checker is not aware of bounds on overloaded operators

[eholk]

This leads to us copying things we shouldn't when the impl has a copy bound.

[eholk]

The problem seems to be here (in kind.rs):

fn check_copy_ex(cx: ctx, ex: @expr, implicit_copy: bool) {
    if ty::expr_is_lval(cx.method_map, ex) &&
       !cx.last_use_map.contains_key(ex.id) &&
       !is_nullary_variant(cx, ex) {
        let ty = ty::expr_ty(cx.tcx, ex);
        check_copy(cx, ex.id, ty, ex.span, implicit_copy);
    }
}

In the test case for #2548, the self argument is in last-use position, so this code doesn't count it as a copy. In cases of overloaded operators that require a copy bound, I'm not sure the last-use optimization is legal.

[catamorphism]

Reproduced again. I'll work on it.

[nikomatsakis]

Here is the general sketch of a test case for this:

fn foo<T: copy>(+t: T) { ... }

fn bar<T>(+t: T) { ... }


fn main() {
   let v = something_noncopyable();
   foo::<SomethingNoncopyable>(move v); // BAD

   let w = something_noncopyable();
   bar(move w); // OK

   a + b
}

However, you have to rewrite it to use (1) overloaded operators, not function calls and (2) actual types :)