error[E0038]: the trait `Bar` cannot be made into an object
  --> $DIR/issue-48027.rs:6:6
   |
LL | impl dyn Bar {}
   |      ^^^^^^^ `Bar` cannot be made into an object
   |
note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
  --> $DIR/issue-48027.rs:2:11
   |
LL | trait Bar {
   |       --- this trait cannot be made into an object...
LL |     const X: usize;
   |           ^ ...because it contains this associated `const`
   = help: consider moving `X` to another trait

error[E0790]: cannot refer to the associated constant on trait without specifying the corresponding `impl` type
  --> $DIR/issue-48027.rs:3:32
   |
LL |     const X: usize;
   |     --------------- `Bar::X` defined here
LL |     fn return_n(&self) -> [u8; Bar::X];
   |                                ^^^^^^ cannot refer to the associated constant of trait

error: aborting due to 2 previous errors

Some errors have detailed explanations: E0038, E0790.
For more information about an error, try `rustc --explain E0038`.
