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
24.8 KiB680 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   |
271help: consider removing the `&`
272   |
273LL |         Either::One(_t)
274LL |
275LL |
276LL |         | &Either::Two(_t) => (),
277   |
278
279error[E0507]: cannot move out of `r.0` which is behind a shared reference
280  --> $DIR/simple.rs:188:11
281   |
282LL |     match r {
283   |           ^
284LL |
285LL |         &Either::One(_t) => (),
286   |         ----------------
287   |         |            |
288   |         |            data moved here
289   |         |            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
290   |         help: consider removing the `&`: `Either::One(_t)`
291
292error[E0507]: cannot move out of `r.0` which is behind a shared reference
293  --> $DIR/simple.rs:195:11
294   |
295LL |     match r {
296   |           ^
297LL |
298LL |         &Either::One(_t) => (),
299   |         ----------------
300   |         |            |
301   |         |            data moved here
302   |         |            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
303   |         help: consider removing the `&`: `Either::One(_t)`
304
305error[E0507]: cannot move out of `sm.0` which is behind a mutable reference
306  --> $DIR/simple.rs:207:22
307   |
308LL |     let &mut X(_t) = sm;
309   |         ----------   ^^
310   |         |      |
311   |         |      data moved here
312   |         |      move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
313   |         help: consider removing the `&mut`: `X(_t)`
314
315error[E0507]: cannot move out of `rm.0` which is behind a mutable reference
316  --> $DIR/simple.rs:211:35
317   |
318LL |     if let &mut Either::One(_t) = rm { }
319   |            --------------------   ^^
320   |            |                |
321   |            |                data moved here
322   |            |                move occurs because `_t` has type `X`, which does not implement the `Copy` trait
323   |            help: consider removing the `&mut`: `Either::One(_t)`
324
325error[E0507]: cannot move out of `rm.0` which is behind a mutable reference
326  --> $DIR/simple.rs:215:38
327   |
328LL |     while let &mut Either::One(_t) = rm { }
329   |               --------------------   ^^
330   |               |                |
331   |               |                data moved here
332   |               |                move occurs because `_t` has type `X`, which does not implement the `Copy` trait
333   |               help: consider removing the `&mut`: `Either::One(_t)`
334
335error[E0507]: cannot move out of `rm.0` which is behind a mutable reference
336  --> $DIR/simple.rs:219:11
337   |
338LL |     match rm {
339   |           ^^
340LL |
341LL |         &mut Either::One(_t) => (),
342   |                          -- data moved here
343...
344LL |         &mut Either::Two(_t) => (),
345   |                          -- ...and here
346   |
347   = note: move occurs because these variables have types that don't implement the `Copy` trait
348help: consider removing the `&mut`
349   |
350LL |         Either::One(_t) => (),
351   |         ^^^^^^^^^^^^^^^
352help: consider removing the `&mut`
353   |
354LL |         Either::Two(_t) => (),
355   |         ^^^^^^^^^^^^^^^
356
357error[E0507]: cannot move out of `rm.0` which is behind a mutable reference
358  --> $DIR/simple.rs:228:11
359   |
360LL |     match rm {
361   |           ^^
362LL |
363LL |         &mut Either::One(_t) => (),
364   |         --------------------
365   |         |                |
366   |         |                data moved here
367   |         |                move occurs because `_t` has type `X`, which does not implement the `Copy` trait
368   |         help: consider removing the `&mut`: `Either::One(_t)`
369
370error[E0507]: cannot move out of `rm.0` which is behind a mutable reference
371  --> $DIR/simple.rs:235:11
372   |
373LL |     match rm {
374   |           ^^
375LL |
376LL |         &mut Either::One(_t) => (),
377   |         --------------------
378   |         |                |
379   |         |                data moved here
380   |         |                move occurs because `_t` has type `X`, which does not implement the `Copy` trait
381   |         help: consider removing the `&mut`: `Either::One(_t)`
382
383error[E0507]: cannot move out of `rm.0` which is behind a mutable reference
384  --> $DIR/simple.rs:242:11
385   |
386LL |     match rm {
387   |           ^^
388LL |
389LL |         &mut Either::One(_t) => (),
390   |         --------------------
391   |         |                |
392   |         |                data moved here
393   |         |                move occurs because `_t` has type `X`, which does not implement the `Copy` trait
394   |         help: consider removing the `&mut`: `Either::One(_t)`
395
396error[E0507]: cannot move out of a shared reference
397  --> $DIR/simple.rs:258:21
398   |
399LL |     let (&X(_t),) = (&x.clone(),);
400   |             --      ^^^^^^^^^^^^^
401   |             |
402   |             data moved here
403   |             move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
404
405error[E0507]: cannot move out of a shared reference
406  --> $DIR/simple.rs:260:34
407   |
408LL |     if let (&Either::One(_t),) = (&e.clone(),) { }
409   |                          --      ^^^^^^^^^^^^^
410   |                          |
411   |                          data moved here
412   |                          move occurs because `_t` has type `X`, which does not implement the `Copy` trait
413
414error[E0507]: cannot move out of a shared reference
415  --> $DIR/simple.rs:262:37
416   |
417LL |     while let (&Either::One(_t),) = (&e.clone(),) { }
418   |                             --      ^^^^^^^^^^^^^
419   |                             |
420   |                             data moved here
421   |                             move occurs because `_t` has type `X`, which does not implement the `Copy` trait
422
423error[E0507]: cannot move out of a shared reference
424  --> $DIR/simple.rs:264:11
425   |
426LL |     match (&e.clone(),) {
427   |           ^^^^^^^^^^^^^
428LL |
429LL |         (&Either::One(_t),)
430   |                       --
431   |                       |
432   |                       data moved here
433   |                       move occurs because `_t` has type `X`, which does not implement the `Copy` trait
434
435error[E0507]: cannot move out of a mutable reference
436  --> $DIR/simple.rs:272:25
437   |
438LL |     let (&mut X(_t),) = (&mut xm.clone(),);
439   |                 --      ^^^^^^^^^^^^^^^^^^
440   |                 |
441   |                 data moved here
442   |                 move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
443
444error[E0507]: cannot move out of a mutable reference
445  --> $DIR/simple.rs:274:38
446   |
447LL |     if let (&mut Either::One(_t),) = (&mut em.clone(),) { }
448   |                              --      ^^^^^^^^^^^^^^^^^^
449   |                              |
450   |                              data moved here
451   |                              move occurs because `_t` has type `X`, which does not implement the `Copy` trait
452
453error[E0507]: cannot move out of a mutable reference
454  --> $DIR/simple.rs:276:41
455   |
456LL |     while let (&mut Either::One(_t),) = (&mut em.clone(),) { }
457   |                                 --      ^^^^^^^^^^^^^^^^^^
458   |                                 |
459   |                                 data moved here
460   |                                 move occurs because `_t` has type `X`, which does not implement the `Copy` trait
461
462error[E0507]: cannot move out of a mutable reference
463  --> $DIR/simple.rs:278:11
464   |
465LL |     match (&mut em.clone(),) {
466   |           ^^^^^^^^^^^^^^^^^^
467LL |
468LL |         (&mut Either::One(_t),) => (),
469   |                           -- data moved here
470LL |         (&mut Either::Two(_t),) => (),
471   |                           -- ...and here
472   |
473   = note: move occurs because these variables have types that don't implement the `Copy` trait
474
475error[E0507]: cannot move out of a shared reference
476  --> $DIR/simple.rs:288:18
477   |
478LL |     let &X(_t) = &x;
479   |         ------   ^^
480   |         |  |
481   |         |  data moved here
482   |         |  move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
483   |         help: consider removing the `&`: `X(_t)`
484
485error[E0507]: cannot move out of a shared reference
486  --> $DIR/simple.rs:292:31
487   |
488LL |     if let &Either::One(_t) = &e { }
489   |            ----------------   ^^
490   |            |            |
491   |            |            data moved here
492   |            |            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
493   |            help: consider removing the `&`: `Either::One(_t)`
494
495error[E0507]: cannot move out of a shared reference
496  --> $DIR/simple.rs:296:34
497   |
498LL |     while let &Either::One(_t) = &e { }
499   |               ----------------   ^^
500   |               |            |
501   |               |            data moved here
502   |               |            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
503   |               help: consider removing the `&`: `Either::One(_t)`
504
505error[E0507]: cannot move out of a shared reference
506  --> $DIR/simple.rs:300:11
507   |
508LL |     match &e {
509   |           ^^
510LL |
511LL |         &Either::One(_t)
512   |                      --
513   |                      |
514   |                      data moved here
515   |                      move occurs because `_t` has type `X`, which does not implement the `Copy` trait
516   |
517help: consider removing the `&`
518   |
519LL |         Either::One(_t)
520LL |
521LL |
522LL |         | &Either::Two(_t) => (),
523   |
524
525error[E0507]: cannot move out of a shared reference
526  --> $DIR/simple.rs:308:11
527   |
528LL |     match &e {
529   |           ^^
530LL |
531LL |         &Either::One(_t) => (),
532   |         ----------------
533   |         |            |
534   |         |            data moved here
535   |         |            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
536   |         help: consider removing the `&`: `Either::One(_t)`
537
538error[E0507]: cannot move out of a shared reference
539  --> $DIR/simple.rs:315:11
540   |
541LL |     match &e {
542   |           ^^
543LL |
544LL |         &Either::One(_t) => (),
545   |         ----------------
546   |         |            |
547   |         |            data moved here
548   |         |            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
549   |         help: consider removing the `&`: `Either::One(_t)`
550
551error[E0507]: cannot move out of a mutable reference
552  --> $DIR/simple.rs:323:22
553   |
554LL |     let &mut X(_t) = &mut xm;
555   |         ----------   ^^^^^^^
556   |         |      |
557   |         |      data moved here
558   |         |      move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
559   |         help: consider removing the `&mut`: `X(_t)`
560
561error[E0507]: cannot move out of a mutable reference
562  --> $DIR/simple.rs:327:35
563   |
564LL |     if let &mut Either::One(_t) = &mut em { }
565   |            --------------------   ^^^^^^^
566   |            |                |
567   |            |                data moved here
568   |            |                move occurs because `_t` has type `X`, which does not implement the `Copy` trait
569   |            help: consider removing the `&mut`: `Either::One(_t)`
570
571error[E0507]: cannot move out of a mutable reference
572  --> $DIR/simple.rs:331:38
573   |
574LL |     while let &mut Either::One(_t) = &mut em { }
575   |               --------------------   ^^^^^^^
576   |               |                |
577   |               |                data moved here
578   |               |                move occurs because `_t` has type `X`, which does not implement the `Copy` trait
579   |               help: consider removing the `&mut`: `Either::One(_t)`
580
581error[E0507]: cannot move out of a mutable reference
582  --> $DIR/simple.rs:335:11
583   |
584LL |     match &mut em {
585   |           ^^^^^^^
586LL |
587LL |         &mut Either::One(_t)
588   |                          --
589   |                          |
590   |                          data moved here
591   |                          move occurs because `_t` has type `X`, which does not implement the `Copy` trait
592   |
593help: consider removing the `&mut`
594   |
595LL |         Either::One(_t)
596LL |
597LL |
598LL |         | &mut Either::Two(_t) => (),
599   |
600
601error[E0507]: cannot move out of a mutable reference
602  --> $DIR/simple.rs:343:11
603   |
604LL |     match &mut em {
605   |           ^^^^^^^
606LL |
607LL |         &mut Either::One(_t) => (),
608   |         --------------------
609   |         |                |
610   |         |                data moved here
611   |         |                move occurs because `_t` has type `X`, which does not implement the `Copy` trait
612   |         help: consider removing the `&mut`: `Either::One(_t)`
613
614error[E0507]: cannot move out of a mutable reference
615  --> $DIR/simple.rs:350:11
616   |
617LL |     match &mut em {
618   |           ^^^^^^^
619LL |
620LL |         &mut Either::One(_t) => (),
621   |         --------------------
622   |         |                |
623   |         |                data moved here
624   |         |                move occurs because `_t` has type `X`, which does not implement the `Copy` trait
625   |         help: consider removing the `&mut`: `Either::One(_t)`
626
627error[E0507]: cannot move out of a mutable reference
628  --> $DIR/simple.rs:357:11
629   |
630LL |     match &mut em {
631   |           ^^^^^^^
632LL |
633LL |         &mut Either::One(_t) => (),
634   |         --------------------
635   |         |                |
636   |         |                data moved here
637   |         |                move occurs because `_t` has type `X`, which does not implement the `Copy` trait
638   |         help: consider removing the `&mut`: `Either::One(_t)`
639
640error[E0507]: cannot move out of a shared reference
641  --> $DIR/simple.rs:202:11
642   |
643LL |     fn f1(&X(_t): &X) { }
644   |           ^^^--^
645   |           |  |
646   |           |  data moved here
647   |           |  move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
648   |           help: consider removing the `&`: `X(_t)`
649
650error[E0507]: cannot move out of a mutable reference
651  --> $DIR/simple.rs:249:11
652   |
653LL |     fn f2(&mut X(_t): &mut X) { }
654   |           ^^^^^^^--^
655   |           |      |
656   |           |      data moved here
657   |           |      move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
658   |           help: consider removing the `&mut`: `X(_t)`
659
660error[E0507]: cannot move out of a shared reference
661  --> $DIR/simple.rs:269:11
662   |
663LL |     fn f3((&X(_t),): (&X,)) { }
664   |           ^^^^--^^^
665   |               |
666   |               data moved here
667   |               move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
668
669error[E0507]: cannot move out of a mutable reference
670  --> $DIR/simple.rs:283:11
671   |
672LL |     fn f4((&mut X(_t),): (&mut X,)) { }
673   |           ^^^^^^^^--^^^
674   |                   |
675   |                   data moved here
676   |                   move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
677
678error: aborting due to 60 previous errors
679
680For more information about this error, try `rustc --explain E0507`.