fork/rust

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

borsAuto merge of #72883 - Mark-Simulacrum:stable-next, r=Mark-Simulacrum49cae55760d

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