fork/rust

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

borsAuto merge of #69444 - pietroalbini:stable-next-final-v2-new, r=pietroalbinif3e1a954d2e

1.41.1
24.6 KiB659 linesraw
1error[E0507]: cannot move out of `s.0` which is behind a shared reference
2  --> $DIR/simple.rs:38:17
3   |
4LL |     let X(_t) = *s;
5   |           --    ^^ help: consider borrowing here: `&*s`
6   |           |
7   |           data moved here
8   |           move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
9
10error[E0507]: cannot move out of `r.0` which is behind a shared reference
11  --> $DIR/simple.rs:42:30
12   |
13LL |     if let Either::One(_t) = *r { }
14   |                        --    ^^ help: consider borrowing here: `&*r`
15   |                        |
16   |                        data moved here
17   |                        move occurs because `_t` has type `X`, which does not implement the `Copy` trait
18
19error[E0507]: cannot move out of `r.0` which is behind a shared reference
20  --> $DIR/simple.rs:46:33
21   |
22LL |     while let Either::One(_t) = *r { }
23   |                           --    ^^ help: consider borrowing here: `&*r`
24   |                           |
25   |                           data moved here
26   |                           move occurs because `_t` has type `X`, which does not implement the `Copy` trait
27
28error[E0507]: cannot move out of `r.0` which is behind a shared reference
29  --> $DIR/simple.rs:50:11
30   |
31LL |     match *r {
32   |           ^^ help: consider borrowing here: `&*r`
33...
34LL |         Either::One(_t)
35   |                     --
36   |                     |
37   |                     data moved here
38   |                     move occurs because `_t` has type `X`, which does not implement the `Copy` trait
39
40error[E0507]: cannot move out of `r.0` which is behind a shared reference
41  --> $DIR/simple.rs:57:11
42   |
43LL |     match *r {
44   |           ^^ help: consider borrowing here: `&*r`
45...
46LL |         Either::One(_t) => (),
47   |                     --
48   |                     |
49   |                     data moved here
50   |                     move occurs because `_t` has type `X`, which does not implement the `Copy` trait
51
52error[E0507]: cannot move out of `sm.0` which is behind a mutable reference
53  --> $DIR/simple.rs:66:17
54   |
55LL |     let X(_t) = *sm;
56   |           --    ^^^ help: consider borrowing here: `&*sm`
57   |           |
58   |           data moved here
59   |           move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
60
61error[E0507]: cannot move out of `rm.0` which is behind a mutable reference
62  --> $DIR/simple.rs:70:30
63   |
64LL |     if let Either::One(_t) = *rm { }
65   |                        --    ^^^ help: consider borrowing here: `&*rm`
66   |                        |
67   |                        data moved here
68   |                        move occurs because `_t` has type `X`, which does not implement the `Copy` trait
69
70error[E0507]: cannot move out of `rm.0` which is behind a mutable reference
71  --> $DIR/simple.rs:74:33
72   |
73LL |     while let Either::One(_t) = *rm { }
74   |                           --    ^^^ help: consider borrowing here: `&*rm`
75   |                           |
76   |                           data moved here
77   |                           move occurs because `_t` has type `X`, which does not implement the `Copy` trait
78
79error[E0507]: cannot move out of `rm.0` which is behind a mutable reference
80  --> $DIR/simple.rs:78:11
81   |
82LL |     match *rm {
83   |           ^^^ help: consider borrowing here: `&*rm`
84...
85LL |         Either::One(_t)
86   |                     --
87   |                     |
88   |                     data moved here
89   |                     move occurs because `_t` has type `X`, which does not implement the `Copy` trait
90
91error[E0507]: cannot move out of `rm.0` which is behind a mutable reference
92  --> $DIR/simple.rs:85:11
93   |
94LL |     match *rm {
95   |           ^^^ help: consider borrowing here: `&*rm`
96...
97LL |         Either::One(_t) => (),
98   |                     --
99   |                     |
100   |                     data moved here
101   |                     move occurs because `_t` has type `X`, which does not implement the `Copy` trait
102
103error[E0507]: cannot move out of `rm.0` which is behind a mutable reference
104  --> $DIR/simple.rs:93:11
105   |
106LL |     match *rm {
107   |           ^^^ help: consider borrowing here: `&*rm`
108...
109LL |         Either::One(_t) => (),
110   |                     --
111   |                     |
112   |                     data moved here
113   |                     move occurs because `_t` has type `X`, which does not implement the `Copy` trait
114
115error[E0507]: cannot move out of index of `std::vec::Vec<X>`
116  --> $DIR/simple.rs:102:17
117   |
118LL |     let X(_t) = vs[0];
119   |           --    ^^^^^ help: consider borrowing here: `&vs[0]`
120   |           |
121   |           data moved here
122   |           move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
123
124error[E0507]: cannot move out of index of `std::vec::Vec<Either>`
125  --> $DIR/simple.rs:106:30
126   |
127LL |     if let Either::One(_t) = vr[0] { }
128   |                        --    ^^^^^ help: consider borrowing here: `&vr[0]`
129   |                        |
130   |                        data moved here
131   |                        move occurs because `_t` has type `X`, which does not implement the `Copy` trait
132
133error[E0507]: cannot move out of index of `std::vec::Vec<Either>`
134  --> $DIR/simple.rs:110:33
135   |
136LL |     while let Either::One(_t) = vr[0] { }
137   |                           --    ^^^^^ help: consider borrowing here: `&vr[0]`
138   |                           |
139   |                           data moved here
140   |                           move occurs because `_t` has type `X`, which does not implement the `Copy` trait
141
142error[E0507]: cannot move out of index of `std::vec::Vec<Either>`
143  --> $DIR/simple.rs:114:11
144   |
145LL |     match vr[0] {
146   |           ^^^^^ help: consider borrowing here: `&vr[0]`
147...
148LL |         Either::One(_t)
149   |                     --
150   |                     |
151   |                     data moved here
152   |                     move occurs because `_t` has type `X`, which does not implement the `Copy` trait
153
154error[E0507]: cannot move out of index of `std::vec::Vec<Either>`
155  --> $DIR/simple.rs:121:11
156   |
157LL |     match vr[0] {
158   |           ^^^^^ help: consider borrowing here: `&vr[0]`
159...
160LL |         Either::One(_t) => (),
161   |                     --
162   |                     |
163   |                     data moved here
164   |                     move occurs because `_t` has type `X`, which does not implement the `Copy` trait
165
166error[E0507]: cannot move out of index of `std::vec::Vec<X>`
167  --> $DIR/simple.rs:130:17
168   |
169LL |     let X(_t) = vsm[0];
170   |           --    ^^^^^^ help: consider borrowing here: `&vsm[0]`
171   |           |
172   |           data moved here
173   |           move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
174
175error[E0507]: cannot move out of index of `std::vec::Vec<Either>`
176  --> $DIR/simple.rs:134:30
177   |
178LL |     if let Either::One(_t) = vrm[0] { }
179   |                        --    ^^^^^^ help: consider borrowing here: `&vrm[0]`
180   |                        |
181   |                        data moved here
182   |                        move occurs because `_t` has type `X`, which does not implement the `Copy` trait
183
184error[E0507]: cannot move out of index of `std::vec::Vec<Either>`
185  --> $DIR/simple.rs:138:33
186   |
187LL |     while let Either::One(_t) = vrm[0] { }
188   |                           --    ^^^^^^ help: consider borrowing here: `&vrm[0]`
189   |                           |
190   |                           data moved here
191   |                           move occurs because `_t` has type `X`, which does not implement the `Copy` trait
192
193error[E0507]: cannot move out of index of `std::vec::Vec<Either>`
194  --> $DIR/simple.rs:142:11
195   |
196LL |     match vrm[0] {
197   |           ^^^^^^ help: consider borrowing here: `&vrm[0]`
198...
199LL |         Either::One(_t)
200   |                     --
201   |                     |
202   |                     data moved here
203   |                     move occurs because `_t` has type `X`, which does not implement the `Copy` trait
204
205error[E0507]: cannot move out of index of `std::vec::Vec<Either>`
206  --> $DIR/simple.rs:149:11
207   |
208LL |     match vrm[0] {
209   |           ^^^^^^ help: consider borrowing here: `&vrm[0]`
210...
211LL |         Either::One(_t) => (),
212   |                     --
213   |                     |
214   |                     data moved here
215   |                     move occurs because `_t` has type `X`, which does not implement the `Copy` trait
216
217error[E0507]: cannot move out of index of `std::vec::Vec<Either>`
218  --> $DIR/simple.rs:157:11
219   |
220LL |     match vrm[0] {
221   |           ^^^^^^ help: consider borrowing here: `&vrm[0]`
222...
223LL |         Either::One(_t) => (),
224   |                     --
225   |                     |
226   |                     data moved here
227   |                     move occurs because `_t` has type `X`, which does not implement the `Copy` trait
228
229error[E0507]: cannot move out of `s.0` which is behind a shared reference
230  --> $DIR/simple.rs:168:18
231   |
232LL |     let &X(_t) = s;
233   |         ------   ^
234   |         |  |
235   |         |  data moved here
236   |         |  move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
237   |         help: consider removing the `&`: `X(_t)`
238
239error[E0507]: cannot move out of `r.0` which is behind a shared reference
240  --> $DIR/simple.rs:172:31
241   |
242LL |     if let &Either::One(_t) = r { }
243   |            ----------------   ^
244   |            |            |
245   |            |            data moved here
246   |            |            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
247   |            help: consider removing the `&`: `Either::One(_t)`
248
249error[E0507]: cannot move out of `r.0` which is behind a shared reference
250  --> $DIR/simple.rs:176:34
251   |
252LL |     while let &Either::One(_t) = r { }
253   |               ----------------   ^
254   |               |            |
255   |               |            data moved here
256   |               |            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
257   |               help: consider removing the `&`: `Either::One(_t)`
258
259error[E0507]: cannot move out of `r.0` which is behind a shared reference
260  --> $DIR/simple.rs:180:11
261   |
262LL |     match r {
263   |           ^
264LL |
265LL |         &Either::One(_t)
266   |         ----------------
267   |         |            |
268   |         |            data moved here
269   |         |            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
270   |         help: consider removing the `&`: `Either::One(_t)`
271
272error[E0507]: cannot move out of `r.0` which is behind a shared reference
273  --> $DIR/simple.rs:188:11
274   |
275LL |     match r {
276   |           ^
277LL |
278LL |         &Either::One(_t) => (),
279   |         ----------------
280   |         |            |
281   |         |            data moved here
282   |         |            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
283   |         help: consider removing the `&`: `Either::One(_t)`
284
285error[E0507]: cannot move out of `r.0` which is behind a shared reference
286  --> $DIR/simple.rs:195:11
287   |
288LL |     match r {
289   |           ^
290LL |
291LL |         &Either::One(_t) => (),
292   |         ----------------
293   |         |            |
294   |         |            data moved here
295   |         |            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
296   |         help: consider removing the `&`: `Either::One(_t)`
297
298error[E0507]: cannot move out of `sm.0` which is behind a mutable reference
299  --> $DIR/simple.rs:207:22
300   |
301LL |     let &mut X(_t) = sm;
302   |         ----------   ^^
303   |         |      |
304   |         |      data moved here
305   |         |      move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
306   |         help: consider removing the `&mut`: `X(_t)`
307
308error[E0507]: cannot move out of `rm.0` which is behind a mutable reference
309  --> $DIR/simple.rs:211:35
310   |
311LL |     if let &mut Either::One(_t) = rm { }
312   |            --------------------   ^^
313   |            |                |
314   |            |                data moved here
315   |            |                move occurs because `_t` has type `X`, which does not implement the `Copy` trait
316   |            help: consider removing the `&mut`: `Either::One(_t)`
317
318error[E0507]: cannot move out of `rm.0` which is behind a mutable reference
319  --> $DIR/simple.rs:215:38
320   |
321LL |     while let &mut Either::One(_t) = rm { }
322   |               --------------------   ^^
323   |               |                |
324   |               |                data moved here
325   |               |                move occurs because `_t` has type `X`, which does not implement the `Copy` trait
326   |               help: consider removing the `&mut`: `Either::One(_t)`
327
328error[E0507]: cannot move out of `rm.0` which is behind a mutable reference
329  --> $DIR/simple.rs:219:11
330   |
331LL |     match rm {
332   |           ^^
333LL |
334LL |         &mut Either::One(_t) => (),
335   |                          -- data moved here
336...
337LL |         &mut Either::Two(_t) => (),
338   |                          -- ...and here
339   |
340   = note: move occurs because these variables have types that don't implement the `Copy` trait
341help: consider removing the `&mut`
342   |
343LL |         Either::One(_t) => (),
344   |         ^^^^^^^^^^^^^^^
345help: consider removing the `&mut`
346   |
347LL |         Either::Two(_t) => (),
348   |         ^^^^^^^^^^^^^^^
349
350error[E0507]: cannot move out of `rm.0` which is behind a mutable reference
351  --> $DIR/simple.rs:228:11
352   |
353LL |     match rm {
354   |           ^^
355LL |
356LL |         &mut Either::One(_t) => (),
357   |         --------------------
358   |         |                |
359   |         |                data moved here
360   |         |                move occurs because `_t` has type `X`, which does not implement the `Copy` trait
361   |         help: consider removing the `&mut`: `Either::One(_t)`
362
363error[E0507]: cannot move out of `rm.0` which is behind a mutable reference
364  --> $DIR/simple.rs:235:11
365   |
366LL |     match rm {
367   |           ^^
368LL |
369LL |         &mut Either::One(_t) => (),
370   |         --------------------
371   |         |                |
372   |         |                data moved here
373   |         |                move occurs because `_t` has type `X`, which does not implement the `Copy` trait
374   |         help: consider removing the `&mut`: `Either::One(_t)`
375
376error[E0507]: cannot move out of `rm.0` which is behind a mutable reference
377  --> $DIR/simple.rs:242:11
378   |
379LL |     match rm {
380   |           ^^
381LL |
382LL |         &mut Either::One(_t) => (),
383   |         --------------------
384   |         |                |
385   |         |                data moved here
386   |         |                move occurs because `_t` has type `X`, which does not implement the `Copy` trait
387   |         help: consider removing the `&mut`: `Either::One(_t)`
388
389error[E0507]: cannot move out of a shared reference
390  --> $DIR/simple.rs:258:21
391   |
392LL |     let (&X(_t),) = (&x.clone(),);
393   |             --      ^^^^^^^^^^^^^
394   |             |
395   |             data moved here
396   |             move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
397
398error[E0507]: cannot move out of a shared reference
399  --> $DIR/simple.rs:260:34
400   |
401LL |     if let (&Either::One(_t),) = (&e.clone(),) { }
402   |                          --      ^^^^^^^^^^^^^
403   |                          |
404   |                          data moved here
405   |                          move occurs because `_t` has type `X`, which does not implement the `Copy` trait
406
407error[E0507]: cannot move out of a shared reference
408  --> $DIR/simple.rs:262:37
409   |
410LL |     while let (&Either::One(_t),) = (&e.clone(),) { }
411   |                             --      ^^^^^^^^^^^^^
412   |                             |
413   |                             data moved here
414   |                             move occurs because `_t` has type `X`, which does not implement the `Copy` trait
415
416error[E0507]: cannot move out of a shared reference
417  --> $DIR/simple.rs:264:11
418   |
419LL |     match (&e.clone(),) {
420   |           ^^^^^^^^^^^^^
421LL |
422LL |         (&Either::One(_t),)
423   |                       --
424   |                       |
425   |                       data moved here
426   |                       move occurs because `_t` has type `X`, which does not implement the `Copy` trait
427
428error[E0507]: cannot move out of a mutable reference
429  --> $DIR/simple.rs:272:25
430   |
431LL |     let (&mut X(_t),) = (&mut xm.clone(),);
432   |                 --      ^^^^^^^^^^^^^^^^^^
433   |                 |
434   |                 data moved here
435   |                 move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
436
437error[E0507]: cannot move out of a mutable reference
438  --> $DIR/simple.rs:274:38
439   |
440LL |     if let (&mut Either::One(_t),) = (&mut em.clone(),) { }
441   |                              --      ^^^^^^^^^^^^^^^^^^
442   |                              |
443   |                              data moved here
444   |                              move occurs because `_t` has type `X`, which does not implement the `Copy` trait
445
446error[E0507]: cannot move out of a mutable reference
447  --> $DIR/simple.rs:276:41
448   |
449LL |     while let (&mut Either::One(_t),) = (&mut em.clone(),) { }
450   |                                 --      ^^^^^^^^^^^^^^^^^^
451   |                                 |
452   |                                 data moved here
453   |                                 move occurs because `_t` has type `X`, which does not implement the `Copy` trait
454
455error[E0507]: cannot move out of a mutable reference
456  --> $DIR/simple.rs:278:11
457   |
458LL |     match (&mut em.clone(),) {
459   |           ^^^^^^^^^^^^^^^^^^
460LL |
461LL |         (&mut Either::One(_t),) => (),
462   |                           -- data moved here
463LL |         (&mut Either::Two(_t),) => (),
464   |                           -- ...and here
465   |
466   = note: move occurs because these variables have types that don't implement the `Copy` trait
467
468error[E0507]: cannot move out of a shared reference
469  --> $DIR/simple.rs:288:18
470   |
471LL |     let &X(_t) = &x;
472   |         ------   ^^
473   |         |  |
474   |         |  data moved here
475   |         |  move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
476   |         help: consider removing the `&`: `X(_t)`
477
478error[E0507]: cannot move out of a shared reference
479  --> $DIR/simple.rs:292:31
480   |
481LL |     if let &Either::One(_t) = &e { }
482   |            ----------------   ^^
483   |            |            |
484   |            |            data moved here
485   |            |            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
486   |            help: consider removing the `&`: `Either::One(_t)`
487
488error[E0507]: cannot move out of a shared reference
489  --> $DIR/simple.rs:296:34
490   |
491LL |     while let &Either::One(_t) = &e { }
492   |               ----------------   ^^
493   |               |            |
494   |               |            data moved here
495   |               |            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
496   |               help: consider removing the `&`: `Either::One(_t)`
497
498error[E0507]: cannot move out of a shared reference
499  --> $DIR/simple.rs:300:11
500   |
501LL |     match &e {
502   |           ^^
503LL |
504LL |         &Either::One(_t)
505   |         ----------------
506   |         |            |
507   |         |            data moved here
508   |         |            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
509   |         help: consider removing the `&`: `Either::One(_t)`
510
511error[E0507]: cannot move out of a shared reference
512  --> $DIR/simple.rs:308:11
513   |
514LL |     match &e {
515   |           ^^
516LL |
517LL |         &Either::One(_t) => (),
518   |         ----------------
519   |         |            |
520   |         |            data moved here
521   |         |            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
522   |         help: consider removing the `&`: `Either::One(_t)`
523
524error[E0507]: cannot move out of a shared reference
525  --> $DIR/simple.rs:315:11
526   |
527LL |     match &e {
528   |           ^^
529LL |
530LL |         &Either::One(_t) => (),
531   |         ----------------
532   |         |            |
533   |         |            data moved here
534   |         |            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
535   |         help: consider removing the `&`: `Either::One(_t)`
536
537error[E0507]: cannot move out of a mutable reference
538  --> $DIR/simple.rs:323:22
539   |
540LL |     let &mut X(_t) = &mut xm;
541   |         ----------   ^^^^^^^
542   |         |      |
543   |         |      data moved here
544   |         |      move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
545   |         help: consider removing the `&mut`: `X(_t)`
546
547error[E0507]: cannot move out of a mutable reference
548  --> $DIR/simple.rs:327:35
549   |
550LL |     if let &mut Either::One(_t) = &mut em { }
551   |            --------------------   ^^^^^^^
552   |            |                |
553   |            |                data moved here
554   |            |                move occurs because `_t` has type `X`, which does not implement the `Copy` trait
555   |            help: consider removing the `&mut`: `Either::One(_t)`
556
557error[E0507]: cannot move out of a mutable reference
558  --> $DIR/simple.rs:331:38
559   |
560LL |     while let &mut Either::One(_t) = &mut em { }
561   |               --------------------   ^^^^^^^
562   |               |                |
563   |               |                data moved here
564   |               |                move occurs because `_t` has type `X`, which does not implement the `Copy` trait
565   |               help: consider removing the `&mut`: `Either::One(_t)`
566
567error[E0507]: cannot move out of a mutable reference
568  --> $DIR/simple.rs:335:11
569   |
570LL |     match &mut em {
571   |           ^^^^^^^
572LL |
573LL |         &mut Either::One(_t)
574   |         --------------------
575   |         |                |
576   |         |                data moved here
577   |         |                move occurs because `_t` has type `X`, which does not implement the `Copy` trait
578   |         help: consider removing the `&mut`: `Either::One(_t)`
579
580error[E0507]: cannot move out of a mutable reference
581  --> $DIR/simple.rs:343:11
582   |
583LL |     match &mut em {
584   |           ^^^^^^^
585LL |
586LL |         &mut Either::One(_t) => (),
587   |         --------------------
588   |         |                |
589   |         |                data moved here
590   |         |                move occurs because `_t` has type `X`, which does not implement the `Copy` trait
591   |         help: consider removing the `&mut`: `Either::One(_t)`
592
593error[E0507]: cannot move out of a mutable reference
594  --> $DIR/simple.rs:350:11
595   |
596LL |     match &mut em {
597   |           ^^^^^^^
598LL |
599LL |         &mut Either::One(_t) => (),
600   |         --------------------
601   |         |                |
602   |         |                data moved here
603   |         |                move occurs because `_t` has type `X`, which does not implement the `Copy` trait
604   |         help: consider removing the `&mut`: `Either::One(_t)`
605
606error[E0507]: cannot move out of a mutable reference
607  --> $DIR/simple.rs:357:11
608   |
609LL |     match &mut em {
610   |           ^^^^^^^
611LL |
612LL |         &mut Either::One(_t) => (),
613   |         --------------------
614   |         |                |
615   |         |                data moved here
616   |         |                move occurs because `_t` has type `X`, which does not implement the `Copy` trait
617   |         help: consider removing the `&mut`: `Either::One(_t)`
618
619error[E0507]: cannot move out of a shared reference
620  --> $DIR/simple.rs:202:11
621   |
622LL |     fn f1(&X(_t): &X) { }
623   |           ^^^--^
624   |           |  |
625   |           |  data moved here
626   |           |  move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
627   |           help: consider removing the `&`: `X(_t)`
628
629error[E0507]: cannot move out of a mutable reference
630  --> $DIR/simple.rs:249:11
631   |
632LL |     fn f2(&mut X(_t): &mut X) { }
633   |           ^^^^^^^--^
634   |           |      |
635   |           |      data moved here
636   |           |      move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
637   |           help: consider removing the `&mut`: `X(_t)`
638
639error[E0507]: cannot move out of a shared reference
640  --> $DIR/simple.rs:269:11
641   |
642LL |     fn f3((&X(_t),): (&X,)) { }
643   |           ^^^^--^^^
644   |               |
645   |               data moved here
646   |               move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
647
648error[E0507]: cannot move out of a mutable reference
649  --> $DIR/simple.rs:283:11
650   |
651LL |     fn f4((&mut X(_t),): (&mut X,)) { }
652   |           ^^^^^^^^--^^^
653   |                   |
654   |                   data moved here
655   |                   move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
656
657error: aborting due to 60 previous errors
658
659For more information about this error, try `rustc --explain E0507`.