rust/src/test/ui/suggestions/dont-suggest-ref/move-into-closure.stderr

error[E0507]: cannot move out of captured variable in an `Fn` closure
  --> $DIR/move-into-closure.rs:30:21
   |
LL |     let x = X(Y);
   |         - captured outer variable
...
LL |         let X(_t) = x;
   |               --    ^
   |               |     |
   |               |     cannot move out of captured variable in an `Fn` closure
   |               |     help: consider borrowing here: `&x`
   |               data moved here
   |
note: move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
  --> $DIR/move-into-closure.rs:30:15
   |
LL |         let X(_t) = x;
   |               ^^

error[E0507]: cannot move out of captured variable in an `Fn` closure
  --> $DIR/move-into-closure.rs:34:34
   |
LL |     let e = Either::One(X(Y));
   |         - captured outer variable
...
LL |         if let Either::One(_t) = e { }
   |                            --    ^
   |                            |     |
   |                            |     cannot move out of captured variable in an `Fn` closure
   |                            |     help: consider borrowing here: `&e`
   |                            data moved here
   |
note: move occurs because `_t` has type `X`, which does not implement the `Copy` trait
  --> $DIR/move-into-closure.rs:34:28
   |
LL |         if let Either::One(_t) = e { }
   |                            ^^

error[E0507]: cannot move out of captured variable in an `Fn` closure
  --> $DIR/move-into-closure.rs:38:37
   |
LL |     let e = Either::One(X(Y));
   |         - captured outer variable
...
LL |         while let Either::One(_t) = e { }
   |                               --    ^
   |                               |     |
   |                               |     cannot move out of captured variable in an `Fn` closure
   |                               |     help: consider borrowing here: `&e`
   |                               data moved here
   |
note: move occurs because `_t` has type `X`, which does not implement the `Copy` trait
  --> $DIR/move-into-closure.rs:38:31
   |
LL |         while let Either::One(_t) = e { }
   |                               ^^

error[E0507]: cannot move out of captured variable in an `Fn` closure
  --> $DIR/move-into-closure.rs:42:15
   |
LL |     let e = Either::One(X(Y));
   |         - captured outer variable
...
LL |         match e {
   |               ^
   |               |
   |               cannot move out of captured variable in an `Fn` closure
   |               help: consider borrowing here: `&e`
...
LL |             Either::One(_t)
   |                         -- data moved here
   |
note: move occurs because `_t` has type `X`, which does not implement the `Copy` trait
  --> $DIR/move-into-closure.rs:46:25
   |
LL |             Either::One(_t)
   |                         ^^

error[E0507]: cannot move out of captured variable in an `Fn` closure
  --> $DIR/move-into-closure.rs:49:15
   |
LL |     let e = Either::One(X(Y));
   |         - captured outer variable
...
LL |         match e {
   |               ^
   |               |
   |               cannot move out of captured variable in an `Fn` closure
   |               help: consider borrowing here: `&e`
...
LL |             Either::One(_t) => (),
   |                         -- data moved here
   |
note: move occurs because `_t` has type `X`, which does not implement the `Copy` trait
  --> $DIR/move-into-closure.rs:53:25
   |
LL |             Either::One(_t) => (),
   |                         ^^

error[E0507]: cannot move out of captured variable in an `Fn` closure
  --> $DIR/move-into-closure.rs:58:25
   |
LL |     let x = X(Y);
   |         - captured outer variable
...
LL |         let X(mut _t) = x;
   |               ------    ^
   |               |         |
   |               |         cannot move out of captured variable in an `Fn` closure
   |               |         help: consider borrowing here: `&x`
   |               data moved here
   |
note: move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
  --> $DIR/move-into-closure.rs:58:15
   |
LL |         let X(mut _t) = x;
   |               ^^^^^^

error[E0507]: cannot move out of captured variable in an `Fn` closure
  --> $DIR/move-into-closure.rs:62:38
   |
LL |     let mut em = Either::One(X(Y));
   |         ------ captured outer variable
...
LL |         if let Either::One(mut _t) = em { }
   |                            ------    ^^
   |                            |         |
   |                            |         cannot move out of captured variable in an `Fn` closure
   |                            |         help: consider borrowing here: `&em`
   |                            data moved here
   |
note: move occurs because `_t` has type `X`, which does not implement the `Copy` trait
  --> $DIR/move-into-closure.rs:62:28
   |
LL |         if let Either::One(mut _t) = em { }
   |                            ^^^^^^

error[E0507]: cannot move out of captured variable in an `Fn` closure
  --> $DIR/move-into-closure.rs:66:41
   |
LL |     let mut em = Either::One(X(Y));
   |         ------ captured outer variable
...
LL |         while let Either::One(mut _t) = em { }
   |                               ------    ^^
   |                               |         |
   |                               |         cannot move out of captured variable in an `Fn` closure
   |                               |         help: consider borrowing here: `&em`
   |                               data moved here
   |
note: move occurs because `_t` has type `X`, which does not implement the `Copy` trait
  --> $DIR/move-into-closure.rs:66:31
   |
LL |         while let Either::One(mut _t) = em { }
   |                               ^^^^^^

error[E0507]: cannot move out of captured variable in an `Fn` closure
  --> $DIR/move-into-closure.rs:70:15
   |
LL |     let mut em = Either::One(X(Y));
   |         ------ captured outer variable
...
LL |         match em {
   |               ^^
   |               |
   |               cannot move out of captured variable in an `Fn` closure
   |               help: consider borrowing here: `&em`
...
LL |             Either::One(mut _t)
   |                         ------ data moved here
   |
note: move occurs because `_t` has type `X`, which does not implement the `Copy` trait
  --> $DIR/move-into-closure.rs:74:25
   |
LL |             Either::One(mut _t)
   |                         ^^^^^^

error[E0507]: cannot move out of captured variable in an `Fn` closure
  --> $DIR/move-into-closure.rs:77:15
   |
LL |     let mut em = Either::One(X(Y));
   |         ------ captured outer variable
...
LL |         match em {
   |               ^^
   |               |
   |               cannot move out of captured variable in an `Fn` closure
   |               help: consider borrowing here: `&em`
...
LL |             Either::One(mut _t) => (),
   |                         ------ data moved here
   |
note: move occurs because `_t` has type `X`, which does not implement the `Copy` trait
  --> $DIR/move-into-closure.rs:81:25
   |
LL |             Either::One(mut _t) => (),
   |                         ^^^^^^

error[E0507]: cannot move out of captured variable in an `FnMut` closure
  --> $DIR/move-into-closure.rs:97:21
   |
LL |     let x = X(Y);
   |         - captured outer variable
...
LL |         let X(_t) = x;
   |               --    ^
   |               |     |
   |               |     cannot move out of captured variable in an `FnMut` closure
   |               |     help: consider borrowing here: `&x`
   |               data moved here
   |
note: move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
  --> $DIR/move-into-closure.rs:97:15
   |
LL |         let X(_t) = x;
   |               ^^

error[E0507]: cannot move out of captured variable in an `FnMut` closure
  --> $DIR/move-into-closure.rs:101:34
   |
LL |     let e = Either::One(X(Y));
   |         - captured outer variable
...
LL |         if let Either::One(_t) = e { }
   |                            --    ^
   |                            |     |
   |                            |     cannot move out of captured variable in an `FnMut` closure
   |                            |     help: consider borrowing here: `&e`
   |                            data moved here
   |
note: move occurs because `_t` has type `X`, which does not implement the `Copy` trait
  --> $DIR/move-into-closure.rs:101:28
   |
LL |         if let Either::One(_t) = e { }
   |                            ^^

error[E0507]: cannot move out of captured variable in an `FnMut` closure
  --> $DIR/move-into-closure.rs:105:37
   |
LL |     let e = Either::One(X(Y));
   |         - captured outer variable
...
LL |         while let Either::One(_t) = e { }
   |                               --    ^
   |                               |     |
   |                               |     cannot move out of captured variable in an `FnMut` closure
   |                               |     help: consider borrowing here: `&e`
   |                               data moved here
   |
note: move occurs because `_t` has type `X`, which does not implement the `Copy` trait
  --> $DIR/move-into-closure.rs:105:31
   |
LL |         while let Either::One(_t) = e { }
   |                               ^^

error[E0507]: cannot move out of captured variable in an `FnMut` closure
  --> $DIR/move-into-closure.rs:109:15
   |
LL |     let e = Either::One(X(Y));
   |         - captured outer variable
...
LL |         match e {
   |               ^
   |               |
   |               cannot move out of captured variable in an `FnMut` closure
   |               help: consider borrowing here: `&e`
...
LL |             Either::One(_t)
   |                         -- data moved here
   |
note: move occurs because `_t` has type `X`, which does not implement the `Copy` trait
  --> $DIR/move-into-closure.rs:113:25
   |
LL |             Either::One(_t)
   |                         ^^

error[E0507]: cannot move out of captured variable in an `FnMut` closure
  --> $DIR/move-into-closure.rs:116:15
   |
LL |     let e = Either::One(X(Y));
   |         - captured outer variable
...
LL |         match e {
   |               ^
   |               |
   |               cannot move out of captured variable in an `FnMut` closure
   |               help: consider borrowing here: `&e`
...
LL |             Either::One(_t) => (),
   |                         -- data moved here
   |
note: move occurs because `_t` has type `X`, which does not implement the `Copy` trait
  --> $DIR/move-into-closure.rs:120:25
   |
LL |             Either::One(_t) => (),
   |                         ^^

error[E0507]: cannot move out of captured variable in an `FnMut` closure
  --> $DIR/move-into-closure.rs:125:25
   |
LL |     let x = X(Y);
   |         - captured outer variable
...
LL |         let X(mut _t) = x;
   |               ------    ^
   |               |         |
   |               |         cannot move out of captured variable in an `FnMut` closure
   |               |         help: consider borrowing here: `&x`
   |               data moved here
   |
note: move occurs because `_t` has type `Y`, which does not implement the `Copy` trait
  --> $DIR/move-into-closure.rs:125:15
   |
LL |         let X(mut _t) = x;
   |               ^^^^^^

error[E0507]: cannot move out of captured variable in an `FnMut` closure
  --> $DIR/move-into-closure.rs:129:38
   |
LL |     let mut em = Either::One(X(Y));
   |         ------ captured outer variable
...
LL |         if let Either::One(mut _t) = em { }
   |                            ------    ^^
   |                            |         |
   |                            |         cannot move out of captured variable in an `FnMut` closure
   |                            |         help: consider borrowing here: `&em`
   |                            data moved here
   |
note: move occurs because `_t` has type `X`, which does not implement the `Copy` trait
  --> $DIR/move-into-closure.rs:129:28
   |
LL |         if let Either::One(mut _t) = em { }
   |                            ^^^^^^

error[E0507]: cannot move out of captured variable in an `FnMut` closure
  --> $DIR/move-into-closure.rs:133:41
   |
LL |     let mut em = Either::One(X(Y));
   |         ------ captured outer variable
...
LL |         while let Either::One(mut _t) = em { }
   |                               ------    ^^
   |                               |         |
   |                               |         cannot move out of captured variable in an `FnMut` closure
   |                               |         help: consider borrowing here: `&em`
   |                               data moved here
   |
note: move occurs because `_t` has type `X`, which does not implement the `Copy` trait
  --> $DIR/move-into-closure.rs:133:31
   |
LL |         while let Either::One(mut _t) = em { }
   |                               ^^^^^^

error[E0507]: cannot move out of captured variable in an `FnMut` closure
  --> $DIR/move-into-closure.rs:137:15
   |
LL |     let mut em = Either::One(X(Y));
   |         ------ captured outer variable
...
LL |         match em {
   |               ^^
   |               |
   |               cannot move out of captured variable in an `FnMut` closure
   |               help: consider borrowing here: `&em`
...
LL |             Either::One(mut _t)
   |                         ------ data moved here
   |
note: move occurs because `_t` has type `X`, which does not implement the `Copy` trait
  --> $DIR/move-into-closure.rs:141:25
   |
LL |             Either::One(mut _t)
   |                         ^^^^^^

error[E0507]: cannot move out of captured variable in an `FnMut` closure
  --> $DIR/move-into-closure.rs:144:15
   |
LL |     let mut em = Either::One(X(Y));
   |         ------ captured outer variable
...
LL |         match em {
   |               ^^
   |               |
   |               cannot move out of captured variable in an `FnMut` closure
   |               help: consider borrowing here: `&em`
...
LL |             Either::One(mut _t) => (),
   |                         ------ data moved here
   |
note: move occurs because `_t` has type `X`, which does not implement the `Copy` trait
  --> $DIR/move-into-closure.rs:148:25
   |
LL |             Either::One(mut _t) => (),
   |                         ^^^^^^

error[E0507]: cannot move out of captured variable in an `FnMut` closure
  --> $DIR/move-into-closure.rs:152:15
   |
LL |     let mut em = Either::One(X(Y));
   |         ------ captured outer variable
...
LL |         match em {
   |               ^^
   |               |
   |               cannot move out of captured variable in an `FnMut` closure
   |               help: consider borrowing here: `&em`
...
LL |             Either::One(mut _t) => (),
   |                         ------ data moved here
   |
note: move occurs because `_t` has type `X`, which does not implement the `Copy` trait
  --> $DIR/move-into-closure.rs:156:25
   |
LL |             Either::One(mut _t) => (),
   |                         ^^^^^^

error: aborting due to 21 previous errors

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