error[E0277]: the size for values of type `[u8]` cannot be known at compilation time
  --> $DIR/box-into-boxed-slice-fail.rs:8:35
   |
LL |     let _ = Box::into_boxed_slice(boxed_slice);
   |                                   ^^^^^^^^^^^ doesn't have a size known at compile-time
   |
   = help: the trait `std::marker::Sized` is not implemented for `[u8]`
   = note: to learn more, visit <https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait>
   = note: required by `std::boxed::Box::<T>::into_boxed_slice`

error[E0277]: the size for values of type `[u8]` cannot be known at compilation time
  --> $DIR/box-into-boxed-slice-fail.rs:8:13
   |
LL |     let _ = Box::into_boxed_slice(boxed_slice);
   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
   |
   = help: the trait `std::marker::Sized` is not implemented for `[u8]`
   = note: to learn more, visit <https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait>
   = note: slice and array elements must have `Sized` type

error[E0277]: the size for values of type `dyn std::fmt::Debug` cannot be known at compilation time
  --> $DIR/box-into-boxed-slice-fail.rs:12:35
   |
LL |     let _ = Box::into_boxed_slice(boxed_trait);
   |                                   ^^^^^^^^^^^ doesn't have a size known at compile-time
   |
   = help: the trait `std::marker::Sized` is not implemented for `dyn std::fmt::Debug`
   = note: to learn more, visit <https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait>
   = note: required by `std::boxed::Box::<T>::into_boxed_slice`

error[E0277]: the size for values of type `dyn std::fmt::Debug` cannot be known at compilation time
  --> $DIR/box-into-boxed-slice-fail.rs:12:13
   |
LL |     let _ = Box::into_boxed_slice(boxed_trait);
   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
   |
   = help: the trait `std::marker::Sized` is not implemented for `dyn std::fmt::Debug`
   = note: to learn more, visit <https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait>
   = note: slice and array elements must have `Sized` type

error: aborting due to 4 previous errors

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