Require that objects can only be made from Sized types. Fixes #18333.

[nikomatsakis]

In the general case, at least, it is not possible to make an object out of an unsized type. This is because the object type would have to store the fat pointer information for the self value and the vtable -- meaning it'd have to be a fat pointer with three words -- but for the compiler to know that the object requires three words, it would have to know the self-type of the object (is self a thin or fat pointer?), which of course it doesn't.

Fixes #18333.

r? @nick29581

[sfackler]

Tidy error: https://travis-ci.org/rust-lang/rust/builds/40339122#L310

[mathstuf]

Would it be possible to relax it such that if I have a reference to a trait, I can make a reference to the trait?

Example:

trait T {
    fn t(&self) -> &T {
        &self
    }
}

[nikomatsakis]

@mathstuf I'm afraid that is not possible, but you can do this:

trait T {
    fn t(&self) -> &T where Self: Sized { &self }
}

[mathstuf]

That comes up with this error:

error[E0277]: the trait bound `&Self: T` is not satisfied
 --> <anon>:2:41
  |
2 |   fn t(&self) -> &T where Self: Sized { &self }
  |                                         ^^^^^
  |
  = note: required for the cast to the object type `T`

error: aborting due to previous error

[nikomatsakis]

@mathstuf sorry, my mistake, I didn't notice that you had written &self. Try this:

trait T {
    fn t(&self) -> &T where Self: Sized { self } // self, not &self
}

In particular, when you return &self you are trying to convert a &&Self pointer into an &T object, but you want to convert an &Self pointer into an &T object.

[mathstuf]

That doesn't work because I can't do this:

let my_t: &T = some_ref(s);
my.t(); // since `T` is just a reference, we don't have `Sized`

[nikomatsakis]

@mathstuf well, it depends on what you are trying to do =) I should have made it clear that what I wrote will allow you to make an object if you don't have one already, but it will fail if you may have one already. If you want to support that, it's a bit more annoying. You basically need an operation that applies to the reference as a whole, I think:

trait ToTObject<'a> {
    fn to_object(self) -> &'a T;
}

impl<'a> ToObject<'a> for &'a T {
    fn to_object(self) -> &'a T { self }
}

impl<'a,U: T> ToObject<'a> for &'a U {
    fn to_object(self) -> &'a T { self }
}

The point here is that the first impl doesn't do any coercion (it already has an object), and the second impl does (it has a &U for some sized U). It'd be nice to make this smoother, no doubt.

[mathstuf]

My current workaround is:

trait T {
  fn t<'a>(&'a self) -> SomeStruct<'a> { SomeStruct { t: self._self_ref_hack() } }
  fn _self_ref_hack(&self) -> &T;
}