src/test/ui/suggestions/dont-suggest-ref/simple.stderr

   1 error[E0507]: cannot move out of `s.0` which is behind a shared reference
   2   --> $DIR/simple.rs:38:17
   3    |
   4 LL |     let X(_t) = *s;
   5    |           --    ^^ help: consider removing the `*`: `s`
   6    |           |
   7    |           data moved here
   8    |           move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
   9
  10 error[E0507]: cannot move out of `r.0` which is behind a shared reference
  11   --> $DIR/simple.rs:42:30
  12    |
  13 LL |     if let Either::One(_t) = *r { }
  14    |                        --    ^^ help: consider removing the `*`: `r`
  15    |                        |
  16    |                        data moved here
  17    |                        move occurs because `_t` has type `X`, which does not implement the `Copy` trait
  18
  19 error[E0507]: cannot move out of `r.0` which is behind a shared reference
  20   --> $DIR/simple.rs:46:33
  21    |
  22 LL |     while let Either::One(_t) = *r { }
  23    |                           --    ^^ help: consider removing the `*`: `r`
  24    |                           |
  25    |                           data moved here
  26    |                           move occurs because `_t` has type `X`, which does not implement the `Copy` trait
  27
  28 error[E0507]: cannot move out of `r.0` which is behind a shared reference
  29   --> $DIR/simple.rs:50:11
  30    |
  31 LL |     match *r {
  32    |           ^^ help: consider removing the `*`: `r`
  33 ...
  34 LL |         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
  40 error[E0507]: cannot move out of `r.0` which is behind a shared reference
  41   --> $DIR/simple.rs:57:11
  42    |
  43 LL |     match *r {
  44    |           ^^ help: consider removing the `*`: `r`
  45 ...
  46 LL |         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
  52 error[E0507]: cannot move out of `sm.0` which is behind a mutable reference
  53   --> $DIR/simple.rs:66:17
  54    |
  55 LL |     let X(_t) = *sm;
  56    |           --    ^^^ help: consider removing the `*`: `sm`
  57    |           |
  58    |           data moved here
  59    |           move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
  60
  61 error[E0507]: cannot move out of `rm.0` which is behind a mutable reference
  62   --> $DIR/simple.rs:70:30
  63    |
  64 LL |     if let Either::One(_t) = *rm { }
  65    |                        --    ^^^ help: consider removing the `*`: `rm`
  66    |                        |
  67    |                        data moved here
  68    |                        move occurs because `_t` has type `X`, which does not implement the `Copy` trait
  69
  70 error[E0507]: cannot move out of `rm.0` which is behind a mutable reference
  71   --> $DIR/simple.rs:74:33
  72    |
  73 LL |     while let Either::One(_t) = *rm { }
  74    |                           --    ^^^ help: consider removing the `*`: `rm`
  75    |                           |
  76    |                           data moved here
  77    |                           move occurs because `_t` has type `X`, which does not implement the `Copy` trait
  78
  79 error[E0507]: cannot move out of `rm.0` which is behind a mutable reference
  80   --> $DIR/simple.rs:78:11
  81    |
  82 LL |     match *rm {
  83    |           ^^^ help: consider removing the `*`: `rm`
  84 ...
  85 LL |         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
  91 error[E0507]: cannot move out of `rm.0` which is behind a mutable reference
  92   --> $DIR/simple.rs:85:11
  93    |
  94 LL |     match *rm {
  95    |           ^^^ help: consider removing the `*`: `rm`
  96 ...
  97 LL |         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
 103 error[E0507]: cannot move out of `rm.0` which is behind a mutable reference
 104   --> $DIR/simple.rs:93:11
 105    |
 106 LL |     match *rm {
 107    |           ^^^ help: consider removing the `*`: `rm`
 108 ...
 109 LL |         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
 115 error[E0507]: cannot move out of index of `std::vec::Vec<X>`
 116   --> $DIR/simple.rs:102:17
 117    |
 118 LL |     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
 124 error[E0507]: cannot move out of index of `std::vec::Vec<Either>`
 125   --> $DIR/simple.rs:106:30
 126    |
 127 LL |     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
 133 error[E0507]: cannot move out of index of `std::vec::Vec<Either>`
 134   --> $DIR/simple.rs:110:33
 135    |
 136 LL |     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
 142 error[E0507]: cannot move out of index of `std::vec::Vec<Either>`
 143   --> $DIR/simple.rs:114:11
 144    |
 145 LL |     match vr[0] {
 146    |           ^^^^^ help: consider borrowing here: `&vr[0]`
 147 ...
 148 LL |         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
 154 error[E0507]: cannot move out of index of `std::vec::Vec<Either>`
 155   --> $DIR/simple.rs:121:11
 156    |
 157 LL |     match vr[0] {
 158    |           ^^^^^ help: consider borrowing here: `&vr[0]`
 159 ...
 160 LL |         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
 166 error[E0507]: cannot move out of index of `std::vec::Vec<X>`
 167   --> $DIR/simple.rs:130:17
 168    |
 169 LL |     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
 175 error[E0507]: cannot move out of index of `std::vec::Vec<Either>`
 176   --> $DIR/simple.rs:134:30
 177    |
 178 LL |     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
 184 error[E0507]: cannot move out of index of `std::vec::Vec<Either>`
 185   --> $DIR/simple.rs:138:33
 186    |
 187 LL |     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
 193 error[E0507]: cannot move out of index of `std::vec::Vec<Either>`
 194   --> $DIR/simple.rs:142:11
 195    |
 196 LL |     match vrm[0] {
 197    |           ^^^^^^ help: consider borrowing here: `&vrm[0]`
 198 ...
 199 LL |         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
 205 error[E0507]: cannot move out of index of `std::vec::Vec<Either>`
 206   --> $DIR/simple.rs:149:11
 207    |
 208 LL |     match vrm[0] {
 209    |           ^^^^^^ help: consider borrowing here: `&vrm[0]`
 210 ...
 211 LL |         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
 217 error[E0507]: cannot move out of index of `std::vec::Vec<Either>`
 218   --> $DIR/simple.rs:157:11
 219    |
 220 LL |     match vrm[0] {
 221    |           ^^^^^^ help: consider borrowing here: `&vrm[0]`
 222 ...
 223 LL |         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
 229 error[E0507]: cannot move out of `s.0` which is behind a shared reference
 230   --> $DIR/simple.rs:168:18
 231    |
 232 LL |     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
 239 error[E0507]: cannot move out of `r.0` which is behind a shared reference
 240   --> $DIR/simple.rs:172:31
 241    |
 242 LL |     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
 249 error[E0507]: cannot move out of `r.0` which is behind a shared reference
 250   --> $DIR/simple.rs:176:34
 251    |
 252 LL |     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
 259 error[E0507]: cannot move out of `r.0` which is behind a shared reference
 260   --> $DIR/simple.rs:180:11
 261    |
 262 LL |     match r {
 263    |           ^
 264 LL |
 265 LL |         &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
 272 error[E0507]: cannot move out of `r.0` which is behind a shared reference
 273   --> $DIR/simple.rs:188:11
 274    |
 275 LL |     match r {
 276    |           ^
 277 LL |
 278 LL |         &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
 285 error[E0507]: cannot move out of `r.0` which is behind a shared reference
 286   --> $DIR/simple.rs:195:11
 287    |
 288 LL |     match r {
 289    |           ^
 290 LL |
 291 LL |         &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
 298 error[E0507]: cannot move out of `sm.0` which is behind a mutable reference
 299   --> $DIR/simple.rs:207:22
 300    |
 301 LL |     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
 308 error[E0507]: cannot move out of `rm.0` which is behind a mutable reference
 309   --> $DIR/simple.rs:211:35
 310    |
 311 LL |     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
 318 error[E0507]: cannot move out of `rm.0` which is behind a mutable reference
 319   --> $DIR/simple.rs:215:38
 320    |
 321 LL |     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
 328 error[E0507]: cannot move out of `rm.0` which is behind a mutable reference
 329   --> $DIR/simple.rs:219:11
 330    |
 331 LL |     match rm {
 332    |           ^^
 333 LL |
 334 LL |         &mut Either::One(_t) => (),
 335    |                          -- data moved here
 336 ...
 337 LL |         &mut Either::Two(_t) => (),
 338    |                          -- ...and here
 339    |
 340 note: move occurs because these variables have types that don't implement the `Copy` trait
 341   --> $DIR/simple.rs:221:26
 342    |
 343 LL |         &mut Either::One(_t) => (),
 344    |                          ^^
 345 ...
 346 LL |         &mut Either::Two(_t) => (),
 347    |                          ^^
 348 help: consider removing the `&mut`
 349    |
 350 LL |         Either::One(_t) => (),
 351    |         ^^^^^^^^^^^^^^^
 352 help: consider removing the `&mut`
 353    |
 354 LL |         Either::Two(_t) => (),
 355    |         ^^^^^^^^^^^^^^^
 356
 357 error[E0507]: cannot move out of `rm.0` which is behind a mutable reference
 358   --> $DIR/simple.rs:228:11
 359    |
 360 LL |     match rm {
 361    |           ^^
 362 LL |
 363 LL |         &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
 370 error[E0507]: cannot move out of `rm.0` which is behind a mutable reference
 371   --> $DIR/simple.rs:235:11
 372    |
 373 LL |     match rm {
 374    |           ^^
 375 LL |
 376 LL |         &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
 383 error[E0507]: cannot move out of `rm.0` which is behind a mutable reference
 384   --> $DIR/simple.rs:242:11
 385    |
 386 LL |     match rm {
 387    |           ^^
 388 LL |
 389 LL |         &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
 396 error[E0507]: cannot move out of a shared reference
 397   --> $DIR/simple.rs:258:21
 398    |
 399 LL |     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
 405 error[E0507]: cannot move out of a shared reference
 406   --> $DIR/simple.rs:260:34
 407    |
 408 LL |     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
 414 error[E0507]: cannot move out of a shared reference
 415   --> $DIR/simple.rs:262:37
 416    |
 417 LL |     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
 423 error[E0507]: cannot move out of a shared reference
 424   --> $DIR/simple.rs:264:11
 425    |
 426 LL |     match (&e.clone(),) {
 427    |           ^^^^^^^^^^^^^
 428 LL |
 429 LL |         (&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
 435 error[E0507]: cannot move out of a mutable reference
 436   --> $DIR/simple.rs:272:25
 437    |
 438 LL |     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
 444 error[E0507]: cannot move out of a mutable reference
 445   --> $DIR/simple.rs:274:38
 446    |
 447 LL |     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
 453 error[E0507]: cannot move out of a mutable reference
 454   --> $DIR/simple.rs:276:41
 455    |
 456 LL |     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
 462 error[E0507]: cannot move out of a mutable reference
 463   --> $DIR/simple.rs:278:11
 464    |
 465 LL |     match (&mut em.clone(),) {
 466    |           ^^^^^^^^^^^^^^^^^^
 467 LL |
 468 LL |         (&mut Either::One(_t),) => (),
 469    |                           -- data moved here
 470 LL |         (&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   --> $DIR/simple.rs:280:27
 475    |
 476 LL |         (&mut Either::One(_t),) => (),
 477    |                           ^^
 478 LL |         (&mut Either::Two(_t),) => (),
 479    |                           ^^
 480
 481 error[E0507]: cannot move out of a shared reference
 482   --> $DIR/simple.rs:288:18
 483    |
 484 LL |     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
 491 error[E0507]: cannot move out of a shared reference
 492   --> $DIR/simple.rs:292:31
 493    |
 494 LL |     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
 501 error[E0507]: cannot move out of a shared reference
 502   --> $DIR/simple.rs:296:34
 503    |
 504 LL |     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
 511 error[E0507]: cannot move out of a shared reference
 512   --> $DIR/simple.rs:300:11
 513    |
 514 LL |     match &e {
 515    |           ^^
 516 LL |
 517 LL |         &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
 524 error[E0507]: cannot move out of a shared reference
 525   --> $DIR/simple.rs:308:11
 526    |
 527 LL |     match &e {
 528    |           ^^
 529 LL |
 530 LL |         &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
 537 error[E0507]: cannot move out of a shared reference
 538   --> $DIR/simple.rs:315:11
 539    |
 540 LL |     match &e {
 541    |           ^^
 542 LL |
 543 LL |         &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
 550 error[E0507]: cannot move out of a mutable reference
 551   --> $DIR/simple.rs:323:22
 552    |
 553 LL |     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
 560 error[E0507]: cannot move out of a mutable reference
 561   --> $DIR/simple.rs:327:35
 562    |
 563 LL |     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
 570 error[E0507]: cannot move out of a mutable reference
 571   --> $DIR/simple.rs:331:38
 572    |
 573 LL |     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
 580 error[E0507]: cannot move out of a mutable reference
 581   --> $DIR/simple.rs:335:11
 582    |
 583 LL |     match &mut em {
 584    |           ^^^^^^^
 585 LL |
 586 LL |         &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
 593 error[E0507]: cannot move out of a mutable reference
 594   --> $DIR/simple.rs:343:11
 595    |
 596 LL |     match &mut em {
 597    |           ^^^^^^^
 598 LL |
 599 LL |         &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
 606 error[E0507]: cannot move out of a mutable reference
 607   --> $DIR/simple.rs:350:11
 608    |
 609 LL |     match &mut em {
 610    |           ^^^^^^^
 611 LL |
 612 LL |         &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
 619 error[E0507]: cannot move out of a mutable reference
 620   --> $DIR/simple.rs:357:11
 621    |
 622 LL |     match &mut em {
 623    |           ^^^^^^^
 624 LL |
 625 LL |         &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
 632 error[E0507]: cannot move out of a shared reference
 633   --> $DIR/simple.rs:202:11
 634    |
 635 LL |     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
 642 error[E0507]: cannot move out of a mutable reference
 643   --> $DIR/simple.rs:249:11
 644    |
 645 LL |     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
 652 error[E0507]: cannot move out of a shared reference
 653   --> $DIR/simple.rs:269:11
 654    |
 655 LL |     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
 661 error[E0507]: cannot move out of a mutable reference
 662   --> $DIR/simple.rs:283:11
 663    |
 664 LL |     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
 670 error: aborting due to 60 previous errors
 671
 672 For more information about this error, try `rustc --explain E0507`.