[rustc.git] / src / test / ui / trait-bounds / unsized-bound.stderr

error[E0277]: the size for values of type `B` cannot be known at compilation time
  --> $DIR/unsized-bound.rs:2:12
   |
LL | impl<A, B> Trait<(A, B)> for (A, B) where A: ?Sized, B: ?Sized, {}
   |         -  ^^^^^^^^^^^^^ doesn't have a size known at compile-time
   |         |
   |         this type parameter needs to be `std::marker::Sized`
   |
   = note: required because it appears within the type `(A, B)`
note: required by a bound in `Trait`
  --> $DIR/unsized-bound.rs:1:13
   |
LL | trait Trait<A> {}
   |             ^ required by this bound in `Trait`
help: consider removing the `?Sized` bound to make the type parameter `Sized`
   |
LL - impl<A, B> Trait<(A, B)> for (A, B) where A: ?Sized, B: ?Sized, {}
LL + impl<A, B> Trait<(A, B)> for (A, B) where A: ?Sized, {}
   |
help: consider relaxing the implicit `Sized` restriction
   |
LL | trait Trait<A: ?Sized> {}
   |              ++++++++

error[E0277]: the size for values of type `A` cannot be known at compilation time
  --> $DIR/unsized-bound.rs:2:30
   |
LL | impl<A, B> Trait<(A, B)> for (A, B) where A: ?Sized, B: ?Sized, {}
   |      -                       ^^^^^^ doesn't have a size known at compile-time
   |      |
   |      this type parameter needs to be `std::marker::Sized`
   |
   = note: only the last element of a tuple may have a dynamically sized type
help: consider removing the `?Sized` bound to make the type parameter `Sized`
   |
LL - impl<A, B> Trait<(A, B)> for (A, B) where A: ?Sized, B: ?Sized, {}
LL + impl<A, B> Trait<(A, B)> for (A, B) where B: ?Sized, {}
   |

error[E0277]: the size for values of type `C` cannot be known at compilation time
  --> $DIR/unsized-bound.rs:5:31
   |
LL | impl<A, B: ?Sized, C: ?Sized> Trait<(A, B, C)> for (A, B, C) where A: ?Sized, {}
   |                    -          ^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
   |                    |
   |                    this type parameter needs to be `std::marker::Sized`
   |
   = note: required because it appears within the type `(A, B, C)`
note: required by a bound in `Trait`
  --> $DIR/unsized-bound.rs:1:13
   |
LL | trait Trait<A> {}
   |             ^ required by this bound in `Trait`
help: consider removing the `?Sized` bound to make the type parameter `Sized`
   |
LL - impl<A, B: ?Sized, C: ?Sized> Trait<(A, B, C)> for (A, B, C) where A: ?Sized, {}
LL + impl<A, B: ?Sized, C> Trait<(A, B, C)> for (A, B, C) where A: ?Sized, {}
   |
help: consider relaxing the implicit `Sized` restriction
   |
LL | trait Trait<A: ?Sized> {}
   |              ++++++++

error[E0277]: the size for values of type `A` cannot be known at compilation time
  --> $DIR/unsized-bound.rs:5:52
   |
LL | impl<A, B: ?Sized, C: ?Sized> Trait<(A, B, C)> for (A, B, C) where A: ?Sized, {}
   |      -                                             ^^^^^^^^^ doesn't have a size known at compile-time
   |      |
   |      this type parameter needs to be `std::marker::Sized`
   |
   = note: only the last element of a tuple may have a dynamically sized type
help: consider removing the `?Sized` bound to make the type parameter `Sized`
   |
LL - impl<A, B: ?Sized, C: ?Sized> Trait<(A, B, C)> for (A, B, C) where A: ?Sized, {}
LL + impl<A, B: ?Sized, C: ?Sized> Trait<(A, B, C)> for (A, B, C)  {}
   |

error[E0277]: the size for values of type `B` cannot be known at compilation time
  --> $DIR/unsized-bound.rs:5:52
   |
LL | impl<A, B: ?Sized, C: ?Sized> Trait<(A, B, C)> for (A, B, C) where A: ?Sized, {}
   |         -                                          ^^^^^^^^^ doesn't have a size known at compile-time
   |         |
   |         this type parameter needs to be `std::marker::Sized`
   |
   = note: only the last element of a tuple may have a dynamically sized type
help: consider removing the `?Sized` bound to make the type parameter `Sized`
   |
LL - impl<A, B: ?Sized, C: ?Sized> Trait<(A, B, C)> for (A, B, C) where A: ?Sized, {}
LL + impl<A, B, C: ?Sized> Trait<(A, B, C)> for (A, B, C) where A: ?Sized, {}
   |

error[E0277]: the size for values of type `B` cannot be known at compilation time
  --> $DIR/unsized-bound.rs:10:28
   |
LL | impl<A: ?Sized, B: ?Sized> Trait2<(A, B)> for (A, B) {}
   |                 -          ^^^^^^^^^^^^^^ doesn't have a size known at compile-time
   |                 |
   |                 this type parameter needs to be `std::marker::Sized`
   |
   = note: required because it appears within the type `(A, B)`
note: required by a bound in `Trait2`
  --> $DIR/unsized-bound.rs:9:14
   |
LL | trait Trait2<A> {}
   |              ^ required by this bound in `Trait2`
help: consider removing the `?Sized` bound to make the type parameter `Sized`
   |
LL - impl<A: ?Sized, B: ?Sized> Trait2<(A, B)> for (A, B) {}
LL + impl<A: ?Sized, B> Trait2<(A, B)> for (A, B) {}
   |
help: consider relaxing the implicit `Sized` restriction
   |
LL | trait Trait2<A: ?Sized> {}
   |               ++++++++

error[E0277]: the size for values of type `A` cannot be known at compilation time
  --> $DIR/unsized-bound.rs:10:47
   |
LL | impl<A: ?Sized, B: ?Sized> Trait2<(A, B)> for (A, B) {}
   |      -                                        ^^^^^^ doesn't have a size known at compile-time
   |      |
   |      this type parameter needs to be `std::marker::Sized`
   |
   = note: only the last element of a tuple may have a dynamically sized type
help: consider removing the `?Sized` bound to make the type parameter `Sized`
   |
LL - impl<A: ?Sized, B: ?Sized> Trait2<(A, B)> for (A, B) {}
LL + impl<A, B: ?Sized> Trait2<(A, B)> for (A, B) {}
   |

error[E0277]: the size for values of type `A` cannot be known at compilation time
  --> $DIR/unsized-bound.rs:14:9
   |
LL | impl<A> Trait3<A> for A where A: ?Sized {}
   |      -  ^^^^^^^^^ doesn't have a size known at compile-time
   |      |
   |      this type parameter needs to be `std::marker::Sized`
   |
note: required by a bound in `Trait3`
  --> $DIR/unsized-bound.rs:13:14
   |
LL | trait Trait3<A> {}
   |              ^ required by this bound in `Trait3`
help: consider removing the `?Sized` bound to make the type parameter `Sized`
   |
LL - impl<A> Trait3<A> for A where A: ?Sized {}
LL + impl<A> Trait3<A> for A  {}
   |
help: consider relaxing the implicit `Sized` restriction
   |
LL | trait Trait3<A: ?Sized> {}
   |               ++++++++

error[E0277]: the size for values of type `A` cannot be known at compilation time
  --> $DIR/unsized-bound.rs:17:17
   |
LL | impl<A: ?Sized> Trait4<A> for A {}
   |      -          ^^^^^^^^^ doesn't have a size known at compile-time
   |      |
   |      this type parameter needs to be `std::marker::Sized`
   |
note: required by a bound in `Trait4`
  --> $DIR/unsized-bound.rs:16:14
   |
LL | trait Trait4<A> {}
   |              ^ required by this bound in `Trait4`
help: consider removing the `?Sized` bound to make the type parameter `Sized`
   |
LL - impl<A: ?Sized> Trait4<A> for A {}
LL + impl<A> Trait4<A> for A {}
   |
help: consider relaxing the implicit `Sized` restriction
   |
LL | trait Trait4<A: ?Sized> {}
   |               ++++++++

error[E0277]: the size for values of type `X` cannot be known at compilation time
  --> $DIR/unsized-bound.rs:20:12
   |
LL | impl<X, Y> Trait5<X, Y> for X where X: ?Sized {}
   |      -     ^^^^^^^^^^^^ doesn't have a size known at compile-time
   |      |
   |      this type parameter needs to be `std::marker::Sized`
   |
note: required by a bound in `Trait5`
  --> $DIR/unsized-bound.rs:19:14
   |
LL | trait Trait5<A, B> {}
   |              ^ required by this bound in `Trait5`
help: consider removing the `?Sized` bound to make the type parameter `Sized`
   |
LL - impl<X, Y> Trait5<X, Y> for X where X: ?Sized {}
LL + impl<X, Y> Trait5<X, Y> for X  {}
   |
help: consider relaxing the implicit `Sized` restriction
   |
LL | trait Trait5<A: ?Sized, B> {}
   |               ++++++++

error[E0277]: the size for values of type `X` cannot be known at compilation time
  --> $DIR/unsized-bound.rs:23:20
   |
LL | impl<X: ?Sized, Y> Trait6<X, Y> for X {}
   |      -             ^^^^^^^^^^^^ doesn't have a size known at compile-time
   |      |
   |      this type parameter needs to be `std::marker::Sized`
   |
note: required by a bound in `Trait6`
  --> $DIR/unsized-bound.rs:22:14
   |
LL | trait Trait6<A, B> {}
   |              ^ required by this bound in `Trait6`
help: consider removing the `?Sized` bound to make the type parameter `Sized`
   |
LL - impl<X: ?Sized, Y> Trait6<X, Y> for X {}
LL + impl<X, Y> Trait6<X, Y> for X {}
   |
help: consider relaxing the implicit `Sized` restriction
   |
LL | trait Trait6<A: ?Sized, B> {}
   |               ++++++++

error[E0277]: the size for values of type `Y` cannot be known at compilation time
  --> $DIR/unsized-bound.rs:26:12
   |
LL | impl<X, Y> Trait7<X, Y> for X where Y: ?Sized {}
   |         -  ^^^^^^^^^^^^ doesn't have a size known at compile-time
   |         |
   |         this type parameter needs to be `std::marker::Sized`
   |
note: required by a bound in `Trait7`
  --> $DIR/unsized-bound.rs:25:17
   |
LL | trait Trait7<A, B> {}
   |                 ^ required by this bound in `Trait7`
help: consider removing the `?Sized` bound to make the type parameter `Sized`
   |
LL - impl<X, Y> Trait7<X, Y> for X where Y: ?Sized {}
LL + impl<X, Y> Trait7<X, Y> for X  {}
   |
help: consider relaxing the implicit `Sized` restriction
   |
LL | trait Trait7<A, B: ?Sized> {}
   |                  ++++++++

error[E0277]: the size for values of type `Y` cannot be known at compilation time
  --> $DIR/unsized-bound.rs:29:20
   |
LL | impl<X, Y: ?Sized> Trait8<X, Y> for X {}
   |         -          ^^^^^^^^^^^^ doesn't have a size known at compile-time
   |         |
   |         this type parameter needs to be `std::marker::Sized`
   |
note: required by a bound in `Trait8`
  --> $DIR/unsized-bound.rs:28:17
   |
LL | trait Trait8<A, B> {}
   |                 ^ required by this bound in `Trait8`
help: consider removing the `?Sized` bound to make the type parameter `Sized`
   |
LL - impl<X, Y: ?Sized> Trait8<X, Y> for X {}
LL + impl<X, Y> Trait8<X, Y> for X {}
   |
help: consider relaxing the implicit `Sized` restriction
   |
LL | trait Trait8<A, B: ?Sized> {}
   |                  ++++++++

error: aborting due to 13 previous errors

For more information about this error, try `rustc --explain E0277`.
Commit	Line	Data
94222f64 XL	1	error[E0277]: the size for values of type `B` cannot be known at compilation time
	2	--> $DIR/unsized-bound.rs:2:12
	3	\|
	4	LL \| impl<A, B> Trait<(A, B)> for (A, B) where A: ?Sized, B: ?Sized, {}
	5	\| - ^^^^^^^^^^^^^ doesn't have a size known at compile-time
	6	\| \|
	7	\| this type parameter needs to be `std::marker::Sized`
	8	\|
	9	= note: required because it appears within the type `(A, B)`
	10	note: required by a bound in `Trait`
	11	--> $DIR/unsized-bound.rs:1:13
	12	\|
	13	LL \| trait Trait<A> {}
	14	\| ^ required by this bound in `Trait`
	15	help: consider removing the `?Sized` bound to make the type parameter `Sized`
	16	\|
	17	LL - impl<A, B> Trait<(A, B)> for (A, B) where A: ?Sized, B: ?Sized, {}
	18	LL + impl<A, B> Trait<(A, B)> for (A, B) where A: ?Sized, {}
923072b8	19	\|
94222f64 XL	20	help: consider relaxing the implicit `Sized` restriction
	21	\|
	22	LL \| trait Trait<A: ?Sized> {}
	23	\| ++++++++
	24
	25	error[E0277]: the size for values of type `A` cannot be known at compilation time
	26	--> $DIR/unsized-bound.rs:2:30
	27	\|
	28	LL \| impl<A, B> Trait<(A, B)> for (A, B) where A: ?Sized, B: ?Sized, {}
	29	\| - ^^^^^^ doesn't have a size known at compile-time
	30	\| \|
	31	\| this type parameter needs to be `std::marker::Sized`
	32	\|
	33	= note: only the last element of a tuple may have a dynamically sized type
	34	help: consider removing the `?Sized` bound to make the type parameter `Sized`
	35	\|
	36	LL - impl<A, B> Trait<(A, B)> for (A, B) where A: ?Sized, B: ?Sized, {}
	37	LL + impl<A, B> Trait<(A, B)> for (A, B) where B: ?Sized, {}
923072b8	38	\|
94222f64 XL	39
	40	error[E0277]: the size for values of type `C` cannot be known at compilation time
	41	--> $DIR/unsized-bound.rs:5:31
	42	\|
	43	LL \| impl<A, B: ?Sized, C: ?Sized> Trait<(A, B, C)> for (A, B, C) where A: ?Sized, {}
	44	\| - ^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
	45	\| \|
	46	\| this type parameter needs to be `std::marker::Sized`
	47	\|
	48	= note: required because it appears within the type `(A, B, C)`
	49	note: required by a bound in `Trait`
	50	--> $DIR/unsized-bound.rs:1:13
	51	\|
	52	LL \| trait Trait<A> {}
	53	\| ^ required by this bound in `Trait`
	54	help: consider removing the `?Sized` bound to make the type parameter `Sized`
	55	\|
	56	LL - impl<A, B: ?Sized, C: ?Sized> Trait<(A, B, C)> for (A, B, C) where A: ?Sized, {}
	57	LL + impl<A, B: ?Sized, C> Trait<(A, B, C)> for (A, B, C) where A: ?Sized, {}
923072b8	58	\|
94222f64 XL	59	help: consider relaxing the implicit `Sized` restriction
	60	\|
	61	LL \| trait Trait<A: ?Sized> {}
	62	\| ++++++++
	63
	64	error[E0277]: the size for values of type `A` cannot be known at compilation time
	65	--> $DIR/unsized-bound.rs:5:52
	66	\|
	67	LL \| impl<A, B: ?Sized, C: ?Sized> Trait<(A, B, C)> for (A, B, C) where A: ?Sized, {}
	68	\| - ^^^^^^^^^ doesn't have a size known at compile-time
	69	\| \|
	70	\| this type parameter needs to be `std::marker::Sized`
	71	\|
	72	= note: only the last element of a tuple may have a dynamically sized type
	73	help: consider removing the `?Sized` bound to make the type parameter `Sized`
	74	\|
	75	LL - impl<A, B: ?Sized, C: ?Sized> Trait<(A, B, C)> for (A, B, C) where A: ?Sized, {}
	76	LL + impl<A, B: ?Sized, C: ?Sized> Trait<(A, B, C)> for (A, B, C) {}
923072b8	77	\|
94222f64 XL	78
	79	error[E0277]: the size for values of type `B` cannot be known at compilation time
	80	--> $DIR/unsized-bound.rs:5:52
	81	\|
	82	LL \| impl<A, B: ?Sized, C: ?Sized> Trait<(A, B, C)> for (A, B, C) where A: ?Sized, {}
	83	\| - ^^^^^^^^^ doesn't have a size known at compile-time
	84	\| \|
	85	\| this type parameter needs to be `std::marker::Sized`
	86	\|
	87	= note: only the last element of a tuple may have a dynamically sized type
	88	help: consider removing the `?Sized` bound to make the type parameter `Sized`
	89	\|
	90	LL - impl<A, B: ?Sized, C: ?Sized> Trait<(A, B, C)> for (A, B, C) where A: ?Sized, {}
	91	LL + impl<A, B, C: ?Sized> Trait<(A, B, C)> for (A, B, C) where A: ?Sized, {}
923072b8	92	\|
94222f64 XL	93
	94	error[E0277]: the size for values of type `B` cannot be known at compilation time
	95	--> $DIR/unsized-bound.rs:10:28
	96	\|
	97	LL \| impl<A: ?Sized, B: ?Sized> Trait2<(A, B)> for (A, B) {}
	98	\| - ^^^^^^^^^^^^^^ doesn't have a size known at compile-time
	99	\| \|
	100	\| this type parameter needs to be `std::marker::Sized`
	101	\|
	102	= note: required because it appears within the type `(A, B)`
	103	note: required by a bound in `Trait2`
	104	--> $DIR/unsized-bound.rs:9:14
	105	\|
	106	LL \| trait Trait2<A> {}
	107	\| ^ required by this bound in `Trait2`
	108	help: consider removing the `?Sized` bound to make the type parameter `Sized`
	109	\|
	110	LL - impl<A: ?Sized, B: ?Sized> Trait2<(A, B)> for (A, B) {}
	111	LL + impl<A: ?Sized, B> Trait2<(A, B)> for (A, B) {}
923072b8	112	\|
94222f64 XL	113	help: consider relaxing the implicit `Sized` restriction
	114	\|
	115	LL \| trait Trait2<A: ?Sized> {}
	116	\| ++++++++
	117
	118	error[E0277]: the size for values of type `A` cannot be known at compilation time
	119	--> $DIR/unsized-bound.rs:10:47
	120	\|
	121	LL \| impl<A: ?Sized, B: ?Sized> Trait2<(A, B)> for (A, B) {}
	122	\| - ^^^^^^ doesn't have a size known at compile-time
	123	\| \|
	124	\| this type parameter needs to be `std::marker::Sized`
	125	\|
	126	= note: only the last element of a tuple may have a dynamically sized type
	127	help: consider removing the `?Sized` bound to make the type parameter `Sized`
	128	\|
	129	LL - impl<A: ?Sized, B: ?Sized> Trait2<(A, B)> for (A, B) {}
	130	LL + impl<A, B: ?Sized> Trait2<(A, B)> for (A, B) {}
923072b8	131	\|
94222f64 XL	132
	133	error[E0277]: the size for values of type `A` cannot be known at compilation time
	134	--> $DIR/unsized-bound.rs:14:9
	135	\|
	136	LL \| impl<A> Trait3<A> for A where A: ?Sized {}
	137	\| - ^^^^^^^^^ doesn't have a size known at compile-time
	138	\| \|
	139	\| this type parameter needs to be `std::marker::Sized`
	140	\|
	141	note: required by a bound in `Trait3`
	142	--> $DIR/unsized-bound.rs:13:14
	143	\|
	144	LL \| trait Trait3<A> {}
	145	\| ^ required by this bound in `Trait3`
	146	help: consider removing the `?Sized` bound to make the type parameter `Sized`
	147	\|
	148	LL - impl<A> Trait3<A> for A where A: ?Sized {}
	149	LL + impl<A> Trait3<A> for A {}
923072b8	150	\|
94222f64 XL	151	help: consider relaxing the implicit `Sized` restriction
	152	\|
	153	LL \| trait Trait3<A: ?Sized> {}
	154	\| ++++++++
	155
	156	error[E0277]: the size for values of type `A` cannot be known at compilation time
	157	--> $DIR/unsized-bound.rs:17:17
	158	\|
	159	LL \| impl<A: ?Sized> Trait4<A> for A {}
	160	\| - ^^^^^^^^^ doesn't have a size known at compile-time
	161	\| \|
	162	\| this type parameter needs to be `std::marker::Sized`
	163	\|
	164	note: required by a bound in `Trait4`
	165	--> $DIR/unsized-bound.rs:16:14
	166	\|
	167	LL \| trait Trait4<A> {}
	168	\| ^ required by this bound in `Trait4`
	169	help: consider removing the `?Sized` bound to make the type parameter `Sized`
	170	\|
	171	LL - impl<A: ?Sized> Trait4<A> for A {}
	172	LL + impl<A> Trait4<A> for A {}
923072b8	173	\|
94222f64 XL	174	help: consider relaxing the implicit `Sized` restriction
	175	\|
	176	LL \| trait Trait4<A: ?Sized> {}
	177	\| ++++++++
	178
	179	error[E0277]: the size for values of type `X` cannot be known at compilation time
	180	--> $DIR/unsized-bound.rs:20:12
	181	\|
	182	LL \| impl<X, Y> Trait5<X, Y> for X where X: ?Sized {}
	183	\| - ^^^^^^^^^^^^ doesn't have a size known at compile-time
	184	\| \|
	185	\| this type parameter needs to be `std::marker::Sized`
	186	\|
	187	note: required by a bound in `Trait5`
	188	--> $DIR/unsized-bound.rs:19:14
	189	\|
	190	LL \| trait Trait5<A, B> {}
	191	\| ^ required by this bound in `Trait5`
	192	help: consider removing the `?Sized` bound to make the type parameter `Sized`
	193	\|
	194	LL - impl<X, Y> Trait5<X, Y> for X where X: ?Sized {}
	195	LL + impl<X, Y> Trait5<X, Y> for X {}
923072b8	196	\|
94222f64 XL	197	help: consider relaxing the implicit `Sized` restriction
	198	\|
	199	LL \| trait Trait5<A: ?Sized, B> {}
	200	\| ++++++++
	201
	202	error[E0277]: the size for values of type `X` cannot be known at compilation time
	203	--> $DIR/unsized-bound.rs:23:20
	204	\|
	205	LL \| impl<X: ?Sized, Y> Trait6<X, Y> for X {}
	206	\| - ^^^^^^^^^^^^ doesn't have a size known at compile-time
	207	\| \|
	208	\| this type parameter needs to be `std::marker::Sized`
	209	\|
	210	note: required by a bound in `Trait6`
	211	--> $DIR/unsized-bound.rs:22:14
	212	\|
	213	LL \| trait Trait6<A, B> {}
	214	\| ^ required by this bound in `Trait6`
	215	help: consider removing the `?Sized` bound to make the type parameter `Sized`
	216	\|
	217	LL - impl<X: ?Sized, Y> Trait6<X, Y> for X {}
	218	LL + impl<X, Y> Trait6<X, Y> for X {}
923072b8	219	\|
94222f64 XL	220	help: consider relaxing the implicit `Sized` restriction
	221	\|
	222	LL \| trait Trait6<A: ?Sized, B> {}
	223	\| ++++++++
	224
	225	error[E0277]: the size for values of type `Y` cannot be known at compilation time
	226	--> $DIR/unsized-bound.rs:26:12
	227	\|
	228	LL \| impl<X, Y> Trait7<X, Y> for X where Y: ?Sized {}
	229	\| - ^^^^^^^^^^^^ doesn't have a size known at compile-time
	230	\| \|
	231	\| this type parameter needs to be `std::marker::Sized`
	232	\|
	233	note: required by a bound in `Trait7`
	234	--> $DIR/unsized-bound.rs:25:17
	235	\|
	236	LL \| trait Trait7<A, B> {}
	237	\| ^ required by this bound in `Trait7`
	238	help: consider removing the `?Sized` bound to make the type parameter `Sized`
	239	\|
	240	LL - impl<X, Y> Trait7<X, Y> for X where Y: ?Sized {}
	241	LL + impl<X, Y> Trait7<X, Y> for X {}
923072b8	242	\|
94222f64 XL	243	help: consider relaxing the implicit `Sized` restriction
	244	\|
	245	LL \| trait Trait7<A, B: ?Sized> {}
	246	\| ++++++++
	247
	248	error[E0277]: the size for values of type `Y` cannot be known at compilation time
	249	--> $DIR/unsized-bound.rs:29:20
	250	\|
	251	LL \| impl<X, Y: ?Sized> Trait8<X, Y> for X {}
	252	\| - ^^^^^^^^^^^^ doesn't have a size known at compile-time
	253	\| \|
	254	\| this type parameter needs to be `std::marker::Sized`
	255	\|
	256	note: required by a bound in `Trait8`
	257	--> $DIR/unsized-bound.rs:28:17
	258	\|
	259	LL \| trait Trait8<A, B> {}
	260	\| ^ required by this bound in `Trait8`
	261	help: consider removing the `?Sized` bound to make the type parameter `Sized`
	262	\|
	263	LL - impl<X, Y: ?Sized> Trait8<X, Y> for X {}
	264	LL + impl<X, Y> Trait8<X, Y> for X {}
923072b8	265	\|
94222f64 XL	266	help: consider relaxing the implicit `Sized` restriction
	267	\|
	268	LL \| trait Trait8<A, B: ?Sized> {}
	269	\| ++++++++
	270
	271	error: aborting due to 13 previous errors
	272
	273	For more information about this error, try `rustc --explain E0277`.