Mutable reference not re-borrowed by binary operator

[Stebalien]

When implementing a binary operator on &mut Something, the binary operator consumes the mutable reference instead of borrowing it:

use std::ops::Shl;

struct Test;

impl<'a> Shl<()> for &'a mut Test {
    type Output = ();
    fn shl(self, rhs: ()) {}
}

// Compiles
fn test_direct() {
    let mut test = Test;
    let test_ref = &mut test;
    test_ref.shl(());
    test_ref.shl(());
}

// Doesn't compile
//
// ```
// error: use of moved value: `test_ref`
// test_ref << ();
// ^~~~~~~~
// note: `test_ref` moved here because it has type `&mut Test`, which is non-copyable
// test_ref << ();
// ```
fn test_shift() {
    let mut test = Test;
    let test_ref = &mut test;
    test_ref << (); // Should be equivalent to test_ref.shl(())
    test_ref << ();
}

fn main() {}

[Gankra]

Is this not intended behaviour? Nothing in the code suggests the &mut should have anything done to it but moved, and &mut's not Copy.

[Gankra]

Oh sorry, I misread. Now I'm confused why the first one does compile.

[Stebalien]

If it didn't compile, nothing in rust would work:

fn push_two_zeros(v: &mut Vec<usize>) {
   v.push(0);
   v.push(0);
}

[eddyb]

@gankro reborrows are automatically inserted in most places, which is why &mut T appears to be copyable to a certain extent.

[pnkfelix]

Cc me

[steveklabnik]

Triage: no change

[steveklabnik]

Triage: still no change

[Patrick-Poitras]

Still not working. Link to playground: https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=a057796d9baed16f4cf6531485134d88