diff options
Diffstat (limited to 'src/test/ui/binop/binop-consume-args.stderr')
| -rw-r--r-- | src/test/ui/binop/binop-consume-args.stderr | 363 |
1 files changed, 363 insertions, 0 deletions
diff --git a/src/test/ui/binop/binop-consume-args.stderr b/src/test/ui/binop/binop-consume-args.stderr new file mode 100644 index 000000000..c734f8c1e --- /dev/null +++ b/src/test/ui/binop/binop-consume-args.stderr @@ -0,0 +1,363 @@ +error[E0382]: use of moved value: `lhs` + --> $DIR/binop-consume-args.rs:7:10 + | +LL | fn add<A: Add<B, Output=()>, B>(lhs: A, rhs: B) { + | --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait +LL | lhs + rhs; + | --------- `lhs` moved due to usage in operator +LL | drop(lhs); + | ^^^ value used here after move + | +note: calling this operator moves the left-hand side + --> $SRC_DIR/core/src/ops/arith.rs:LL:COL + | +LL | fn add(self, rhs: Rhs) -> Self::Output; + | ^^^^ +help: consider further restricting this bound + | +LL | fn add<A: Add<B, Output=()> + Copy, B>(lhs: A, rhs: B) { + | ++++++ + +error[E0382]: use of moved value: `rhs` + --> $DIR/binop-consume-args.rs:8:10 + | +LL | fn add<A: Add<B, Output=()>, B>(lhs: A, rhs: B) { + | --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait +LL | lhs + rhs; + | --- value moved here +LL | drop(lhs); +LL | drop(rhs); + | ^^^ value used here after move + | +help: consider restricting type parameter `B` + | +LL | fn add<A: Add<B, Output=()>, B: Copy>(lhs: A, rhs: B) { + | ++++++ + +error[E0382]: use of moved value: `lhs` + --> $DIR/binop-consume-args.rs:13:10 + | +LL | fn sub<A: Sub<B, Output=()>, B>(lhs: A, rhs: B) { + | --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait +LL | lhs - rhs; + | --------- `lhs` moved due to usage in operator +LL | drop(lhs); + | ^^^ value used here after move + | +note: calling this operator moves the left-hand side + --> $SRC_DIR/core/src/ops/arith.rs:LL:COL + | +LL | fn sub(self, rhs: Rhs) -> Self::Output; + | ^^^^ +help: consider further restricting this bound + | +LL | fn sub<A: Sub<B, Output=()> + Copy, B>(lhs: A, rhs: B) { + | ++++++ + +error[E0382]: use of moved value: `rhs` + --> $DIR/binop-consume-args.rs:14:10 + | +LL | fn sub<A: Sub<B, Output=()>, B>(lhs: A, rhs: B) { + | --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait +LL | lhs - rhs; + | --- value moved here +LL | drop(lhs); +LL | drop(rhs); + | ^^^ value used here after move + | +help: consider restricting type parameter `B` + | +LL | fn sub<A: Sub<B, Output=()>, B: Copy>(lhs: A, rhs: B) { + | ++++++ + +error[E0382]: use of moved value: `lhs` + --> $DIR/binop-consume-args.rs:19:10 + | +LL | fn mul<A: Mul<B, Output=()>, B>(lhs: A, rhs: B) { + | --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait +LL | lhs * rhs; + | --------- `lhs` moved due to usage in operator +LL | drop(lhs); + | ^^^ value used here after move + | +note: calling this operator moves the left-hand side + --> $SRC_DIR/core/src/ops/arith.rs:LL:COL + | +LL | fn mul(self, rhs: Rhs) -> Self::Output; + | ^^^^ +help: consider further restricting this bound + | +LL | fn mul<A: Mul<B, Output=()> + Copy, B>(lhs: A, rhs: B) { + | ++++++ + +error[E0382]: use of moved value: `rhs` + --> $DIR/binop-consume-args.rs:20:10 + | +LL | fn mul<A: Mul<B, Output=()>, B>(lhs: A, rhs: B) { + | --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait +LL | lhs * rhs; + | --- value moved here +LL | drop(lhs); +LL | drop(rhs); + | ^^^ value used here after move + | +help: consider restricting type parameter `B` + | +LL | fn mul<A: Mul<B, Output=()>, B: Copy>(lhs: A, rhs: B) { + | ++++++ + +error[E0382]: use of moved value: `lhs` + --> $DIR/binop-consume-args.rs:25:10 + | +LL | fn div<A: Div<B, Output=()>, B>(lhs: A, rhs: B) { + | --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait +LL | lhs / rhs; + | --------- `lhs` moved due to usage in operator +LL | drop(lhs); + | ^^^ value used here after move + | +note: calling this operator moves the left-hand side + --> $SRC_DIR/core/src/ops/arith.rs:LL:COL + | +LL | fn div(self, rhs: Rhs) -> Self::Output; + | ^^^^ +help: consider further restricting this bound + | +LL | fn div<A: Div<B, Output=()> + Copy, B>(lhs: A, rhs: B) { + | ++++++ + +error[E0382]: use of moved value: `rhs` + --> $DIR/binop-consume-args.rs:26:10 + | +LL | fn div<A: Div<B, Output=()>, B>(lhs: A, rhs: B) { + | --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait +LL | lhs / rhs; + | --- value moved here +LL | drop(lhs); +LL | drop(rhs); + | ^^^ value used here after move + | +help: consider restricting type parameter `B` + | +LL | fn div<A: Div<B, Output=()>, B: Copy>(lhs: A, rhs: B) { + | ++++++ + +error[E0382]: use of moved value: `lhs` + --> $DIR/binop-consume-args.rs:31:10 + | +LL | fn rem<A: Rem<B, Output=()>, B>(lhs: A, rhs: B) { + | --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait +LL | lhs % rhs; + | --------- `lhs` moved due to usage in operator +LL | drop(lhs); + | ^^^ value used here after move + | +note: calling this operator moves the left-hand side + --> $SRC_DIR/core/src/ops/arith.rs:LL:COL + | +LL | fn rem(self, rhs: Rhs) -> Self::Output; + | ^^^^ +help: consider further restricting this bound + | +LL | fn rem<A: Rem<B, Output=()> + Copy, B>(lhs: A, rhs: B) { + | ++++++ + +error[E0382]: use of moved value: `rhs` + --> $DIR/binop-consume-args.rs:32:10 + | +LL | fn rem<A: Rem<B, Output=()>, B>(lhs: A, rhs: B) { + | --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait +LL | lhs % rhs; + | --- value moved here +LL | drop(lhs); +LL | drop(rhs); + | ^^^ value used here after move + | +help: consider restricting type parameter `B` + | +LL | fn rem<A: Rem<B, Output=()>, B: Copy>(lhs: A, rhs: B) { + | ++++++ + +error[E0382]: use of moved value: `lhs` + --> $DIR/binop-consume-args.rs:37:10 + | +LL | fn bitand<A: BitAnd<B, Output=()>, B>(lhs: A, rhs: B) { + | --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait +LL | lhs & rhs; + | --------- `lhs` moved due to usage in operator +LL | drop(lhs); + | ^^^ value used here after move + | +note: calling this operator moves the left-hand side + --> $SRC_DIR/core/src/ops/bit.rs:LL:COL + | +LL | fn bitand(self, rhs: Rhs) -> Self::Output; + | ^^^^ +help: consider further restricting this bound + | +LL | fn bitand<A: BitAnd<B, Output=()> + Copy, B>(lhs: A, rhs: B) { + | ++++++ + +error[E0382]: use of moved value: `rhs` + --> $DIR/binop-consume-args.rs:38:10 + | +LL | fn bitand<A: BitAnd<B, Output=()>, B>(lhs: A, rhs: B) { + | --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait +LL | lhs & rhs; + | --- value moved here +LL | drop(lhs); +LL | drop(rhs); + | ^^^ value used here after move + | +help: consider restricting type parameter `B` + | +LL | fn bitand<A: BitAnd<B, Output=()>, B: Copy>(lhs: A, rhs: B) { + | ++++++ + +error[E0382]: use of moved value: `lhs` + --> $DIR/binop-consume-args.rs:43:10 + | +LL | fn bitor<A: BitOr<B, Output=()>, B>(lhs: A, rhs: B) { + | --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait +LL | lhs | rhs; + | --------- `lhs` moved due to usage in operator +LL | drop(lhs); + | ^^^ value used here after move + | +note: calling this operator moves the left-hand side + --> $SRC_DIR/core/src/ops/bit.rs:LL:COL + | +LL | fn bitor(self, rhs: Rhs) -> Self::Output; + | ^^^^ +help: consider further restricting this bound + | +LL | fn bitor<A: BitOr<B, Output=()> + Copy, B>(lhs: A, rhs: B) { + | ++++++ + +error[E0382]: use of moved value: `rhs` + --> $DIR/binop-consume-args.rs:44:10 + | +LL | fn bitor<A: BitOr<B, Output=()>, B>(lhs: A, rhs: B) { + | --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait +LL | lhs | rhs; + | --- value moved here +LL | drop(lhs); +LL | drop(rhs); + | ^^^ value used here after move + | +help: consider restricting type parameter `B` + | +LL | fn bitor<A: BitOr<B, Output=()>, B: Copy>(lhs: A, rhs: B) { + | ++++++ + +error[E0382]: use of moved value: `lhs` + --> $DIR/binop-consume-args.rs:49:10 + | +LL | fn bitxor<A: BitXor<B, Output=()>, B>(lhs: A, rhs: B) { + | --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait +LL | lhs ^ rhs; + | --------- `lhs` moved due to usage in operator +LL | drop(lhs); + | ^^^ value used here after move + | +note: calling this operator moves the left-hand side + --> $SRC_DIR/core/src/ops/bit.rs:LL:COL + | +LL | fn bitxor(self, rhs: Rhs) -> Self::Output; + | ^^^^ +help: consider further restricting this bound + | +LL | fn bitxor<A: BitXor<B, Output=()> + Copy, B>(lhs: A, rhs: B) { + | ++++++ + +error[E0382]: use of moved value: `rhs` + --> $DIR/binop-consume-args.rs:50:10 + | +LL | fn bitxor<A: BitXor<B, Output=()>, B>(lhs: A, rhs: B) { + | --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait +LL | lhs ^ rhs; + | --- value moved here +LL | drop(lhs); +LL | drop(rhs); + | ^^^ value used here after move + | +help: consider restricting type parameter `B` + | +LL | fn bitxor<A: BitXor<B, Output=()>, B: Copy>(lhs: A, rhs: B) { + | ++++++ + +error[E0382]: use of moved value: `lhs` + --> $DIR/binop-consume-args.rs:55:10 + | +LL | fn shl<A: Shl<B, Output=()>, B>(lhs: A, rhs: B) { + | --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait +LL | lhs << rhs; + | ---------- `lhs` moved due to usage in operator +LL | drop(lhs); + | ^^^ value used here after move + | +note: calling this operator moves the left-hand side + --> $SRC_DIR/core/src/ops/bit.rs:LL:COL + | +LL | fn shl(self, rhs: Rhs) -> Self::Output; + | ^^^^ +help: consider further restricting this bound + | +LL | fn shl<A: Shl<B, Output=()> + Copy, B>(lhs: A, rhs: B) { + | ++++++ + +error[E0382]: use of moved value: `rhs` + --> $DIR/binop-consume-args.rs:56:10 + | +LL | fn shl<A: Shl<B, Output=()>, B>(lhs: A, rhs: B) { + | --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait +LL | lhs << rhs; + | --- value moved here +LL | drop(lhs); +LL | drop(rhs); + | ^^^ value used here after move + | +help: consider restricting type parameter `B` + | +LL | fn shl<A: Shl<B, Output=()>, B: Copy>(lhs: A, rhs: B) { + | ++++++ + +error[E0382]: use of moved value: `lhs` + --> $DIR/binop-consume-args.rs:61:10 + | +LL | fn shr<A: Shr<B, Output=()>, B>(lhs: A, rhs: B) { + | --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait +LL | lhs >> rhs; + | ---------- `lhs` moved due to usage in operator +LL | drop(lhs); + | ^^^ value used here after move + | +note: calling this operator moves the left-hand side + --> $SRC_DIR/core/src/ops/bit.rs:LL:COL + | +LL | fn shr(self, rhs: Rhs) -> Self::Output; + | ^^^^ +help: consider further restricting this bound + | +LL | fn shr<A: Shr<B, Output=()> + Copy, B>(lhs: A, rhs: B) { + | ++++++ + +error[E0382]: use of moved value: `rhs` + --> $DIR/binop-consume-args.rs:62:10 + | +LL | fn shr<A: Shr<B, Output=()>, B>(lhs: A, rhs: B) { + | --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait +LL | lhs >> rhs; + | --- value moved here +LL | drop(lhs); +LL | drop(rhs); + | ^^^ value used here after move + | +help: consider restricting type parameter `B` + | +LL | fn shr<A: Shr<B, Output=()>, B: Copy>(lhs: A, rhs: B) { + | ++++++ + +error: aborting due to 20 previous errors + +For more information about this error, try `rustc --explain E0382`. |