src/test/ui/binop/binop-consume-args.stderr

   1 error[E0382]: use of moved value: `lhs`
   2   --> $DIR/binop-consume-args.rs:7:10
   3    |
   4 LL | fn add<A: Add<B, Output=()>, B>(lhs: A, rhs: B) {
   5    |        --                       --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
   6    |        |
   7    |        help: consider adding a `Copy` constraint to this type argument: `A: Copy +`
   8 LL |     lhs + rhs;
   9    |     --- value moved here
  10 LL |     drop(lhs);
  11    |          ^^^ value used here after move
  12
  13 error[E0382]: use of moved value: `rhs`
  14   --> $DIR/binop-consume-args.rs:8:10
  15    |
  16 LL | fn add<A: Add<B, Output=()>, B>(lhs: A, rhs: B) {
  17    |                              -          --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
  18    |                              |
  19    |                              help: consider adding a `Copy` constraint to this type argument: `B: Copy`
  20 LL |     lhs + rhs;
  21    |           --- value moved here
  22 LL |     drop(lhs);
  23 LL |     drop(rhs);
  24    |          ^^^ value used here after move
  25
  26 error[E0382]: use of moved value: `lhs`
  27   --> $DIR/binop-consume-args.rs:13:10
  28    |
  29 LL | fn sub<A: Sub<B, Output=()>, B>(lhs: A, rhs: B) {
  30    |        --                       --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
  31    |        |
  32    |        help: consider adding a `Copy` constraint to this type argument: `A: Copy +`
  33 LL |     lhs - rhs;
  34    |     --- value moved here
  35 LL |     drop(lhs);
  36    |          ^^^ value used here after move
  37
  38 error[E0382]: use of moved value: `rhs`
  39   --> $DIR/binop-consume-args.rs:14:10
  40    |
  41 LL | fn sub<A: Sub<B, Output=()>, B>(lhs: A, rhs: B) {
  42    |                              -          --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
  43    |                              |
  44    |                              help: consider adding a `Copy` constraint to this type argument: `B: Copy`
  45 LL |     lhs - rhs;
  46    |           --- value moved here
  47 LL |     drop(lhs);
  48 LL |     drop(rhs);
  49    |          ^^^ value used here after move
  50
  51 error[E0382]: use of moved value: `lhs`
  52   --> $DIR/binop-consume-args.rs:19:10
  53    |
  54 LL | fn mul<A: Mul<B, Output=()>, B>(lhs: A, rhs: B) {
  55    |        --                       --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
  56    |        |
  57    |        help: consider adding a `Copy` constraint to this type argument: `A: Copy +`
  58 LL |     lhs * rhs;
  59    |     --- value moved here
  60 LL |     drop(lhs);
  61    |          ^^^ value used here after move
  62
  63 error[E0382]: use of moved value: `rhs`
  64   --> $DIR/binop-consume-args.rs:20:10
  65    |
  66 LL | fn mul<A: Mul<B, Output=()>, B>(lhs: A, rhs: B) {
  67    |                              -          --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
  68    |                              |
  69    |                              help: consider adding a `Copy` constraint to this type argument: `B: Copy`
  70 LL |     lhs * rhs;
  71    |           --- value moved here
  72 LL |     drop(lhs);
  73 LL |     drop(rhs);
  74    |          ^^^ value used here after move
  75
  76 error[E0382]: use of moved value: `lhs`
  77   --> $DIR/binop-consume-args.rs:25:10
  78    |
  79 LL | fn div<A: Div<B, Output=()>, B>(lhs: A, rhs: B) {
  80    |        --                       --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
  81    |        |
  82    |        help: consider adding a `Copy` constraint to this type argument: `A: Copy +`
  83 LL |     lhs / rhs;
  84    |     --- value moved here
  85 LL |     drop(lhs);
  86    |          ^^^ value used here after move
  87
  88 error[E0382]: use of moved value: `rhs`
  89   --> $DIR/binop-consume-args.rs:26:10
  90    |
  91 LL | fn div<A: Div<B, Output=()>, B>(lhs: A, rhs: B) {
  92    |                              -          --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
  93    |                              |
  94    |                              help: consider adding a `Copy` constraint to this type argument: `B: Copy`
  95 LL |     lhs / rhs;
  96    |           --- value moved here
  97 LL |     drop(lhs);
  98 LL |     drop(rhs);
  99    |          ^^^ value used here after move
 100
 101 error[E0382]: use of moved value: `lhs`
 102   --> $DIR/binop-consume-args.rs:31:10
 103    |
 104 LL | fn rem<A: Rem<B, Output=()>, B>(lhs: A, rhs: B) {
 105    |        --                       --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
 106    |        |
 107    |        help: consider adding a `Copy` constraint to this type argument: `A: Copy +`
 108 LL |     lhs % rhs;
 109    |     --- value moved here
 110 LL |     drop(lhs);
 111    |          ^^^ value used here after move
 112
 113 error[E0382]: use of moved value: `rhs`
 114   --> $DIR/binop-consume-args.rs:32:10
 115    |
 116 LL | fn rem<A: Rem<B, Output=()>, B>(lhs: A, rhs: B) {
 117    |                              -          --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
 118    |                              |
 119    |                              help: consider adding a `Copy` constraint to this type argument: `B: Copy`
 120 LL |     lhs % rhs;
 121    |           --- value moved here
 122 LL |     drop(lhs);
 123 LL |     drop(rhs);
 124    |          ^^^ value used here after move
 125
 126 error[E0382]: use of moved value: `lhs`
 127   --> $DIR/binop-consume-args.rs:37:10
 128    |
 129 LL | fn bitand<A: BitAnd<B, Output=()>, B>(lhs: A, rhs: B) {
 130    |           --                          --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
 131    |           |
 132    |           help: consider adding a `Copy` constraint to this type argument: `A: Copy +`
 133 LL |     lhs & rhs;
 134    |     --- value moved here
 135 LL |     drop(lhs);
 136    |          ^^^ value used here after move
 137
 138 error[E0382]: use of moved value: `rhs`
 139   --> $DIR/binop-consume-args.rs:38:10
 140    |
 141 LL | fn bitand<A: BitAnd<B, Output=()>, B>(lhs: A, rhs: B) {
 142    |                                    -          --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
 143    |                                    |
 144    |                                    help: consider adding a `Copy` constraint to this type argument: `B: Copy`
 145 LL |     lhs & rhs;
 146    |           --- value moved here
 147 LL |     drop(lhs);
 148 LL |     drop(rhs);
 149    |          ^^^ value used here after move
 150
 151 error[E0382]: use of moved value: `lhs`
 152   --> $DIR/binop-consume-args.rs:43:10
 153    |
 154 LL | fn bitor<A: BitOr<B, Output=()>, B>(lhs: A, rhs: B) {
 155    |          --                         --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
 156    |          |
 157    |          help: consider adding a `Copy` constraint to this type argument: `A: Copy +`
 158 LL |     lhs | rhs;
 159    |     --- value moved here
 160 LL |     drop(lhs);
 161    |          ^^^ value used here after move
 162
 163 error[E0382]: use of moved value: `rhs`
 164   --> $DIR/binop-consume-args.rs:44:10
 165    |
 166 LL | fn bitor<A: BitOr<B, Output=()>, B>(lhs: A, rhs: B) {
 167    |                                  -          --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
 168    |                                  |
 169    |                                  help: consider adding a `Copy` constraint to this type argument: `B: Copy`
 170 LL |     lhs | rhs;
 171    |           --- value moved here
 172 LL |     drop(lhs);
 173 LL |     drop(rhs);
 174    |          ^^^ value used here after move
 175
 176 error[E0382]: use of moved value: `lhs`
 177   --> $DIR/binop-consume-args.rs:49:10
 178    |
 179 LL | fn bitxor<A: BitXor<B, Output=()>, B>(lhs: A, rhs: B) {
 180    |           --                          --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
 181    |           |
 182    |           help: consider adding a `Copy` constraint to this type argument: `A: Copy +`
 183 LL |     lhs ^ rhs;
 184    |     --- value moved here
 185 LL |     drop(lhs);
 186    |          ^^^ value used here after move
 187
 188 error[E0382]: use of moved value: `rhs`
 189   --> $DIR/binop-consume-args.rs:50:10
 190    |
 191 LL | fn bitxor<A: BitXor<B, Output=()>, B>(lhs: A, rhs: B) {
 192    |                                    -          --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
 193    |                                    |
 194    |                                    help: consider adding a `Copy` constraint to this type argument: `B: Copy`
 195 LL |     lhs ^ rhs;
 196    |           --- value moved here
 197 LL |     drop(lhs);
 198 LL |     drop(rhs);
 199    |          ^^^ value used here after move
 200
 201 error[E0382]: use of moved value: `lhs`
 202   --> $DIR/binop-consume-args.rs:55:10
 203    |
 204 LL | fn shl<A: Shl<B, Output=()>, B>(lhs: A, rhs: B) {
 205    |        --                       --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
 206    |        |
 207    |        help: consider adding a `Copy` constraint to this type argument: `A: Copy +`
 208 LL |     lhs << rhs;
 209    |     --- value moved here
 210 LL |     drop(lhs);
 211    |          ^^^ value used here after move
 212
 213 error[E0382]: use of moved value: `rhs`
 214   --> $DIR/binop-consume-args.rs:56:10
 215    |
 216 LL | fn shl<A: Shl<B, Output=()>, B>(lhs: A, rhs: B) {
 217    |                              -          --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
 218    |                              |
 219    |                              help: consider adding a `Copy` constraint to this type argument: `B: Copy`
 220 LL |     lhs << rhs;
 221    |            --- value moved here
 222 LL |     drop(lhs);
 223 LL |     drop(rhs);
 224    |          ^^^ value used here after move
 225
 226 error[E0382]: use of moved value: `lhs`
 227   --> $DIR/binop-consume-args.rs:61:10
 228    |
 229 LL | fn shr<A: Shr<B, Output=()>, B>(lhs: A, rhs: B) {
 230    |        --                       --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
 231    |        |
 232    |        help: consider adding a `Copy` constraint to this type argument: `A: Copy +`
 233 LL |     lhs >> rhs;
 234    |     --- value moved here
 235 LL |     drop(lhs);
 236    |          ^^^ value used here after move
 237
 238 error[E0382]: use of moved value: `rhs`
 239   --> $DIR/binop-consume-args.rs:62:10
 240    |
 241 LL | fn shr<A: Shr<B, Output=()>, B>(lhs: A, rhs: B) {
 242    |                              -          --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
 243    |                              |
 244    |                              help: consider adding a `Copy` constraint to this type argument: `B: Copy`
 245 LL |     lhs >> rhs;
 246    |            --- value moved here
 247 LL |     drop(lhs);
 248 LL |     drop(rhs);
 249    |          ^^^ value used here after move
 250
 251 error: aborting due to 20 previous errors
 252
 253 For more information about this error, try `rustc --explain E0382`.