“Object safety” refers to the ability for a trait to be converted to an object. In general, traits may only be converted to an object if all of their methods meet certain criteria. In particular, they must:
- have a suitable receiver from which we can extract a vtable and coerce to a “thin” version that doesn’t contain the vtable;
- not reference the erased type
Selfexcept for in this receiver;
- not have generic type parameters.
- Reasons a method might not be object-safe.
- Returns the object safety violations that affect astconv – currently,
Selfin supertraits. This is needed because
object_safety_violationscan’t be used during type collection.
- We say a method is vtable safe if it can be invoked on a trait object. Note that object-safe traits can have some non-vtable-safe methods, so long as they require
Self: Sizedor otherwise ensure that they cannot be used when
Self = Trait.
- Lint object-unsafe trait.
Some(_)if this item makes the containing trait not object safe.
- Creates the object type for the current trait. For example, if the current trait is
Deref, then this will be
dyn Deref<Target = Self::Target> + 'static.
- Performs a type substitution to produce the version of
Self = self_ty. For example, for
receiver_ty = Rc<Self>and
self_ty = Foo, returns
- Checks the method’s receiver (the
selfargument) can be dispatched on when
Selfis a trait object. We require that
DispatchableFromDynbe implemented for the receiver type in the following way:
Some(_)if this method cannot be called on a trait object; this does not necessarily imply that the enclosing trait is not object safe, because the method might have a where clause