fork/rust

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

borsAuto merge of #67350 - Mark-Simulacrum:stable-next, r=Mark-Simulacrum73528e339aa

1.40.0
25.0 KiB672 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   |
340note: move occurs because these variables have types that don't implement the `Copy` trait
341  --> $DIR/simple.rs:221:26
342   |
343LL |         &mut Either::One(_t) => (),
344   |                          ^^
345...
346LL |         &mut Either::Two(_t) => (),
347   |                          ^^
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   |
473note: move occurs because these variables have types that don't implement the `Copy` trait
474  --> $DIR/simple.rs:280:27
475   |
476LL |         (&mut Either::One(_t),) => (),
477   |                           ^^
478LL |         (&mut Either::Two(_t),) => (),
479   |                           ^^
480
481error[E0507]: cannot move out of a shared reference
482  --> $DIR/simple.rs:288:18
483   |
484LL |     let &X(_t) = &x;
485   |         ------   ^^
486   |         |  |
487   |         |  data moved here
488   |         |  move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
489   |         help: consider removing the `&`: `X(_t)`
490
491error[E0507]: cannot move out of a shared reference
492  --> $DIR/simple.rs:292:31
493   |
494LL |     if let &Either::One(_t) = &e { }
495   |            ----------------   ^^
496   |            |            |
497   |            |            data moved here
498   |            |            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
499   |            help: consider removing the `&`: `Either::One(_t)`
500
501error[E0507]: cannot move out of a shared reference
502  --> $DIR/simple.rs:296:34
503   |
504LL |     while let &Either::One(_t) = &e { }
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:300: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:308: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 shared reference
538  --> $DIR/simple.rs:315:11
539   |
540LL |     match &e {
541   |           ^^
542LL |
543LL |         &Either::One(_t) => (),
544   |         ----------------
545   |         |            |
546   |         |            data moved here
547   |         |            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
548   |         help: consider removing the `&`: `Either::One(_t)`
549
550error[E0507]: cannot move out of a mutable reference
551  --> $DIR/simple.rs:323:22
552   |
553LL |     let &mut X(_t) = &mut xm;
554   |         ----------   ^^^^^^^
555   |         |      |
556   |         |      data moved here
557   |         |      move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
558   |         help: consider removing the `&mut`: `X(_t)`
559
560error[E0507]: cannot move out of a mutable reference
561  --> $DIR/simple.rs:327:35
562   |
563LL |     if let &mut Either::One(_t) = &mut em { }
564   |            --------------------   ^^^^^^^
565   |            |                |
566   |            |                data moved here
567   |            |                move occurs because `_t` has type `X`, which does not implement the `Copy` trait
568   |            help: consider removing the `&mut`: `Either::One(_t)`
569
570error[E0507]: cannot move out of a mutable reference
571  --> $DIR/simple.rs:331:38
572   |
573LL |     while let &mut Either::One(_t) = &mut em { }
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:335: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:343: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:350: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 mutable reference
620  --> $DIR/simple.rs:357:11
621   |
622LL |     match &mut em {
623   |           ^^^^^^^
624LL |
625LL |         &mut Either::One(_t) => (),
626   |         --------------------
627   |         |                |
628   |         |                data moved here
629   |         |                move occurs because `_t` has type `X`, which does not implement the `Copy` trait
630   |         help: consider removing the `&mut`: `Either::One(_t)`
631
632error[E0507]: cannot move out of a shared reference
633  --> $DIR/simple.rs:202:11
634   |
635LL |     fn f1(&X(_t): &X) { }
636   |           ^^^--^
637   |           |  |
638   |           |  data moved here
639   |           |  move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
640   |           help: consider removing the `&`: `X(_t)`
641
642error[E0507]: cannot move out of a mutable reference
643  --> $DIR/simple.rs:249:11
644   |
645LL |     fn f2(&mut X(_t): &mut X) { }
646   |           ^^^^^^^--^
647   |           |      |
648   |           |      data moved here
649   |           |      move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
650   |           help: consider removing the `&mut`: `X(_t)`
651
652error[E0507]: cannot move out of a shared reference
653  --> $DIR/simple.rs:269:11
654   |
655LL |     fn f3((&X(_t),): (&X,)) { }
656   |           ^^^^--^^^
657   |               |
658   |               data moved here
659   |               move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
660
661error[E0507]: cannot move out of a mutable reference
662  --> $DIR/simple.rs:283:11
663   |
664LL |     fn f4((&mut X(_t),): (&mut X,)) { }
665   |           ^^^^^^^^--^^^
666   |                   |
667   |                   data moved here
668   |                   move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
669
670error: aborting due to 60 previous errors
671
672For more information about this error, try `rustc --explain E0507`.