rust/tests/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: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 `Sized`
   |
   = note: required because it appears within the type `(A, B)`
note: required by an implicit `Sized` bound in `Trait`
  --> $DIR/unsized-bound.rs:1:13
   |
LL | trait Trait<A> {}
   |             ^ required by the implicit `Sized` requirement on this type parameter 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 `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: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 `Sized`
   |
   = note: required because it appears within the type `(A, B, C)`
note: required by an implicit `Sized` bound in `Trait`
  --> $DIR/unsized-bound.rs:1:13
   |
LL | trait Trait<A> {}
   |             ^ required by the implicit `Sized` requirement on this type parameter 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, {}
   |      - this type parameter needs to be `Sized`     ^^^^^^^^^ doesn't have a size known at compile-time
   |
   = 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, {}
   |         - this type parameter needs to be `Sized`  ^^^^^^^^^ doesn't have a size known at compile-time
   |
   = 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: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 `Sized`
   |
   = note: required because it appears within the type `(A, B)`
note: required by an implicit `Sized` bound in `Trait2`
  --> $DIR/unsized-bound.rs:9:14
   |
LL | trait Trait2<A> {}
   |              ^ required by the implicit `Sized` requirement on this type parameter 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 `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:23
   |
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 `Sized`
   |
note: required by an implicit `Sized` bound in `Trait3`
  --> $DIR/unsized-bound.rs:13:14
   |
LL | trait Trait3<A> {}
   |              ^ required by the implicit `Sized` requirement on this type parameter 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:31
   |
LL | impl<A: ?Sized> Trait4<A> for A {}
   |      -                        ^ doesn't have a size known at compile-time
   |      |
   |      this type parameter needs to be `Sized`
   |
note: required by an implicit `Sized` bound in `Trait4`
  --> $DIR/unsized-bound.rs:16:14
   |
LL | trait Trait4<A> {}
   |              ^ required by the implicit `Sized` requirement on this type parameter 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:29
   |
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 `Sized`
   |
note: required by an implicit `Sized` bound in `Trait5`
  --> $DIR/unsized-bound.rs:19:14
   |
LL | trait Trait5<A, B> {}
   |              ^ required by the implicit `Sized` requirement on this type parameter 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:37
   |
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 `Sized`
   |
note: required by an implicit `Sized` bound in `Trait6`
  --> $DIR/unsized-bound.rs:22:14
   |
LL | trait Trait6<A, B> {}
   |              ^ required by the implicit `Sized` requirement on this type parameter 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 `Sized`
   |
note: required by an implicit `Sized` bound in `Trait7`
  --> $DIR/unsized-bound.rs:25:17
   |
LL | trait Trait7<A, B> {}
   |                 ^ required by the implicit `Sized` requirement on this type parameter 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 `Sized`
   |
note: required by an implicit `Sized` bound in `Trait8`
  --> $DIR/unsized-bound.rs:28:17
   |
LL | trait Trait8<A, B> {}
   |                 ^ required by the implicit `Sized` requirement on this type parameter 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`.