src/test/ui/pattern/bindings-after-at/borrowck-pat-by-move-and-ref-inverse.stderr - third_party/rust - Git at Google

 error: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:29:9
    |
 LL |     let a @ ref b = U;
    |         -^^^-----
    |         |   |
    |         |   value borrowed here after move
    |         value moved into `a` here
    |         move occurs because `a` has type `U` which does not implement the `Copy` trait

 error: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:31:9
    |
 LL |     let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
    |         -^^^^^^^^^^^^---------^^^^^^-----^
    |         |            |              |
    |         |            |              value borrowed here after move
    |         |            value borrowed here after move
    |         value moved into `a` here
    |         move occurs because `a` has type `(U, U)` which does not implement the `Copy` trait

 error: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:31:14
    |
 LL |     let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
    |              -----^^^---------
    |              |       |
    |              |       value borrowed here after move
    |              value moved into `b` here
    |              move occurs because `b` has type `U` which does not implement the `Copy` trait

 error: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:31:33
    |
 LL |     let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
    |                                 -^^^-----
    |                                 |   |
    |                                 |   value borrowed here after move
    |                                 value moved into `d` here
    |                                 move occurs because `d` has type `U` which does not implement the `Copy` trait

 error: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:38:9
    |
 LL |     let a @ [ref mut b, ref c] = [U, U];
    |         -^^^^---------^^-----^
    |         |    |          |
    |         |    |          value borrowed here after move
    |         |    value borrowed here after move
    |         value moved into `a` here
    |         move occurs because `a` has type `[U; 2]` which does not implement the `Copy` trait

 error: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:41:9
    |
 LL |     let a @ ref b = u();
    |         -^^^-----
    |         |   |
    |         |   value borrowed here after move
    |         value moved into `a` here
    |         move occurs because `a` has type `U` which does not implement the `Copy` trait

 error: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:44:9
    |
 LL |     let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
    |         -^^^^^^^^^^^^---------^^^^^^-----^
    |         |            |              |
    |         |            |              value borrowed here after move
    |         |            value borrowed here after move
    |         value moved into `a` here
    |         move occurs because `a` has type `(U, U)` which does not implement the `Copy` trait

 error: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:44:14
    |
 LL |     let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
    |              -----^^^---------
    |              |       |
    |              |       value borrowed here after move
    |              value moved into `b` here
    |              move occurs because `b` has type `U` which does not implement the `Copy` trait

 error: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:44:33
    |
 LL |     let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
    |                                 -^^^-----
    |                                 |   |
    |                                 |   value borrowed here after move
    |                                 value moved into `d` here
    |                                 move occurs because `d` has type `U` which does not implement the `Copy` trait

 error: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:51:9
    |
 LL |     let a @ [ref mut b, ref c] = [u(), u()];
    |         -^^^^---------^^-----^
    |         |    |          |
    |         |    |          value borrowed here after move
    |         |    value borrowed here after move
    |         value moved into `a` here
    |         move occurs because `a` has type `[U; 2]` which does not implement the `Copy` trait

 error: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:56:9
    |
 LL |         a @ Some(ref b) => {}
    |         -^^^^^^^^-----^
    |         |        |
    |         |        value borrowed here after move
    |         value moved into `a` here
    |         move occurs because `a` has type `Option<U>` which does not implement the `Copy` trait

 error: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:61:9
    |
 LL |         a @ Some((mut b @ ref mut c, d @ ref e)) => {}
    |         -^^^^^^^^^^^^^^^^^---------^^^^^^-----^^
    |         |                 |              |
    |         |                 |              value borrowed here after move
    |         |                 value borrowed here after move
    |         value moved into `a` here
    |         move occurs because `a` has type `Option<(U, U)>` which does not implement the `Copy` trait

 error: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:61:19
    |
 LL |         a @ Some((mut b @ ref mut c, d @ ref e)) => {}
    |                   -----^^^---------
    |                   |       |
    |                   |       value borrowed here after move
    |                   value moved into `b` here
    |                   move occurs because `b` has type `U` which does not implement the `Copy` trait

 error: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:61:38
    |
 LL |         a @ Some((mut b @ ref mut c, d @ ref e)) => {}
    |                                      -^^^-----
    |                                      |   |
    |                                      |   value borrowed here after move
    |                                      value moved into `d` here
    |                                      move occurs because `d` has type `U` which does not implement the `Copy` trait

 error: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:71:9
    |
 LL |         mut a @ Some([ref b, ref mut c]) => {}
    |         -----^^^^^^^^^-----^^---------^^
    |         |             |      |
    |         |             |      value borrowed here after move
    |         |             value borrowed here after move
    |         value moved into `a` here
    |         move occurs because `a` has type `Option<[U; 2]>` which does not implement the `Copy` trait

 error: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:77:9
    |
 LL |         a @ Some(ref b) => {}
    |         -^^^^^^^^-----^
    |         |        |
    |         |        value borrowed here after move
    |         value moved into `a` here
    |         move occurs because `a` has type `Option<U>` which does not implement the `Copy` trait

 error: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:83:9
    |
 LL |         a @ Some((mut b @ ref mut c, d @ ref e)) => {}
    |         -^^^^^^^^^^^^^^^^^---------^^^^^^-----^^
    |         |                 |              |
    |         |                 |              value borrowed here after move
    |         |                 value borrowed here after move
    |         value moved into `a` here
    |         move occurs because `a` has type `Option<(U, U)>` which does not implement the `Copy` trait

 error: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:83:19
    |
 LL |         a @ Some((mut b @ ref mut c, d @ ref e)) => {}
    |                   -----^^^---------
    |                   |       |
    |                   |       value borrowed here after move
    |                   value moved into `b` here
    |                   move occurs because `b` has type `U` which does not implement the `Copy` trait

 error: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:83:38
    |
 LL |         a @ Some((mut b @ ref mut c, d @ ref e)) => {}
    |                                      -^^^-----
    |                                      |   |
    |                                      |   value borrowed here after move
    |                                      value moved into `d` here
    |                                      move occurs because `d` has type `U` which does not implement the `Copy` trait

 error: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:93:9
    |
 LL |         mut a @ Some([ref b, ref mut c]) => {}
    |         -----^^^^^^^^^-----^^---------^^
    |         |             |      |
    |         |             |      value borrowed here after move
    |         |             value borrowed here after move
    |         value moved into `a` here
    |         move occurs because `a` has type `Option<[U; 2]>` which does not implement the `Copy` trait

 error: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:14:11
    |
 LL |     fn f1(a @ ref b: U) {}
    |           -^^^-----
    |           |   |
    |           |   value borrowed here after move
    |           value moved into `a` here
    |           move occurs because `a` has type `U` which does not implement the `Copy` trait

 error: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:18:11
    |
 LL |     fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
    |           -----^^^^^^^^-----^^^^^^^^^^-----^
    |           |            |              |
    |           |            |              value borrowed here after move
    |           |            value borrowed here after move
    |           value moved into `a` here
    |           move occurs because `a` has type `(U, U)` which does not implement the `Copy` trait

 error: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:18:20
    |
 LL |     fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
    |                    -^^^-----
    |                    |   |
    |                    |   value borrowed here after move
    |                    value moved into `b` here
    |                    move occurs because `b` has type `U` which does not implement the `Copy` trait

 error: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:18:31
    |
 LL |     fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
    |                               -----^^^-----
    |                               |       |
    |                               |       value borrowed here after move
    |                               value moved into `d` here
    |                               move occurs because `d` has type `U` which does not implement the `Copy` trait

 error: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:25:11
    |
 LL |     fn f3(a @ [ref mut b, ref c]: [U; 2]) {}
    |           -^^^^---------^^-----^
    |           |    |          |
    |           |    |          value borrowed here after move
    |           |    value borrowed here after move
    |           value moved into `a` here
    |           move occurs because `a` has type `[U; 2]` which does not implement the `Copy` trait

 error[E0382]: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:31:22
    |
 LL |     let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
    |              --------^^^^^^^^^
    |              |       |
    |              |       value borrowed here after move
    |              value moved here
    |
    = note: move occurs because value has type `U`, which does not implement the `Copy` trait

 error[E0382]: use of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:31:33
    |
 LL |     let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
    |         ------------------------^^^^^^^^^-   ------ move occurs because value has type `(U, U)`, which does not implement the `Copy` trait
    |         |                       |
    |         |                       value used here after move
    |         value moved here

 error[E0382]: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:31:37
    |
 LL |     let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
    |                                 ----^^^^^
    |                                 |   |
    |                                 |   value borrowed here after move
    |                                 value moved here
    |
    = note: move occurs because value has type `U`, which does not implement the `Copy` trait

 error[E0382]: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:38:25
    |
 LL |     let a @ [ref mut b, ref c] = [U, U];
    |         ----------------^^^^^-   ------ move occurs because value has type `[U; 2]`, which does not implement the `Copy` trait
    |         |               |
    |         |               value borrowed here after move
    |         value moved here

 error[E0382]: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:41:13
    |
 LL |     let a @ ref b = u();
    |         ----^^^^^   --- move occurs because value has type `U`, which does not implement the `Copy` trait
    |         |   |
    |         |   value borrowed here after move
    |         value moved here

 error[E0382]: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:44:22
    |
 LL |     let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
    |              --------^^^^^^^^^
    |              |       |
    |              |       value borrowed here after move
    |              value moved here
    |
    = note: move occurs because value has type `U`, which does not implement the `Copy` trait

 error[E0382]: use of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:44:33
    |
 LL |     let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
    |         ------------------------^^^^^^^^^-   ---------- move occurs because value has type `(U, U)`, which does not implement the `Copy` trait
    |         |                       |
    |         |                       value used here after move
    |         value moved here

 error[E0382]: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:44:37
    |
 LL |     let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
    |                                 ----^^^^^
    |                                 |   |
    |                                 |   value borrowed here after move
    |                                 value moved here
    |
    = note: move occurs because value has type `U`, which does not implement the `Copy` trait

 error[E0382]: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:51:25
    |
 LL |     let a @ [ref mut b, ref c] = [u(), u()];
    |         ----------------^^^^^-   ---------- move occurs because value has type `[U; 2]`, which does not implement the `Copy` trait
    |         |               |
    |         |               value borrowed here after move
    |         value moved here

 error[E0382]: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:61:27
    |
 LL |         a @ Some((mut b @ ref mut c, d @ ref e)) => {}
    |                   --------^^^^^^^^^
    |                   |       |
    |                   |       value borrowed here after move
    |                   value moved here
    |
    = note: move occurs because value has type `U`, which does not implement the `Copy` trait
 help: borrow this field in the pattern to avoid moving the value
    |
 LL |         a @ Some((ref mut b @ ref mut c, d @ ref e)) => {}
    |                   ^^^

 error[E0382]: use of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:61:38
    |
 LL |     match Some((U, U)) {
    |           ------------ move occurs because value has type `Option<(U, U)>`, which does not implement the `Copy` trait
 LL |         a @ Some((mut b @ ref mut c, d @ ref e)) => {}
    |         -----------------------------^^^^^^^^^--
    |         |                            |
    |         |                            value used here after move
    |         value moved here

 error[E0382]: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:61:42
    |
 LL |         a @ Some((mut b @ ref mut c, d @ ref e)) => {}
    |                                      ----^^^^^
    |                                      |   |
    |                                      |   value borrowed here after move
    |                                      value moved here
    |
    = note: move occurs because value has type `U`, which does not implement the `Copy` trait
 help: borrow this field in the pattern to avoid moving the value
    |
 LL |         a @ Some((mut b @ ref mut c, ref d @ ref e)) => {}
    |                                      ^^^

 error[E0382]: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:71:30
    |
 LL |     match Some([U, U]) {
    |           ------------ move occurs because value has type `Option<[U; 2]>`, which does not implement the `Copy` trait
 LL |         mut a @ Some([ref b, ref mut c]) => {}
    |         ---------------------^^^^^^^^^--
    |         |                    |
    |         |                    value borrowed here after move
    |         value moved here

 error[E0382]: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:77:18
    |
 LL |     match Some(u()) {
    |           --------- move occurs because value has type `Option<U>`, which does not implement the `Copy` trait
 LL |         a @ Some(ref b) => {}
    |         ---------^^^^^-
    |         |        |
    |         |        value borrowed here after move
    |         value moved here

 error[E0382]: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:83:27
    |
 LL |         a @ Some((mut b @ ref mut c, d @ ref e)) => {}
    |                   --------^^^^^^^^^
    |                   |       |
    |                   |       value borrowed here after move
    |                   value moved here
    |
    = note: move occurs because value has type `U`, which does not implement the `Copy` trait
 help: borrow this field in the pattern to avoid moving the value
    |
 LL |         a @ Some((ref mut b @ ref mut c, d @ ref e)) => {}
    |                   ^^^

 error[E0382]: use of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:83:38
    |
 LL |     match Some((u(), u())) {
    |           ---------------- move occurs because value has type `Option<(U, U)>`, which does not implement the `Copy` trait
 LL |         a @ Some((mut b @ ref mut c, d @ ref e)) => {}
    |         -----------------------------^^^^^^^^^--
    |         |                            |
    |         |                            value used here after move
    |         value moved here

 error[E0382]: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:83:42
    |
 LL |         a @ Some((mut b @ ref mut c, d @ ref e)) => {}
    |                                      ----^^^^^
    |                                      |   |
    |                                      |   value borrowed here after move
    |                                      value moved here
    |
    = note: move occurs because value has type `U`, which does not implement the `Copy` trait
 help: borrow this field in the pattern to avoid moving the value
    |
 LL |         a @ Some((mut b @ ref mut c, ref d @ ref e)) => {}
    |                                      ^^^

 error[E0382]: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:93:30
    |
 LL |     match Some([u(), u()]) {
    |           ---------------- move occurs because value has type `Option<[U; 2]>`, which does not implement the `Copy` trait
 LL |         mut a @ Some([ref b, ref mut c]) => {}
    |         ---------------------^^^^^^^^^--
    |         |                    |
    |         |                    value borrowed here after move
    |         value moved here

 error[E0382]: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:14:15
    |
 LL |     fn f1(a @ ref b: U) {}
    |           ----^^^^^
    |           |   |
    |           |   value borrowed here after move
    |           value moved here
    |           move occurs because value has type `U`, which does not implement the `Copy` trait

 error[E0382]: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:18:24
    |
 LL |     fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
    |                    ----^^^^^
    |                    |   |
    |                    |   value borrowed here after move
    |                    value moved here
    |
    = note: move occurs because value has type `U`, which does not implement the `Copy` trait

 error[E0382]: use of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:18:31
    |
 LL |     fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
    |           --------------------^^^^^^^^^^^^^-
    |           |                   |
    |           |                   value used here after move
    |           value moved here
    |           move occurs because value has type `(U, U)`, which does not implement the `Copy` trait

 error[E0382]: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:18:39
    |
 LL |     fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
    |                               --------^^^^^
    |                               |       |
    |                               |       value borrowed here after move
    |                               value moved here
    |
    = note: move occurs because value has type `U`, which does not implement the `Copy` trait

 error[E0382]: borrow of moved value
   --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:25:27
    |
 LL |     fn f3(a @ [ref mut b, ref c]: [U; 2]) {}
    |           ----------------^^^^^-
    |           |               |
    |           |               value borrowed here after move
    |           value moved here
    |           move occurs because value has type `[U; 2]`, which does not implement the `Copy` trait

 error: aborting due to 48 previous errors

 For more information about this error, try `rustc --explain E0382`.
	error: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:29:9
	\|
	LL \| let a @ ref b = U;
	\| -^^^-----
	\| \| \|
	\| \| value borrowed here after move
	\| value moved into `a` here
	\| move occurs because `a` has type `U` which does not implement the `Copy` trait

	error: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:31:9
	\|
	LL \| let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
	\| -^^^^^^^^^^^^---------^^^^^^-----^
	\| \| \| \|
	\| \| \| value borrowed here after move
	\| \| value borrowed here after move
	\| value moved into `a` here
	\| move occurs because `a` has type `(U, U)` which does not implement the `Copy` trait

	error: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:31:14
	\|
	LL \| let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
	\| -----^^^---------
	\| \| \|
	\| \| value borrowed here after move
	\| value moved into `b` here
	\| move occurs because `b` has type `U` which does not implement the `Copy` trait

	error: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:31:33
	\|
	LL \| let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
	\| -^^^-----
	\| \| \|
	\| \| value borrowed here after move
	\| value moved into `d` here
	\| move occurs because `d` has type `U` which does not implement the `Copy` trait

	error: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:38:9
	\|
	LL \| let a @ [ref mut b, ref c] = [U, U];
	\| -^^^^---------^^-----^
	\| \| \| \|
	\| \| \| value borrowed here after move
	\| \| value borrowed here after move
	\| value moved into `a` here
	\| move occurs because `a` has type `[U; 2]` which does not implement the `Copy` trait

	error: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:41:9
	\|
	LL \| let a @ ref b = u();
	\| -^^^-----
	\| \| \|
	\| \| value borrowed here after move
	\| value moved into `a` here
	\| move occurs because `a` has type `U` which does not implement the `Copy` trait

	error: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:44:9
	\|
	LL \| let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
	\| -^^^^^^^^^^^^---------^^^^^^-----^
	\| \| \| \|
	\| \| \| value borrowed here after move
	\| \| value borrowed here after move
	\| value moved into `a` here
	\| move occurs because `a` has type `(U, U)` which does not implement the `Copy` trait

	error: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:44:14
	\|
	LL \| let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
	\| -----^^^---------
	\| \| \|
	\| \| value borrowed here after move
	\| value moved into `b` here
	\| move occurs because `b` has type `U` which does not implement the `Copy` trait

	error: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:44:33
	\|
	LL \| let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
	\| -^^^-----
	\| \| \|
	\| \| value borrowed here after move
	\| value moved into `d` here
	\| move occurs because `d` has type `U` which does not implement the `Copy` trait

	error: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:51:9
	\|
	LL \| let a @ [ref mut b, ref c] = [u(), u()];
	\| -^^^^---------^^-----^
	\| \| \| \|
	\| \| \| value borrowed here after move
	\| \| value borrowed here after move
	\| value moved into `a` here
	\| move occurs because `a` has type `[U; 2]` which does not implement the `Copy` trait

	error: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:56:9
	\|
	LL \| a @ Some(ref b) => {}
	\| -^^^^^^^^-----^
	\| \| \|
	\| \| value borrowed here after move
	\| value moved into `a` here
	\| move occurs because `a` has type `Option<U>` which does not implement the `Copy` trait

	error: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:61:9
	\|
	LL \| a @ Some((mut b @ ref mut c, d @ ref e)) => {}
	\| -^^^^^^^^^^^^^^^^^---------^^^^^^-----^^
	\| \| \| \|
	\| \| \| value borrowed here after move
	\| \| value borrowed here after move
	\| value moved into `a` here
	\| move occurs because `a` has type `Option<(U, U)>` which does not implement the `Copy` trait

	error: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:61:19
	\|
	LL \| a @ Some((mut b @ ref mut c, d @ ref e)) => {}
	\| -----^^^---------
	\| \| \|
	\| \| value borrowed here after move
	\| value moved into `b` here
	\| move occurs because `b` has type `U` which does not implement the `Copy` trait

	error: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:61:38
	\|
	LL \| a @ Some((mut b @ ref mut c, d @ ref e)) => {}
	\| -^^^-----
	\| \| \|
	\| \| value borrowed here after move
	\| value moved into `d` here
	\| move occurs because `d` has type `U` which does not implement the `Copy` trait

	error: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:71:9
	\|
	LL \| mut a @ Some([ref b, ref mut c]) => {}
	\| -----^^^^^^^^^-----^^---------^^
	\| \| \| \|
	\| \| \| value borrowed here after move
	\| \| value borrowed here after move
	\| value moved into `a` here
	\| move occurs because `a` has type `Option<[U; 2]>` which does not implement the `Copy` trait

	error: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:77:9
	\|
	LL \| a @ Some(ref b) => {}
	\| -^^^^^^^^-----^
	\| \| \|
	\| \| value borrowed here after move
	\| value moved into `a` here
	\| move occurs because `a` has type `Option<U>` which does not implement the `Copy` trait

	error: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:83:9
	\|
	LL \| a @ Some((mut b @ ref mut c, d @ ref e)) => {}
	\| -^^^^^^^^^^^^^^^^^---------^^^^^^-----^^
	\| \| \| \|
	\| \| \| value borrowed here after move
	\| \| value borrowed here after move
	\| value moved into `a` here
	\| move occurs because `a` has type `Option<(U, U)>` which does not implement the `Copy` trait

	error: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:83:19
	\|
	LL \| a @ Some((mut b @ ref mut c, d @ ref e)) => {}
	\| -----^^^---------
	\| \| \|
	\| \| value borrowed here after move
	\| value moved into `b` here
	\| move occurs because `b` has type `U` which does not implement the `Copy` trait

	error: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:83:38
	\|
	LL \| a @ Some((mut b @ ref mut c, d @ ref e)) => {}
	\| -^^^-----
	\| \| \|
	\| \| value borrowed here after move
	\| value moved into `d` here
	\| move occurs because `d` has type `U` which does not implement the `Copy` trait

	error: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:93:9
	\|
	LL \| mut a @ Some([ref b, ref mut c]) => {}
	\| -----^^^^^^^^^-----^^---------^^
	\| \| \| \|
	\| \| \| value borrowed here after move
	\| \| value borrowed here after move
	\| value moved into `a` here
	\| move occurs because `a` has type `Option<[U; 2]>` which does not implement the `Copy` trait

	error: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:14:11
	\|
	LL \| fn f1(a @ ref b: U) {}
	\| -^^^-----
	\| \| \|
	\| \| value borrowed here after move
	\| value moved into `a` here
	\| move occurs because `a` has type `U` which does not implement the `Copy` trait

	error: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:18:11
	\|
	LL \| fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
	\| -----^^^^^^^^-----^^^^^^^^^^-----^
	\| \| \| \|
	\| \| \| value borrowed here after move
	\| \| value borrowed here after move
	\| value moved into `a` here
	\| move occurs because `a` has type `(U, U)` which does not implement the `Copy` trait

	error: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:18:20
	\|
	LL \| fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
	\| -^^^-----
	\| \| \|
	\| \| value borrowed here after move
	\| value moved into `b` here
	\| move occurs because `b` has type `U` which does not implement the `Copy` trait

	error: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:18:31
	\|
	LL \| fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
	\| -----^^^-----
	\| \| \|
	\| \| value borrowed here after move
	\| value moved into `d` here
	\| move occurs because `d` has type `U` which does not implement the `Copy` trait

	error: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:25:11
	\|
	LL \| fn f3(a @ [ref mut b, ref c]: [U; 2]) {}
	\| -^^^^---------^^-----^
	\| \| \| \|
	\| \| \| value borrowed here after move
	\| \| value borrowed here after move
	\| value moved into `a` here
	\| move occurs because `a` has type `[U; 2]` which does not implement the `Copy` trait

	error[E0382]: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:31:22
	\|
	LL \| let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
	\| --------^^^^^^^^^
	\| \| \|
	\| \| value borrowed here after move
	\| value moved here
	\|
	= note: move occurs because value has type `U`, which does not implement the `Copy` trait

	error[E0382]: use of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:31:33
	\|
	LL \| let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
	\| ------------------------^^^^^^^^^- ------ move occurs because value has type `(U, U)`, which does not implement the `Copy` trait
	\| \| \|
	\| \| value used here after move
	\| value moved here

	error[E0382]: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:31:37
	\|
	LL \| let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
	\| ----^^^^^
	\| \| \|
	\| \| value borrowed here after move
	\| value moved here
	\|
	= note: move occurs because value has type `U`, which does not implement the `Copy` trait

	error[E0382]: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:38:25
	\|
	LL \| let a @ [ref mut b, ref c] = [U, U];
	\| ----------------^^^^^- ------ move occurs because value has type `[U; 2]`, which does not implement the `Copy` trait
	\| \| \|
	\| \| value borrowed here after move
	\| value moved here

	error[E0382]: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:41:13
	\|
	LL \| let a @ ref b = u();
	\| ----^^^^^ --- move occurs because value has type `U`, which does not implement the `Copy` trait
	\| \| \|
	\| \| value borrowed here after move
	\| value moved here

	error[E0382]: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:44:22
	\|
	LL \| let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
	\| --------^^^^^^^^^
	\| \| \|
	\| \| value borrowed here after move
	\| value moved here
	\|
	= note: move occurs because value has type `U`, which does not implement the `Copy` trait

	error[E0382]: use of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:44:33
	\|
	LL \| let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
	\| ------------------------^^^^^^^^^- ---------- move occurs because value has type `(U, U)`, which does not implement the `Copy` trait
	\| \| \|
	\| \| value used here after move
	\| value moved here

	error[E0382]: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:44:37
	\|
	LL \| let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
	\| ----^^^^^
	\| \| \|
	\| \| value borrowed here after move
	\| value moved here
	\|
	= note: move occurs because value has type `U`, which does not implement the `Copy` trait

	error[E0382]: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:51:25
	\|
	LL \| let a @ [ref mut b, ref c] = [u(), u()];
	\| ----------------^^^^^- ---------- move occurs because value has type `[U; 2]`, which does not implement the `Copy` trait
	\| \| \|
	\| \| value borrowed here after move
	\| value moved here

	error[E0382]: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:61:27
	\|
	LL \| a @ Some((mut b @ ref mut c, d @ ref e)) => {}
	\| --------^^^^^^^^^
	\| \| \|
	\| \| value borrowed here after move
	\| value moved here
	\|
	= note: move occurs because value has type `U`, which does not implement the `Copy` trait
	help: borrow this field in the pattern to avoid moving the value
	\|
	LL \| a @ Some((ref mut b @ ref mut c, d @ ref e)) => {}
	\| ^^^

	error[E0382]: use of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:61:38
	\|
	LL \| match Some((U, U)) {
	\| ------------ move occurs because value has type `Option<(U, U)>`, which does not implement the `Copy` trait
	LL \| a @ Some((mut b @ ref mut c, d @ ref e)) => {}
	\| -----------------------------^^^^^^^^^--
	\| \| \|
	\| \| value used here after move
	\| value moved here

	error[E0382]: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:61:42
	\|
	LL \| a @ Some((mut b @ ref mut c, d @ ref e)) => {}
	\| ----^^^^^
	\| \| \|
	\| \| value borrowed here after move
	\| value moved here
	\|
	= note: move occurs because value has type `U`, which does not implement the `Copy` trait
	help: borrow this field in the pattern to avoid moving the value
	\|
	LL \| a @ Some((mut b @ ref mut c, ref d @ ref e)) => {}
	\| ^^^

	error[E0382]: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:71:30
	\|
	LL \| match Some([U, U]) {
	\| ------------ move occurs because value has type `Option<[U; 2]>`, which does not implement the `Copy` trait
	LL \| mut a @ Some([ref b, ref mut c]) => {}
	\| ---------------------^^^^^^^^^--
	\| \| \|
	\| \| value borrowed here after move
	\| value moved here

	error[E0382]: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:77:18
	\|
	LL \| match Some(u()) {
	\| --------- move occurs because value has type `Option<U>`, which does not implement the `Copy` trait
	LL \| a @ Some(ref b) => {}
	\| ---------^^^^^-
	\| \| \|
	\| \| value borrowed here after move
	\| value moved here

	error[E0382]: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:83:27
	\|
	LL \| a @ Some((mut b @ ref mut c, d @ ref e)) => {}
	\| --------^^^^^^^^^
	\| \| \|
	\| \| value borrowed here after move
	\| value moved here
	\|
	= note: move occurs because value has type `U`, which does not implement the `Copy` trait
	help: borrow this field in the pattern to avoid moving the value
	\|
	LL \| a @ Some((ref mut b @ ref mut c, d @ ref e)) => {}
	\| ^^^

	error[E0382]: use of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:83:38
	\|
	LL \| match Some((u(), u())) {
	\| ---------------- move occurs because value has type `Option<(U, U)>`, which does not implement the `Copy` trait
	LL \| a @ Some((mut b @ ref mut c, d @ ref e)) => {}
	\| -----------------------------^^^^^^^^^--
	\| \| \|
	\| \| value used here after move
	\| value moved here

	error[E0382]: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:83:42
	\|
	LL \| a @ Some((mut b @ ref mut c, d @ ref e)) => {}
	\| ----^^^^^
	\| \| \|
	\| \| value borrowed here after move
	\| value moved here
	\|
	= note: move occurs because value has type `U`, which does not implement the `Copy` trait
	help: borrow this field in the pattern to avoid moving the value
	\|
	LL \| a @ Some((mut b @ ref mut c, ref d @ ref e)) => {}
	\| ^^^

	error[E0382]: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:93:30
	\|
	LL \| match Some([u(), u()]) {
	\| ---------------- move occurs because value has type `Option<[U; 2]>`, which does not implement the `Copy` trait
	LL \| mut a @ Some([ref b, ref mut c]) => {}
	\| ---------------------^^^^^^^^^--
	\| \| \|
	\| \| value borrowed here after move
	\| value moved here

	error[E0382]: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:14:15
	\|
	LL \| fn f1(a @ ref b: U) {}
	\| ----^^^^^
	\| \| \|
	\| \| value borrowed here after move
	\| value moved here
	\| move occurs because value has type `U`, which does not implement the `Copy` trait

	error[E0382]: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:18:24
	\|
	LL \| fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
	\| ----^^^^^
	\| \| \|
	\| \| value borrowed here after move
	\| value moved here
	\|
	= note: move occurs because value has type `U`, which does not implement the `Copy` trait

	error[E0382]: use of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:18:31
	\|
	LL \| fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
	\| --------------------^^^^^^^^^^^^^-
	\| \| \|
	\| \| value used here after move
	\| value moved here
	\| move occurs because value has type `(U, U)`, which does not implement the `Copy` trait

	error[E0382]: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:18:39
	\|
	LL \| fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
	\| --------^^^^^
	\| \| \|
	\| \| value borrowed here after move
	\| value moved here
	\|
	= note: move occurs because value has type `U`, which does not implement the `Copy` trait

	error[E0382]: borrow of moved value
	--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:25:27
	\|
	LL \| fn f3(a @ [ref mut b, ref c]: [U; 2]) {}
	\| ----------------^^^^^-
	\| \| \|
	\| \| value borrowed here after move
	\| value moved here
	\| move occurs because value has type `[U; 2]`, which does not implement the `Copy` trait

	error: aborting due to 48 previous errors

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