New upstream version 1.56.0~beta.4+dfsg1

[rustc.git] / src / test / ui / suggestions / dont-suggest-ref / simple.stderr

error[E0507]: cannot move out of `s.0` which is behind a shared reference
  --> $DIR/simple.rs:38:17
   |
LL |     let X(_t) = *s;
   |           --    ^^ help: consider borrowing here: `&*s`
   |           |
   |           data moved here
   |           move occurs because `_t` has type `Y`, which does not implement the `Copy` trait

error[E0507]: cannot move out of `r.0` which is behind a shared reference
  --> $DIR/simple.rs:42:30
   |
LL |     if let Either::One(_t) = *r { }
   |                        --    ^^ help: consider borrowing here: `&*r`
   |                        |
   |                        data moved here
   |                        move occurs because `_t` has type `X`, which does not implement the `Copy` trait

error[E0507]: cannot move out of `r.0` which is behind a shared reference
  --> $DIR/simple.rs:46:33
   |
LL |     while let Either::One(_t) = *r { }
   |                           --    ^^ help: consider borrowing here: `&*r`
   |                           |
   |                           data moved here
   |                           move occurs because `_t` has type `X`, which does not implement the `Copy` trait

error[E0507]: cannot move out of `r.0` which is behind a shared reference
  --> $DIR/simple.rs:50:11
   |
LL |     match *r {
   |           ^^ help: consider borrowing here: `&*r`
...
LL |         Either::One(_t)
   |                     --
   |                     |
   |                     data moved here
   |                     move occurs because `_t` has type `X`, which does not implement the `Copy` trait

error[E0507]: cannot move out of `r.0` which is behind a shared reference
  --> $DIR/simple.rs:57:11
   |
LL |     match *r {
   |           ^^ help: consider borrowing here: `&*r`
...
LL |         Either::One(_t) => (),
   |                     --
   |                     |
   |                     data moved here
   |                     move occurs because `_t` has type `X`, which does not implement the `Copy` trait

error[E0507]: cannot move out of `sm.0` which is behind a mutable reference
  --> $DIR/simple.rs:66:17
   |
LL |     let X(_t) = *sm;
   |           --    ^^^ help: consider borrowing here: `&*sm`
   |           |
   |           data moved here
   |           move occurs because `_t` has type `Y`, which does not implement the `Copy` trait

error[E0507]: cannot move out of `rm.0` which is behind a mutable reference
  --> $DIR/simple.rs:70:30
   |
LL |     if let Either::One(_t) = *rm { }
   |                        --    ^^^ help: consider borrowing here: `&*rm`
   |                        |
   |                        data moved here
   |                        move occurs because `_t` has type `X`, which does not implement the `Copy` trait

error[E0507]: cannot move out of `rm.0` which is behind a mutable reference
  --> $DIR/simple.rs:74:33
   |
LL |     while let Either::One(_t) = *rm { }
   |                           --    ^^^ help: consider borrowing here: `&*rm`
   |                           |
   |                           data moved here
   |                           move occurs because `_t` has type `X`, which does not implement the `Copy` trait

error[E0507]: cannot move out of `rm.0` which is behind a mutable reference
  --> $DIR/simple.rs:78:11
   |
LL |     match *rm {
   |           ^^^ help: consider borrowing here: `&*rm`
...
LL |         Either::One(_t)
   |                     --
   |                     |
   |                     data moved here
   |                     move occurs because `_t` has type `X`, which does not implement the `Copy` trait

error[E0507]: cannot move out of `rm.0` which is behind a mutable reference
  --> $DIR/simple.rs:85:11
   |
LL |     match *rm {
   |           ^^^ help: consider borrowing here: `&*rm`
...
LL |         Either::One(_t) => (),
   |                     --
   |                     |
   |                     data moved here
   |                     move occurs because `_t` has type `X`, which does not implement the `Copy` trait

error[E0507]: cannot move out of `rm.0` which is behind a mutable reference
  --> $DIR/simple.rs:93:11
   |
LL |     match *rm {
   |           ^^^ help: consider borrowing here: `&*rm`
...
LL |         Either::One(_t) => (),
   |                     --
   |                     |
   |                     data moved here
   |                     move occurs because `_t` has type `X`, which does not implement the `Copy` trait

error[E0507]: cannot move out of index of `Vec<X>`
  --> $DIR/simple.rs:102:17
   |
LL |     let X(_t) = vs[0];
   |           --    ^^^^^ help: consider borrowing here: `&vs[0]`
   |           |
   |           data moved here
   |           move occurs because `_t` has type `Y`, which does not implement the `Copy` trait

error[E0507]: cannot move out of index of `Vec<Either>`
  --> $DIR/simple.rs:106:30
   |
LL |     if let Either::One(_t) = vr[0] { }
   |                        --    ^^^^^ help: consider borrowing here: `&vr[0]`
   |                        |
   |                        data moved here
   |                        move occurs because `_t` has type `X`, which does not implement the `Copy` trait

error[E0507]: cannot move out of index of `Vec<Either>`
  --> $DIR/simple.rs:110:33
   |
LL |     while let Either::One(_t) = vr[0] { }
   |                           --    ^^^^^ help: consider borrowing here: `&vr[0]`
   |                           |
   |                           data moved here
   |                           move occurs because `_t` has type `X`, which does not implement the `Copy` trait

error[E0507]: cannot move out of index of `Vec<Either>`
  --> $DIR/simple.rs:114:11
   |
LL |     match vr[0] {
   |           ^^^^^ help: consider borrowing here: `&vr[0]`
...
LL |         Either::One(_t)
   |                     --
   |                     |
   |                     data moved here
   |                     move occurs because `_t` has type `X`, which does not implement the `Copy` trait

error[E0507]: cannot move out of index of `Vec<Either>`
  --> $DIR/simple.rs:121:11
   |
LL |     match vr[0] {
   |           ^^^^^ help: consider borrowing here: `&vr[0]`
...
LL |         Either::One(_t) => (),
   |                     --
   |                     |
   |                     data moved here
   |                     move occurs because `_t` has type `X`, which does not implement the `Copy` trait

error[E0507]: cannot move out of index of `Vec<X>`
  --> $DIR/simple.rs:130:17
   |
LL |     let X(_t) = vsm[0];
   |           --    ^^^^^^ help: consider borrowing here: `&vsm[0]`
   |           |
   |           data moved here
   |           move occurs because `_t` has type `Y`, which does not implement the `Copy` trait

error[E0507]: cannot move out of index of `Vec<Either>`
  --> $DIR/simple.rs:134:30
   |
LL |     if let Either::One(_t) = vrm[0] { }
   |                        --    ^^^^^^ help: consider borrowing here: `&vrm[0]`
   |                        |
   |                        data moved here
   |                        move occurs because `_t` has type `X`, which does not implement the `Copy` trait

error[E0507]: cannot move out of index of `Vec<Either>`
  --> $DIR/simple.rs:138:33
   |
LL |     while let Either::One(_t) = vrm[0] { }
   |                           --    ^^^^^^ help: consider borrowing here: `&vrm[0]`
   |                           |
   |                           data moved here
   |                           move occurs because `_t` has type `X`, which does not implement the `Copy` trait

error[E0507]: cannot move out of index of `Vec<Either>`
  --> $DIR/simple.rs:142:11
   |
LL |     match vrm[0] {
   |           ^^^^^^ help: consider borrowing here: `&vrm[0]`
...
LL |         Either::One(_t)
   |                     --
   |                     |
   |                     data moved here
   |                     move occurs because `_t` has type `X`, which does not implement the `Copy` trait

error[E0507]: cannot move out of index of `Vec<Either>`
  --> $DIR/simple.rs:149:11
   |
LL |     match vrm[0] {
   |           ^^^^^^ help: consider borrowing here: `&vrm[0]`
...
LL |         Either::One(_t) => (),
   |                     --
   |                     |
   |                     data moved here
   |                     move occurs because `_t` has type `X`, which does not implement the `Copy` trait

error[E0507]: cannot move out of index of `Vec<Either>`
  --> $DIR/simple.rs:157:11
   |
LL |     match vrm[0] {
   |           ^^^^^^ help: consider borrowing here: `&vrm[0]`
...
LL |         Either::One(_t) => (),
   |                     --
   |                     |
   |                     data moved here
   |                     move occurs because `_t` has type `X`, which does not implement the `Copy` trait

error[E0507]: cannot move out of `s.0` which is behind a shared reference
  --> $DIR/simple.rs:168:18
   |
LL |     let &X(_t) = s;
   |         ------   ^
   |         |  |
   |         |  data moved here
   |         |  move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
   |         help: consider removing the `&`: `X(_t)`

error[E0507]: cannot move out of `r.0` which is behind a shared reference
  --> $DIR/simple.rs:172:31
   |
LL |     if let &Either::One(_t) = r { }
   |            ----------------   ^
   |            |            |
   |            |            data moved here
   |            |            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
   |            help: consider removing the `&`: `Either::One(_t)`

error[E0507]: cannot move out of `r.0` which is behind a shared reference
  --> $DIR/simple.rs:176:34
   |
LL |     while let &Either::One(_t) = r { }
   |               ----------------   ^
   |               |            |
   |               |            data moved here
   |               |            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
   |               help: consider removing the `&`: `Either::One(_t)`

error[E0507]: cannot move out of `r.0` which is behind a shared reference
  --> $DIR/simple.rs:180:11
   |
LL |     match r {
   |           ^
LL |
LL |         &Either::One(_t)
   |                      --
   |                      |
   |                      data moved here
   |                      move occurs because `_t` has type `X`, which does not implement the `Copy` trait
   |
help: consider removing the `&`
   |
LL ~         Either::One(_t)
LL +
LL +
LL ~         | &Either::Two(_t) => (),
   |

error[E0507]: cannot move out of `r.0` which is behind a shared reference
  --> $DIR/simple.rs:188:11
   |
LL |     match r {
   |           ^
LL |
LL |         &Either::One(_t) => (),
   |         ----------------
   |         |            |
   |         |            data moved here
   |         |            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
   |         help: consider removing the `&`: `Either::One(_t)`

error[E0507]: cannot move out of `r.0` which is behind a shared reference
  --> $DIR/simple.rs:195:11
   |
LL |     match r {
   |           ^
LL |
LL |         &Either::One(_t) => (),
   |         ----------------
   |         |            |
   |         |            data moved here
   |         |            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
   |         help: consider removing the `&`: `Either::One(_t)`

error[E0507]: cannot move out of `sm.0` which is behind a mutable reference
  --> $DIR/simple.rs:207:22
   |
LL |     let &mut X(_t) = sm;
   |         ----------   ^^
   |         |      |
   |         |      data moved here
   |         |      move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
   |         help: consider removing the `&mut`: `X(_t)`

error[E0507]: cannot move out of `rm.0` which is behind a mutable reference
  --> $DIR/simple.rs:211:35
   |
LL |     if let &mut Either::One(_t) = rm { }
   |            --------------------   ^^
   |            |                |
   |            |                data moved here
   |            |                move occurs because `_t` has type `X`, which does not implement the `Copy` trait
   |            help: consider removing the `&mut`: `Either::One(_t)`

error[E0507]: cannot move out of `rm.0` which is behind a mutable reference
  --> $DIR/simple.rs:215:38
   |
LL |     while let &mut Either::One(_t) = rm { }
   |               --------------------   ^^
   |               |                |
   |               |                data moved here
   |               |                move occurs because `_t` has type `X`, which does not implement the `Copy` trait
   |               help: consider removing the `&mut`: `Either::One(_t)`

error[E0507]: cannot move out of `rm.0` which is behind a mutable reference
  --> $DIR/simple.rs:219:11
   |
LL |     match rm {
   |           ^^
LL |
LL |         &mut Either::One(_t) => (),
   |                          -- data moved here
...
LL |         &mut Either::Two(_t) => (),
   |                          -- ...and here
   |
   = note: move occurs because these variables have types that don't implement the `Copy` trait
help: consider removing the `&mut`
   |
LL |         Either::One(_t) => (),
   |         ~~~~~~~~~~~~~~~
help: consider removing the `&mut`
   |
LL |         Either::Two(_t) => (),
   |         ~~~~~~~~~~~~~~~

error[E0507]: cannot move out of `rm.0` which is behind a mutable reference
  --> $DIR/simple.rs:228:11
   |
LL |     match rm {
   |           ^^
LL |
LL |         &mut Either::One(_t) => (),
   |         --------------------
   |         |                |
   |         |                data moved here
   |         |                move occurs because `_t` has type `X`, which does not implement the `Copy` trait
   |         help: consider removing the `&mut`: `Either::One(_t)`

error[E0507]: cannot move out of `rm.0` which is behind a mutable reference
  --> $DIR/simple.rs:235:11
   |
LL |     match rm {
   |           ^^
LL |
LL |         &mut Either::One(_t) => (),
   |         --------------------
   |         |                |
   |         |                data moved here
   |         |                move occurs because `_t` has type `X`, which does not implement the `Copy` trait
   |         help: consider removing the `&mut`: `Either::One(_t)`

error[E0507]: cannot move out of `rm.0` which is behind a mutable reference
  --> $DIR/simple.rs:242:11
   |
LL |     match rm {
   |           ^^
LL |
LL |         &mut Either::One(_t) => (),
   |         --------------------
   |         |                |
   |         |                data moved here
   |         |                move occurs because `_t` has type `X`, which does not implement the `Copy` trait
   |         help: consider removing the `&mut`: `Either::One(_t)`

error[E0507]: cannot move out of a shared reference
  --> $DIR/simple.rs:258:21
   |
LL |     let (&X(_t),) = (&x.clone(),);
   |             --      ^^^^^^^^^^^^^
   |             |
   |             data moved here
   |             move occurs because `_t` has type `Y`, which does not implement the `Copy` trait

error[E0507]: cannot move out of a shared reference
  --> $DIR/simple.rs:260:34
   |
LL |     if let (&Either::One(_t),) = (&e.clone(),) { }
   |                          --      ^^^^^^^^^^^^^
   |                          |
   |                          data moved here
   |                          move occurs because `_t` has type `X`, which does not implement the `Copy` trait

error[E0507]: cannot move out of a shared reference
  --> $DIR/simple.rs:262:37
   |
LL |     while let (&Either::One(_t),) = (&e.clone(),) { }
   |                             --      ^^^^^^^^^^^^^
   |                             |
   |                             data moved here
   |                             move occurs because `_t` has type `X`, which does not implement the `Copy` trait

error[E0507]: cannot move out of a shared reference
  --> $DIR/simple.rs:264:11
   |
LL |     match (&e.clone(),) {
   |           ^^^^^^^^^^^^^
LL |
LL |         (&Either::One(_t),)
   |                       --
   |                       |
   |                       data moved here
   |                       move occurs because `_t` has type `X`, which does not implement the `Copy` trait

error[E0507]: cannot move out of a mutable reference
  --> $DIR/simple.rs:272:25
   |
LL |     let (&mut X(_t),) = (&mut xm.clone(),);
   |                 --      ^^^^^^^^^^^^^^^^^^
   |                 |
   |                 data moved here
   |                 move occurs because `_t` has type `Y`, which does not implement the `Copy` trait

error[E0507]: cannot move out of a mutable reference
  --> $DIR/simple.rs:274:38
   |
LL |     if let (&mut Either::One(_t),) = (&mut em.clone(),) { }
   |                              --      ^^^^^^^^^^^^^^^^^^
   |                              |
   |                              data moved here
   |                              move occurs because `_t` has type `X`, which does not implement the `Copy` trait

error[E0507]: cannot move out of a mutable reference
  --> $DIR/simple.rs:276:41
   |
LL |     while let (&mut Either::One(_t),) = (&mut em.clone(),) { }
   |                                 --      ^^^^^^^^^^^^^^^^^^
   |                                 |
   |                                 data moved here
   |                                 move occurs because `_t` has type `X`, which does not implement the `Copy` trait

error[E0507]: cannot move out of a mutable reference
  --> $DIR/simple.rs:278:11
   |
LL |     match (&mut em.clone(),) {
   |           ^^^^^^^^^^^^^^^^^^
LL |
LL |         (&mut Either::One(_t),) => (),
   |                           -- data moved here
LL |         (&mut Either::Two(_t),) => (),
   |                           -- ...and here
   |
   = note: move occurs because these variables have types that don't implement the `Copy` trait

error[E0507]: cannot move out of a shared reference
  --> $DIR/simple.rs:288:18
   |
LL |     let &X(_t) = &x;
   |         ------   ^^
   |         |  |
   |         |  data moved here
   |         |  move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
   |         help: consider removing the `&`: `X(_t)`

error[E0507]: cannot move out of a shared reference
  --> $DIR/simple.rs:292:31
   |
LL |     if let &Either::One(_t) = &e { }
   |            ----------------   ^^
   |            |            |
   |            |            data moved here
   |            |            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
   |            help: consider removing the `&`: `Either::One(_t)`

error[E0507]: cannot move out of a shared reference
  --> $DIR/simple.rs:296:34
   |
LL |     while let &Either::One(_t) = &e { }
   |               ----------------   ^^
   |               |            |
   |               |            data moved here
   |               |            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
   |               help: consider removing the `&`: `Either::One(_t)`

error[E0507]: cannot move out of a shared reference
  --> $DIR/simple.rs:300:11
   |
LL |     match &e {
   |           ^^
LL |
LL |         &Either::One(_t)
   |                      --
   |                      |
   |                      data moved here
   |                      move occurs because `_t` has type `X`, which does not implement the `Copy` trait
   |
help: consider removing the `&`
   |
LL ~         Either::One(_t)
LL +
LL +
LL ~         | &Either::Two(_t) => (),
   |

error[E0507]: cannot move out of a shared reference
  --> $DIR/simple.rs:308:11
   |
LL |     match &e {
   |           ^^
LL |
LL |         &Either::One(_t) => (),
   |         ----------------
   |         |            |
   |         |            data moved here
   |         |            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
   |         help: consider removing the `&`: `Either::One(_t)`

error[E0507]: cannot move out of a shared reference
  --> $DIR/simple.rs:315:11
   |
LL |     match &e {
   |           ^^
LL |
LL |         &Either::One(_t) => (),
   |         ----------------
   |         |            |
   |         |            data moved here
   |         |            move occurs because `_t` has type `X`, which does not implement the `Copy` trait
   |         help: consider removing the `&`: `Either::One(_t)`

error[E0507]: cannot move out of a mutable reference
  --> $DIR/simple.rs:323:22
   |
LL |     let &mut X(_t) = &mut xm;
   |         ----------   ^^^^^^^
   |         |      |
   |         |      data moved here
   |         |      move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
   |         help: consider removing the `&mut`: `X(_t)`

error[E0507]: cannot move out of a mutable reference
  --> $DIR/simple.rs:327:35
   |
LL |     if let &mut Either::One(_t) = &mut em { }
   |            --------------------   ^^^^^^^
   |            |                |
   |            |                data moved here
   |            |                move occurs because `_t` has type `X`, which does not implement the `Copy` trait
   |            help: consider removing the `&mut`: `Either::One(_t)`

error[E0507]: cannot move out of a mutable reference
  --> $DIR/simple.rs:331:38
   |
LL |     while let &mut Either::One(_t) = &mut em { }
   |               --------------------   ^^^^^^^
   |               |                |
   |               |                data moved here
   |               |                move occurs because `_t` has type `X`, which does not implement the `Copy` trait
   |               help: consider removing the `&mut`: `Either::One(_t)`

error[E0507]: cannot move out of a mutable reference
  --> $DIR/simple.rs:335:11
   |
LL |     match &mut em {
   |           ^^^^^^^
LL |
LL |         &mut Either::One(_t)
   |                          --
   |                          |
   |                          data moved here
   |                          move occurs because `_t` has type `X`, which does not implement the `Copy` trait
   |
help: consider removing the `&mut`
   |
LL ~         Either::One(_t)
LL +
LL +
LL ~         | &mut Either::Two(_t) => (),
   |

error[E0507]: cannot move out of a mutable reference
  --> $DIR/simple.rs:343:11
   |
LL |     match &mut em {
   |           ^^^^^^^
LL |
LL |         &mut Either::One(_t) => (),
   |         --------------------
   |         |                |
   |         |                data moved here
   |         |                move occurs because `_t` has type `X`, which does not implement the `Copy` trait
   |         help: consider removing the `&mut`: `Either::One(_t)`

error[E0507]: cannot move out of a mutable reference
  --> $DIR/simple.rs:350:11
   |
LL |     match &mut em {
   |           ^^^^^^^
LL |
LL |         &mut Either::One(_t) => (),
   |         --------------------
   |         |                |
   |         |                data moved here
   |         |                move occurs because `_t` has type `X`, which does not implement the `Copy` trait
   |         help: consider removing the `&mut`: `Either::One(_t)`

error[E0507]: cannot move out of a mutable reference
  --> $DIR/simple.rs:357:11
   |
LL |     match &mut em {
   |           ^^^^^^^
LL |
LL |         &mut Either::One(_t) => (),
   |         --------------------
   |         |                |
   |         |                data moved here
   |         |                move occurs because `_t` has type `X`, which does not implement the `Copy` trait
   |         help: consider removing the `&mut`: `Either::One(_t)`

error[E0507]: cannot move out of a shared reference
  --> $DIR/simple.rs:202:11
   |
LL |     fn f1(&X(_t): &X) { }
   |           ^^^--^
   |           |  |
   |           |  data moved here
   |           |  move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
   |           help: consider removing the `&`: `X(_t)`

error[E0507]: cannot move out of a mutable reference
  --> $DIR/simple.rs:249:11
   |
LL |     fn f2(&mut X(_t): &mut X) { }
   |           ^^^^^^^--^
   |           |      |
   |           |      data moved here
   |           |      move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
   |           help: consider removing the `&mut`: `X(_t)`

error[E0507]: cannot move out of a shared reference
  --> $DIR/simple.rs:269:11
   |
LL |     fn f3((&X(_t),): (&X,)) { }
   |           ^^^^--^^^
   |               |
   |               data moved here
   |               move occurs because `_t` has type `Y`, which does not implement the `Copy` trait

error[E0507]: cannot move out of a mutable reference
  --> $DIR/simple.rs:283:11
   |
LL |     fn f4((&mut X(_t),): (&mut X,)) { }
   |           ^^^^^^^^--^^^
   |                   |
   |                   data moved here
   |                   move occurs because `_t` has type `Y`, which does not implement the `Copy` trait

error: aborting due to 60 previous errors

For more information about this error, try `rustc --explain E0507`.