Module dyn_compatibility

“Dyn-compatibility”¹ refers to the ability for a trait to be converted to a trait object. In general, traits may only be converted to a trait object if certain criteria are met.

---

1. Formerly known as “object safety”. ↩

Structs

EraseEscapingBoundRegions 🔒

IllegalRpititVisitor 🔒

IllegalSelfTypeVisitor 🔒

Enums

AllowSelfProjections 🔒

DynCompatibilityViolation

Functions

bounds_reference_self 🔒

check_receiver_correct 🔒

This code checks that receiver_is_dispatchable is correctly implemented.

contains_illegal_impl_trait_in_trait 🔒

contains_illegal_self_type_reference 🔒

This is somewhat subtle. In general, we want to forbid references to Self in the argument and return types, since the value of Self is erased. However, there is one exception: it is ok to reference Self in order to access an associated type of the current trait, since we retain the value of those associated types in the object type itself.

dyn_compatibility_violations 🔒

dyn_compatibility_violations_for_assoc_item

Returns Some(_) if this item makes the containing trait dyn-incompatible.

dyn_compatibility_violations_for_trait 🔒

generics_require_sized_self 🔒

get_sized_bounds 🔒

hir_ty_lowering_dyn_compatibility_violations

Returns the dyn-compatibility violations that affect HIR ty lowering.

is_dyn_compatible 🔒

is_vtable_safe_method

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: Sized or otherwise ensure that they cannot be used when Self = Trait.

object_ty_for_trait 🔒

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.

predicate_references_self 🔒

predicates_reference_self 🔒

provide 🔒

receiver_for_self_ty 🔒

Performs a type instantiation to produce the version of receiver_ty when Self = self_ty. For example, for receiver_ty = Rc<Self> and self_ty = Foo, returns Rc<Foo>.

receiver_is_dispatchable 🔒

Checks the method’s receiver (the self argument) can be dispatched on when Self is a trait object. We require that DispatchableFromDyn be implemented for the receiver type in the following way:

sized_trait_bound_spans 🔒

super_predicates_have_non_lifetime_binders 🔒

trait_has_sized_self 🔒

virtual_call_violations_for_method 🔒

Returns Some(_) if this method cannot be called on a trait object; this does not necessarily imply that the enclosing trait is dyn-incompatible, because the method might have a where clause Self: Sized.