[rustc.git] / src / test / ui / binop / binop-consume-args.stderr

error[E0382]: use of moved value: `lhs`
  --> $DIR/binop-consume-args.rs:7:10
   |
LL | fn add<A: Add<B, Output=()>, B>(lhs: A, rhs: B) {
   |        --                       --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
   |        |
   |        help: consider further restricting this bound: `A: Copy +`
LL |     lhs + rhs;
   |     --- value moved here
LL |     drop(lhs);
   |          ^^^ value used here after move

error[E0382]: use of moved value: `rhs`
  --> $DIR/binop-consume-args.rs:8:10
   |
LL | fn add<A: Add<B, Output=()>, B>(lhs: A, rhs: B) {
   |                              -          --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
   |                              |
   |                              help: consider restricting this bound: `B: Copy`
LL |     lhs + rhs;
   |           --- value moved here
LL |     drop(lhs);
LL |     drop(rhs);
   |          ^^^ value used here after move

error[E0382]: use of moved value: `lhs`
  --> $DIR/binop-consume-args.rs:13:10
   |
LL | fn sub<A: Sub<B, Output=()>, B>(lhs: A, rhs: B) {
   |        --                       --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
   |        |
   |        help: consider further restricting this bound: `A: Copy +`
LL |     lhs - rhs;
   |     --- value moved here
LL |     drop(lhs);
   |          ^^^ value used here after move

error[E0382]: use of moved value: `rhs`
  --> $DIR/binop-consume-args.rs:14:10
   |
LL | fn sub<A: Sub<B, Output=()>, B>(lhs: A, rhs: B) {
   |                              -          --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
   |                              |
   |                              help: consider restricting this bound: `B: Copy`
LL |     lhs - rhs;
   |           --- value moved here
LL |     drop(lhs);
LL |     drop(rhs);
   |          ^^^ value used here after move

error[E0382]: use of moved value: `lhs`
  --> $DIR/binop-consume-args.rs:19:10
   |
LL | fn mul<A: Mul<B, Output=()>, B>(lhs: A, rhs: B) {
   |        --                       --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
   |        |
   |        help: consider further restricting this bound: `A: Copy +`
LL |     lhs * rhs;
   |     --- value moved here
LL |     drop(lhs);
   |          ^^^ value used here after move

error[E0382]: use of moved value: `rhs`
  --> $DIR/binop-consume-args.rs:20:10
   |
LL | fn mul<A: Mul<B, Output=()>, B>(lhs: A, rhs: B) {
   |                              -          --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
   |                              |
   |                              help: consider restricting this bound: `B: Copy`
LL |     lhs * rhs;
   |           --- value moved here
LL |     drop(lhs);
LL |     drop(rhs);
   |          ^^^ value used here after move

error[E0382]: use of moved value: `lhs`
  --> $DIR/binop-consume-args.rs:25:10
   |
LL | fn div<A: Div<B, Output=()>, B>(lhs: A, rhs: B) {
   |        --                       --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
   |        |
   |        help: consider further restricting this bound: `A: Copy +`
LL |     lhs / rhs;
   |     --- value moved here
LL |     drop(lhs);
   |          ^^^ value used here after move

error[E0382]: use of moved value: `rhs`
  --> $DIR/binop-consume-args.rs:26:10
   |
LL | fn div<A: Div<B, Output=()>, B>(lhs: A, rhs: B) {
   |                              -          --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
   |                              |
   |                              help: consider restricting this bound: `B: Copy`
LL |     lhs / rhs;
   |           --- value moved here
LL |     drop(lhs);
LL |     drop(rhs);
   |          ^^^ value used here after move

error[E0382]: use of moved value: `lhs`
  --> $DIR/binop-consume-args.rs:31:10
   |
LL | fn rem<A: Rem<B, Output=()>, B>(lhs: A, rhs: B) {
   |        --                       --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
   |        |
   |        help: consider further restricting this bound: `A: Copy +`
LL |     lhs % rhs;
   |     --- value moved here
LL |     drop(lhs);
   |          ^^^ value used here after move

error[E0382]: use of moved value: `rhs`
  --> $DIR/binop-consume-args.rs:32:10
   |
LL | fn rem<A: Rem<B, Output=()>, B>(lhs: A, rhs: B) {
   |                              -          --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
   |                              |
   |                              help: consider restricting this bound: `B: Copy`
LL |     lhs % rhs;
   |           --- value moved here
LL |     drop(lhs);
LL |     drop(rhs);
   |          ^^^ value used here after move

error[E0382]: use of moved value: `lhs`
  --> $DIR/binop-consume-args.rs:37:10
   |
LL | fn bitand<A: BitAnd<B, Output=()>, B>(lhs: A, rhs: B) {
   |           --                          --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
   |           |
   |           help: consider further restricting this bound: `A: Copy +`
LL |     lhs & rhs;
   |     --- value moved here
LL |     drop(lhs);
   |          ^^^ value used here after move

error[E0382]: use of moved value: `rhs`
  --> $DIR/binop-consume-args.rs:38:10
   |
LL | fn bitand<A: BitAnd<B, Output=()>, B>(lhs: A, rhs: B) {
   |                                    -          --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
   |                                    |
   |                                    help: consider restricting this bound: `B: Copy`
LL |     lhs & rhs;
   |           --- value moved here
LL |     drop(lhs);
LL |     drop(rhs);
   |          ^^^ value used here after move

error[E0382]: use of moved value: `lhs`
  --> $DIR/binop-consume-args.rs:43:10
   |
LL | fn bitor<A: BitOr<B, Output=()>, B>(lhs: A, rhs: B) {
   |          --                         --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
   |          |
   |          help: consider further restricting this bound: `A: Copy +`
LL |     lhs | rhs;
   |     --- value moved here
LL |     drop(lhs);
   |          ^^^ value used here after move

error[E0382]: use of moved value: `rhs`
  --> $DIR/binop-consume-args.rs:44:10
   |
LL | fn bitor<A: BitOr<B, Output=()>, B>(lhs: A, rhs: B) {
   |                                  -          --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
   |                                  |
   |                                  help: consider restricting this bound: `B: Copy`
LL |     lhs | rhs;
   |           --- value moved here
LL |     drop(lhs);
LL |     drop(rhs);
   |          ^^^ value used here after move

error[E0382]: use of moved value: `lhs`
  --> $DIR/binop-consume-args.rs:49:10
   |
LL | fn bitxor<A: BitXor<B, Output=()>, B>(lhs: A, rhs: B) {
   |           --                          --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
   |           |
   |           help: consider further restricting this bound: `A: Copy +`
LL |     lhs ^ rhs;
   |     --- value moved here
LL |     drop(lhs);
   |          ^^^ value used here after move

error[E0382]: use of moved value: `rhs`
  --> $DIR/binop-consume-args.rs:50:10
   |
LL | fn bitxor<A: BitXor<B, Output=()>, B>(lhs: A, rhs: B) {
   |                                    -          --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
   |                                    |
   |                                    help: consider restricting this bound: `B: Copy`
LL |     lhs ^ rhs;
   |           --- value moved here
LL |     drop(lhs);
LL |     drop(rhs);
   |          ^^^ value used here after move

error[E0382]: use of moved value: `lhs`
  --> $DIR/binop-consume-args.rs:55:10
   |
LL | fn shl<A: Shl<B, Output=()>, B>(lhs: A, rhs: B) {
   |        --                       --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
   |        |
   |        help: consider further restricting this bound: `A: Copy +`
LL |     lhs << rhs;
   |     --- value moved here
LL |     drop(lhs);
   |          ^^^ value used here after move

error[E0382]: use of moved value: `rhs`
  --> $DIR/binop-consume-args.rs:56:10
   |
LL | fn shl<A: Shl<B, Output=()>, B>(lhs: A, rhs: B) {
   |                              -          --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
   |                              |
   |                              help: consider restricting this bound: `B: Copy`
LL |     lhs << rhs;
   |            --- value moved here
LL |     drop(lhs);
LL |     drop(rhs);
   |          ^^^ value used here after move

error[E0382]: use of moved value: `lhs`
  --> $DIR/binop-consume-args.rs:61:10
   |
LL | fn shr<A: Shr<B, Output=()>, B>(lhs: A, rhs: B) {
   |        --                       --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
   |        |
   |        help: consider further restricting this bound: `A: Copy +`
LL |     lhs >> rhs;
   |     --- value moved here
LL |     drop(lhs);
   |          ^^^ value used here after move

error[E0382]: use of moved value: `rhs`
  --> $DIR/binop-consume-args.rs:62:10
   |
LL | fn shr<A: Shr<B, Output=()>, B>(lhs: A, rhs: B) {
   |                              -          --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
   |                              |
   |                              help: consider restricting this bound: `B: Copy`
LL |     lhs >> rhs;
   |            --- value moved here
LL |     drop(lhs);
LL |     drop(rhs);
   |          ^^^ value used here after move

error: aborting due to 20 previous errors

For more information about this error, try `rustc --explain E0382`.
Commit	Line	Data
b7449926	1	error[E0382]: use of moved value: `lhs`
0731742a	2	--> $DIR/binop-consume-args.rs:7:10
b7449926	3	\|
48663c56	4	LL \| fn add<A: Add<B, Output=()>, B>(lhs: A, rhs: B) {
60c5eb7d	5	\| -- --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
48663c56	6	\| \|
60c5eb7d	7	\| help: consider further restricting this bound: `A: Copy +`
b7449926 XL	8	LL \| lhs + rhs;
b7449926 XL	9	\| --- value moved here
532ac7d7	10	LL \| drop(lhs);
b7449926	11	\| ^^^ value used here after move
b7449926 XL	12
b7449926 XL	13	error[E0382]: use of moved value: `rhs`
0731742a	14	--> $DIR/binop-consume-args.rs:8:10
b7449926	15	\|
48663c56 XL	16	LL \| fn add<A: Add<B, Output=()>, B>(lhs: A, rhs: B) {
	17	\| - --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
	18	\| \|
60c5eb7d	19	\| help: consider restricting this bound: `B: Copy`
b7449926 XL	20	LL \| lhs + rhs;
b7449926 XL	21	\| --- value moved here
532ac7d7 XL	22	LL \| drop(lhs);
532ac7d7 XL	23	LL \| drop(rhs);
b7449926	24	\| ^^^ value used here after move
b7449926 XL	25
b7449926 XL	26	error[E0382]: use of moved value: `lhs`
0731742a	27	--> $DIR/binop-consume-args.rs:13:10
b7449926	28	\|
48663c56	29	LL \| fn sub<A: Sub<B, Output=()>, B>(lhs: A, rhs: B) {
60c5eb7d	30	\| -- --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
48663c56	31	\| \|
60c5eb7d	32	\| help: consider further restricting this bound: `A: Copy +`
b7449926 XL	33	LL \| lhs - rhs;
b7449926 XL	34	\| --- value moved here
532ac7d7	35	LL \| drop(lhs);
b7449926	36	\| ^^^ value used here after move
b7449926 XL	37
b7449926 XL	38	error[E0382]: use of moved value: `rhs`
0731742a	39	--> $DIR/binop-consume-args.rs:14:10
b7449926	40	\|
48663c56 XL	41	LL \| fn sub<A: Sub<B, Output=()>, B>(lhs: A, rhs: B) {
	42	\| - --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
	43	\| \|
60c5eb7d	44	\| help: consider restricting this bound: `B: Copy`
b7449926 XL	45	LL \| lhs - rhs;
b7449926 XL	46	\| --- value moved here
532ac7d7 XL	47	LL \| drop(lhs);
532ac7d7 XL	48	LL \| drop(rhs);
b7449926	49	\| ^^^ value used here after move
b7449926 XL	50
b7449926 XL	51	error[E0382]: use of moved value: `lhs`
0731742a	52	--> $DIR/binop-consume-args.rs:19:10
b7449926	53	\|
48663c56	54	LL \| fn mul<A: Mul<B, Output=()>, B>(lhs: A, rhs: B) {
60c5eb7d	55	\| -- --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
48663c56	56	\| \|
60c5eb7d	57	\| help: consider further restricting this bound: `A: Copy +`
b7449926 XL	58	LL \| lhs * rhs;
b7449926 XL	59	\| --- value moved here
532ac7d7	60	LL \| drop(lhs);
b7449926	61	\| ^^^ value used here after move
b7449926 XL	62
b7449926 XL	63	error[E0382]: use of moved value: `rhs`
0731742a	64	--> $DIR/binop-consume-args.rs:20:10
b7449926	65	\|
48663c56 XL	66	LL \| fn mul<A: Mul<B, Output=()>, B>(lhs: A, rhs: B) {
	67	\| - --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
	68	\| \|
60c5eb7d	69	\| help: consider restricting this bound: `B: Copy`
b7449926 XL	70	LL \| lhs * rhs;
b7449926 XL	71	\| --- value moved here
532ac7d7 XL	72	LL \| drop(lhs);
532ac7d7 XL	73	LL \| drop(rhs);
b7449926	74	\| ^^^ value used here after move
b7449926 XL	75
b7449926 XL	76	error[E0382]: use of moved value: `lhs`
0731742a	77	--> $DIR/binop-consume-args.rs:25:10
b7449926	78	\|
48663c56	79	LL \| fn div<A: Div<B, Output=()>, B>(lhs: A, rhs: B) {
60c5eb7d	80	\| -- --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
48663c56	81	\| \|
60c5eb7d	82	\| help: consider further restricting this bound: `A: Copy +`
b7449926 XL	83	LL \| lhs / rhs;
b7449926 XL	84	\| --- value moved here
532ac7d7	85	LL \| drop(lhs);
b7449926	86	\| ^^^ value used here after move
b7449926 XL	87
b7449926 XL	88	error[E0382]: use of moved value: `rhs`
0731742a	89	--> $DIR/binop-consume-args.rs:26:10
b7449926	90	\|
48663c56 XL	91	LL \| fn div<A: Div<B, Output=()>, B>(lhs: A, rhs: B) {
	92	\| - --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
	93	\| \|
60c5eb7d	94	\| help: consider restricting this bound: `B: Copy`
b7449926 XL	95	LL \| lhs / rhs;
b7449926 XL	96	\| --- value moved here
532ac7d7 XL	97	LL \| drop(lhs);
532ac7d7 XL	98	LL \| drop(rhs);
b7449926	99	\| ^^^ value used here after move
b7449926 XL	100
b7449926 XL	101	error[E0382]: use of moved value: `lhs`
0731742a	102	--> $DIR/binop-consume-args.rs:31:10
b7449926	103	\|
48663c56	104	LL \| fn rem<A: Rem<B, Output=()>, B>(lhs: A, rhs: B) {
60c5eb7d	105	\| -- --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
48663c56	106	\| \|
60c5eb7d	107	\| help: consider further restricting this bound: `A: Copy +`
b7449926 XL	108	LL \| lhs % rhs;
b7449926 XL	109	\| --- value moved here
532ac7d7	110	LL \| drop(lhs);
b7449926	111	\| ^^^ value used here after move
b7449926 XL	112
b7449926 XL	113	error[E0382]: use of moved value: `rhs`
0731742a	114	--> $DIR/binop-consume-args.rs:32:10
b7449926	115	\|
48663c56 XL	116	LL \| fn rem<A: Rem<B, Output=()>, B>(lhs: A, rhs: B) {
	117	\| - --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
	118	\| \|
60c5eb7d	119	\| help: consider restricting this bound: `B: Copy`
b7449926 XL	120	LL \| lhs % rhs;
b7449926 XL	121	\| --- value moved here
532ac7d7 XL	122	LL \| drop(lhs);
532ac7d7 XL	123	LL \| drop(rhs);
b7449926	124	\| ^^^ value used here after move
b7449926 XL	125
b7449926 XL	126	error[E0382]: use of moved value: `lhs`
0731742a	127	--> $DIR/binop-consume-args.rs:37:10
b7449926	128	\|
48663c56	129	LL \| fn bitand<A: BitAnd<B, Output=()>, B>(lhs: A, rhs: B) {
60c5eb7d	130	\| -- --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
48663c56	131	\| \|
60c5eb7d	132	\| help: consider further restricting this bound: `A: Copy +`
b7449926 XL	133	LL \| lhs & rhs;
b7449926 XL	134	\| --- value moved here
532ac7d7	135	LL \| drop(lhs);
b7449926	136	\| ^^^ value used here after move
b7449926 XL	137
b7449926 XL	138	error[E0382]: use of moved value: `rhs`
0731742a	139	--> $DIR/binop-consume-args.rs:38:10
b7449926	140	\|
48663c56 XL	141	LL \| fn bitand<A: BitAnd<B, Output=()>, B>(lhs: A, rhs: B) {
	142	\| - --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
	143	\| \|
60c5eb7d	144	\| help: consider restricting this bound: `B: Copy`
b7449926 XL	145	LL \| lhs & rhs;
b7449926 XL	146	\| --- value moved here
532ac7d7 XL	147	LL \| drop(lhs);
532ac7d7 XL	148	LL \| drop(rhs);
b7449926	149	\| ^^^ value used here after move
b7449926 XL	150
b7449926 XL	151	error[E0382]: use of moved value: `lhs`
0731742a	152	--> $DIR/binop-consume-args.rs:43:10
b7449926	153	\|
48663c56	154	LL \| fn bitor<A: BitOr<B, Output=()>, B>(lhs: A, rhs: B) {
60c5eb7d	155	\| -- --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
48663c56	156	\| \|
60c5eb7d	157	\| help: consider further restricting this bound: `A: Copy +`
b7449926 XL	158	LL \| lhs \| rhs;
b7449926 XL	159	\| --- value moved here
532ac7d7	160	LL \| drop(lhs);
b7449926	161	\| ^^^ value used here after move
b7449926 XL	162
b7449926 XL	163	error[E0382]: use of moved value: `rhs`
0731742a	164	--> $DIR/binop-consume-args.rs:44:10
b7449926	165	\|
48663c56 XL	166	LL \| fn bitor<A: BitOr<B, Output=()>, B>(lhs: A, rhs: B) {
	167	\| - --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
	168	\| \|
60c5eb7d	169	\| help: consider restricting this bound: `B: Copy`
b7449926 XL	170	LL \| lhs \| rhs;
b7449926 XL	171	\| --- value moved here
532ac7d7 XL	172	LL \| drop(lhs);
532ac7d7 XL	173	LL \| drop(rhs);
b7449926	174	\| ^^^ value used here after move
b7449926 XL	175
b7449926 XL	176	error[E0382]: use of moved value: `lhs`
0731742a	177	--> $DIR/binop-consume-args.rs:49:10
b7449926	178	\|
48663c56	179	LL \| fn bitxor<A: BitXor<B, Output=()>, B>(lhs: A, rhs: B) {
60c5eb7d	180	\| -- --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
48663c56	181	\| \|
60c5eb7d	182	\| help: consider further restricting this bound: `A: Copy +`
b7449926 XL	183	LL \| lhs ^ rhs;
b7449926 XL	184	\| --- value moved here
532ac7d7	185	LL \| drop(lhs);
b7449926	186	\| ^^^ value used here after move
b7449926 XL	187
b7449926 XL	188	error[E0382]: use of moved value: `rhs`
0731742a	189	--> $DIR/binop-consume-args.rs:50:10
b7449926	190	\|
48663c56 XL	191	LL \| fn bitxor<A: BitXor<B, Output=()>, B>(lhs: A, rhs: B) {
	192	\| - --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
	193	\| \|
60c5eb7d	194	\| help: consider restricting this bound: `B: Copy`
b7449926 XL	195	LL \| lhs ^ rhs;
b7449926 XL	196	\| --- value moved here
532ac7d7 XL	197	LL \| drop(lhs);
532ac7d7 XL	198	LL \| drop(rhs);
b7449926	199	\| ^^^ value used here after move
b7449926 XL	200
b7449926 XL	201	error[E0382]: use of moved value: `lhs`
0731742a	202	--> $DIR/binop-consume-args.rs:55:10
b7449926	203	\|
48663c56	204	LL \| fn shl<A: Shl<B, Output=()>, B>(lhs: A, rhs: B) {
60c5eb7d	205	\| -- --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
48663c56	206	\| \|
60c5eb7d	207	\| help: consider further restricting this bound: `A: Copy +`
b7449926 XL	208	LL \| lhs << rhs;
b7449926 XL	209	\| --- value moved here
532ac7d7	210	LL \| drop(lhs);
b7449926	211	\| ^^^ value used here after move
b7449926 XL	212
b7449926 XL	213	error[E0382]: use of moved value: `rhs`
0731742a	214	--> $DIR/binop-consume-args.rs:56:10
b7449926	215	\|
48663c56 XL	216	LL \| fn shl<A: Shl<B, Output=()>, B>(lhs: A, rhs: B) {
	217	\| - --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
	218	\| \|
60c5eb7d	219	\| help: consider restricting this bound: `B: Copy`
b7449926 XL	220	LL \| lhs << rhs;
b7449926 XL	221	\| --- value moved here
532ac7d7 XL	222	LL \| drop(lhs);
532ac7d7 XL	223	LL \| drop(rhs);
b7449926	224	\| ^^^ value used here after move
b7449926 XL	225
b7449926 XL	226	error[E0382]: use of moved value: `lhs`
0731742a	227	--> $DIR/binop-consume-args.rs:61:10
b7449926	228	\|
48663c56	229	LL \| fn shr<A: Shr<B, Output=()>, B>(lhs: A, rhs: B) {
60c5eb7d	230	\| -- --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
48663c56	231	\| \|
60c5eb7d	232	\| help: consider further restricting this bound: `A: Copy +`
b7449926 XL	233	LL \| lhs >> rhs;
b7449926 XL	234	\| --- value moved here
532ac7d7	235	LL \| drop(lhs);
b7449926	236	\| ^^^ value used here after move
b7449926 XL	237
b7449926 XL	238	error[E0382]: use of moved value: `rhs`
0731742a	239	--> $DIR/binop-consume-args.rs:62:10
b7449926	240	\|
48663c56 XL	241	LL \| fn shr<A: Shr<B, Output=()>, B>(lhs: A, rhs: B) {
	242	\| - --- move occurs because `rhs` has type `B`, which does not implement the `Copy` trait
	243	\| \|
60c5eb7d	244	\| help: consider restricting this bound: `B: Copy`
b7449926 XL	245	LL \| lhs >> rhs;
b7449926 XL	246	\| --- value moved here
532ac7d7 XL	247	LL \| drop(lhs);
532ac7d7 XL	248	LL \| drop(rhs);
b7449926	249	\| ^^^ value used here after move
b7449926 XL	250
	251	error: aborting due to 20 previous errors
	252
	253	For more information about this error, try `rustc --explain E0382`.