fork/rust

git clone https://git.julia.blue/fork/rust

borsAuto merge of #71868 - Mark-Simulacrum:stable-1.43.1, r=pietroalbini8d69840ab92

1.43.1
11.8 KiB333 linesraw
1error[E0382]: use of moved value: `lhs`
2  --> $DIR/binop-consume-args.rs:7:10
3   |
4LL | 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
6LL |     lhs + rhs;
7   |     --- value moved here
8LL |     drop(lhs);
9   |          ^^^ value used here after move
10   |
11help: consider further restricting this bound with `+ Copy`
12  --> $DIR/binop-consume-args.rs:5:11
13   |
14LL | fn add<A: Add<B, Output=()>, B>(lhs: A, rhs: B) {
15   |           ^^^^^^^^^^^^^^^^^
16
17error[E0382]: use of moved value: `rhs`
18  --> $DIR/binop-consume-args.rs:8:10
19   |
20LL | fn add<A: Add<B, Output=()>, B>(lhs: A, rhs: B) {
21   |                                         --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
22LL |     lhs + rhs;
23   |           --- value moved here
24LL |     drop(lhs);
25LL |     drop(rhs);
26   |          ^^^ value used here after move
27   |
28help: consider restricting this type parameter with `B: Copy`
29  --> $DIR/binop-consume-args.rs:5:30
30   |
31LL | fn add<A: Add<B, Output=()>, B>(lhs: A, rhs: B) {
32   |                              ^
33
34error[E0382]: use of moved value: `lhs`
35  --> $DIR/binop-consume-args.rs:13:10
36   |
37LL | fn sub<A: Sub<B, Output=()>, B>(lhs: A, rhs: B) {
38   |                                 --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
39LL |     lhs - rhs;
40   |     --- value moved here
41LL |     drop(lhs);
42   |          ^^^ value used here after move
43   |
44help: consider further restricting this bound with `+ Copy`
45  --> $DIR/binop-consume-args.rs:11:11
46   |
47LL | fn sub<A: Sub<B, Output=()>, B>(lhs: A, rhs: B) {
48   |           ^^^^^^^^^^^^^^^^^
49
50error[E0382]: use of moved value: `rhs`
51  --> $DIR/binop-consume-args.rs:14:10
52   |
53LL | fn sub<A: Sub<B, Output=()>, B>(lhs: A, rhs: B) {
54   |                                         --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
55LL |     lhs - rhs;
56   |           --- value moved here
57LL |     drop(lhs);
58LL |     drop(rhs);
59   |          ^^^ value used here after move
60   |
61help: consider restricting this type parameter with `B: Copy`
62  --> $DIR/binop-consume-args.rs:11:30
63   |
64LL | fn sub<A: Sub<B, Output=()>, B>(lhs: A, rhs: B) {
65   |                              ^
66
67error[E0382]: use of moved value: `lhs`
68  --> $DIR/binop-consume-args.rs:19:10
69   |
70LL | fn mul<A: Mul<B, Output=()>, B>(lhs: A, rhs: B) {
71   |                                 --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
72LL |     lhs * rhs;
73   |     --- value moved here
74LL |     drop(lhs);
75   |          ^^^ value used here after move
76   |
77help: consider further restricting this bound with `+ Copy`
78  --> $DIR/binop-consume-args.rs:17:11
79   |
80LL | fn mul<A: Mul<B, Output=()>, B>(lhs: A, rhs: B) {
81   |           ^^^^^^^^^^^^^^^^^
82
83error[E0382]: use of moved value: `rhs`
84  --> $DIR/binop-consume-args.rs:20:10
85   |
86LL | fn mul<A: Mul<B, Output=()>, B>(lhs: A, rhs: B) {
87   |                                         --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
88LL |     lhs * rhs;
89   |           --- value moved here
90LL |     drop(lhs);
91LL |     drop(rhs);
92   |          ^^^ value used here after move
93   |
94help: consider restricting this type parameter with `B: Copy`
95  --> $DIR/binop-consume-args.rs:17:30
96   |
97LL | fn mul<A: Mul<B, Output=()>, B>(lhs: A, rhs: B) {
98   |                              ^
99
100error[E0382]: use of moved value: `lhs`
101  --> $DIR/binop-consume-args.rs:25:10
102   |
103LL | fn div<A: Div<B, Output=()>, B>(lhs: A, rhs: B) {
104   |                                 --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
105LL |     lhs / rhs;
106   |     --- value moved here
107LL |     drop(lhs);
108   |          ^^^ value used here after move
109   |
110help: consider further restricting this bound with `+ Copy`
111  --> $DIR/binop-consume-args.rs:23:11
112   |
113LL | fn div<A: Div<B, Output=()>, B>(lhs: A, rhs: B) {
114   |           ^^^^^^^^^^^^^^^^^
115
116error[E0382]: use of moved value: `rhs`
117  --> $DIR/binop-consume-args.rs:26:10
118   |
119LL | fn div<A: Div<B, Output=()>, B>(lhs: A, rhs: B) {
120   |                                         --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
121LL |     lhs / rhs;
122   |           --- value moved here
123LL |     drop(lhs);
124LL |     drop(rhs);
125   |          ^^^ value used here after move
126   |
127help: consider restricting this type parameter with `B: Copy`
128  --> $DIR/binop-consume-args.rs:23:30
129   |
130LL | fn div<A: Div<B, Output=()>, B>(lhs: A, rhs: B) {
131   |                              ^
132
133error[E0382]: use of moved value: `lhs`
134  --> $DIR/binop-consume-args.rs:31:10
135   |
136LL | fn rem<A: Rem<B, Output=()>, B>(lhs: A, rhs: B) {
137   |                                 --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
138LL |     lhs % rhs;
139   |     --- value moved here
140LL |     drop(lhs);
141   |          ^^^ value used here after move
142   |
143help: consider further restricting this bound with `+ Copy`
144  --> $DIR/binop-consume-args.rs:29:11
145   |
146LL | fn rem<A: Rem<B, Output=()>, B>(lhs: A, rhs: B) {
147   |           ^^^^^^^^^^^^^^^^^
148
149error[E0382]: use of moved value: `rhs`
150  --> $DIR/binop-consume-args.rs:32:10
151   |
152LL | fn rem<A: Rem<B, Output=()>, B>(lhs: A, rhs: B) {
153   |                                         --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
154LL |     lhs % rhs;
155   |           --- value moved here
156LL |     drop(lhs);
157LL |     drop(rhs);
158   |          ^^^ value used here after move
159   |
160help: consider restricting this type parameter with `B: Copy`
161  --> $DIR/binop-consume-args.rs:29:30
162   |
163LL | fn rem<A: Rem<B, Output=()>, B>(lhs: A, rhs: B) {
164   |                              ^
165
166error[E0382]: use of moved value: `lhs`
167  --> $DIR/binop-consume-args.rs:37:10
168   |
169LL | fn bitand<A: BitAnd<B, Output=()>, B>(lhs: A, rhs: B) {
170   |                                       --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
171LL |     lhs & rhs;
172   |     --- value moved here
173LL |     drop(lhs);
174   |          ^^^ value used here after move
175   |
176help: consider further restricting this bound with `+ Copy`
177  --> $DIR/binop-consume-args.rs:35:14
178   |
179LL | fn bitand<A: BitAnd<B, Output=()>, B>(lhs: A, rhs: B) {
180   |              ^^^^^^^^^^^^^^^^^^^^
181
182error[E0382]: use of moved value: `rhs`
183  --> $DIR/binop-consume-args.rs:38:10
184   |
185LL | fn bitand<A: BitAnd<B, Output=()>, B>(lhs: A, rhs: B) {
186   |                                               --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
187LL |     lhs & rhs;
188   |           --- value moved here
189LL |     drop(lhs);
190LL |     drop(rhs);
191   |          ^^^ value used here after move
192   |
193help: consider restricting this type parameter with `B: Copy`
194  --> $DIR/binop-consume-args.rs:35:36
195   |
196LL | fn bitand<A: BitAnd<B, Output=()>, B>(lhs: A, rhs: B) {
197   |                                    ^
198
199error[E0382]: use of moved value: `lhs`
200  --> $DIR/binop-consume-args.rs:43:10
201   |
202LL | fn bitor<A: BitOr<B, Output=()>, B>(lhs: A, rhs: B) {
203   |                                     --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
204LL |     lhs | rhs;
205   |     --- value moved here
206LL |     drop(lhs);
207   |          ^^^ value used here after move
208   |
209help: consider further restricting this bound with `+ Copy`
210  --> $DIR/binop-consume-args.rs:41:13
211   |
212LL | fn bitor<A: BitOr<B, Output=()>, B>(lhs: A, rhs: B) {
213   |             ^^^^^^^^^^^^^^^^^^^
214
215error[E0382]: use of moved value: `rhs`
216  --> $DIR/binop-consume-args.rs:44:10
217   |
218LL | fn bitor<A: BitOr<B, Output=()>, B>(lhs: A, rhs: B) {
219   |                                             --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
220LL |     lhs | rhs;
221   |           --- value moved here
222LL |     drop(lhs);
223LL |     drop(rhs);
224   |          ^^^ value used here after move
225   |
226help: consider restricting this type parameter with `B: Copy`
227  --> $DIR/binop-consume-args.rs:41:34
228   |
229LL | fn bitor<A: BitOr<B, Output=()>, B>(lhs: A, rhs: B) {
230   |                                  ^
231
232error[E0382]: use of moved value: `lhs`
233  --> $DIR/binop-consume-args.rs:49:10
234   |
235LL | fn bitxor<A: BitXor<B, Output=()>, B>(lhs: A, rhs: B) {
236   |                                       --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
237LL |     lhs ^ rhs;
238   |     --- value moved here
239LL |     drop(lhs);
240   |          ^^^ value used here after move
241   |
242help: consider further restricting this bound with `+ Copy`
243  --> $DIR/binop-consume-args.rs:47:14
244   |
245LL | fn bitxor<A: BitXor<B, Output=()>, B>(lhs: A, rhs: B) {
246   |              ^^^^^^^^^^^^^^^^^^^^
247
248error[E0382]: use of moved value: `rhs`
249  --> $DIR/binop-consume-args.rs:50:10
250   |
251LL | fn bitxor<A: BitXor<B, Output=()>, B>(lhs: A, rhs: B) {
252   |                                               --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
253LL |     lhs ^ rhs;
254   |           --- value moved here
255LL |     drop(lhs);
256LL |     drop(rhs);
257   |          ^^^ value used here after move
258   |
259help: consider restricting this type parameter with `B: Copy`
260  --> $DIR/binop-consume-args.rs:47:36
261   |
262LL | fn bitxor<A: BitXor<B, Output=()>, B>(lhs: A, rhs: B) {
263   |                                    ^
264
265error[E0382]: use of moved value: `lhs`
266  --> $DIR/binop-consume-args.rs:55:10
267   |
268LL | fn shl<A: Shl<B, Output=()>, B>(lhs: A, rhs: B) {
269   |                                 --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
270LL |     lhs << rhs;
271   |     --- value moved here
272LL |     drop(lhs);
273   |          ^^^ value used here after move
274   |
275help: consider further restricting this bound with `+ Copy`
276  --> $DIR/binop-consume-args.rs:53:11
277   |
278LL | fn shl<A: Shl<B, Output=()>, B>(lhs: A, rhs: B) {
279   |           ^^^^^^^^^^^^^^^^^
280
281error[E0382]: use of moved value: `rhs`
282  --> $DIR/binop-consume-args.rs:56:10
283   |
284LL | fn shl<A: Shl<B, Output=()>, B>(lhs: A, rhs: B) {
285   |                                         --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
286LL |     lhs << rhs;
287   |            --- value moved here
288LL |     drop(lhs);
289LL |     drop(rhs);
290   |          ^^^ value used here after move
291   |
292help: consider restricting this type parameter with `B: Copy`
293  --> $DIR/binop-consume-args.rs:53:30
294   |
295LL | fn shl<A: Shl<B, Output=()>, B>(lhs: A, rhs: B) {
296   |                              ^
297
298error[E0382]: use of moved value: `lhs`
299  --> $DIR/binop-consume-args.rs:61:10
300   |
301LL | fn shr<A: Shr<B, Output=()>, B>(lhs: A, rhs: B) {
302   |                                 --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
303LL |     lhs >> rhs;
304   |     --- value moved here
305LL |     drop(lhs);
306   |          ^^^ value used here after move
307   |
308help: consider further restricting this bound with `+ Copy`
309  --> $DIR/binop-consume-args.rs:59:11
310   |
311LL | fn shr<A: Shr<B, Output=()>, B>(lhs: A, rhs: B) {
312   |           ^^^^^^^^^^^^^^^^^
313
314error[E0382]: use of moved value: `rhs`
315  --> $DIR/binop-consume-args.rs:62:10
316   |
317LL | fn shr<A: Shr<B, Output=()>, B>(lhs: A, rhs: B) {
318   |                                         --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
319LL |     lhs >> rhs;
320   |            --- value moved here
321LL |     drop(lhs);
322LL |     drop(rhs);
323   |          ^^^ value used here after move
324   |
325help: consider restricting this type parameter with `B: Copy`
326  --> $DIR/binop-consume-args.rs:59:30
327   |
328LL | fn shr<A: Shr<B, Output=()>, B>(lhs: A, rhs: B) {
329   |                              ^
330
331error: aborting due to 20 previous errors
332
333For more information about this error, try `rustc --explain E0382`.