better error message when using `dyn` type

[nikomatsakis]

The error that you get when using a dyn type with a fn that expects a Sized type parameter is not particularly enlightening:

#![feature(dyn_trait)]

trait Something { }
impl Something for () { }

fn foo<T: Something>(_: &T) { }

fn main() {
    let x: &dyn Something = &();
    foo(x);
}

yields:

error[E0277]: the trait bound `Something: std::marker::Sized` is not satisfied
  --> src/main.rs:10:5
   |
10 |     foo(x);
   |     ^^^ `Something` does not have a constant size known at compile-time
   |
   = help: the trait `std::marker::Sized` is not implemented for `Something`
   = note: required by `foo`

This came up when attempting to do some refactorings to use a dyn Trait where previously we had used a type parameter. I'm not exactly sure what sort of error we should report here -- but it seems like it'd be nice to talk about the definition site.

[arielb1]

Feels like we should change the printout to complain about dyn Something: Sized.

[nikomatsakis]

@arielb1 also true!

[gaurikholkar-zz]

Any updates on this?

[nikomatsakis]

Nope, but I definitely think this is something we should do.

cc @withoutboats -- this is precisely the kind of bad Sized error message we were talking about before. Any idea what you think it ought to say?

[withoutboats]

Its a pretty interesting case. Certainly Ariel's suggestion is a strict improvement:

= help: the trait `std::marker::Sized` is not implemented for `dyn Something`

The most common thing people do when they see the current error message, in my experience, is add a Sized bound to trait Something, which just digs them in deeper. Saying dyn Something makes this a bit less likely, because they're more likely to see that the problem is with the object type and not the trait itself.

But the real problem here is that users don't realize that foo requires T: Sized, because you don't write out : Sized explicitly.

Possibly the correct approach is to invert this error message for Sized. With most traits, saying the type you instantiated with does not implement the trait is the helpful message. Here, the issue is that the function cannot take types like the one you passed.

I'm not great at error messages, but the idea I think we want to express is:

• This type parameter cannot be instantiated to dyn Something
• Because this type parameter cannot be instantiated to ?Sized types
• Try changing it to T: ?Sized + Something

[nikomatsakis]

@withoutboats

But the real problem here is that users don't realize that foo requires T: Sized, because you don't write out : Sized explicitly.

Hmm, yes. We can certainly try to dig in and offer some tips about the declaration site of T, at least if it's crate-local.

[nikomatsakis]

Maybe just something like "note that the Sized bound is implicit unless a type parameter is decorated with ?Sized

[estebank]

Current output:

error[E0277]: the size for values of type `dyn Something` cannot be known at compilation time
  --> src/main.rs:10:5
   |
10 |     foo(x);
   |     ^^^ doesn't have a size known at compile-time
   |
   = help: the trait `std::marker::Sized` is not implemented for `dyn Something`
   = 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 `foo`
  --> src/main.rs:6:1
   |
6  | fn foo<T: Something>(_: &T) { }
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^

---

Update:

error[E0277]: the size for values of type `dyn Something` cannot be known at compilation time
  --> src/main.rs:10:9
   |
6  | fn foo<T: Something>(_: &T) { }
   |    --- - required by this bound in `foo`
...
10 |     foo(x);
   |         ^ doesn't have a size known at compile-time
   |
   = help: the trait `std::marker::Sized` is not implemented for `dyn Something`
   = note: to learn more, visit <https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait>

[estebank]

I think this is a duplicate of #57744.