Module rustc_trait_selection::traits::project

Code for projecting associated types out of trait references.

Structs

AssocTypeNormalizer
InProgress
Progress

Enums

ProjectedTy
ProjectionTyCandidate
ProjectionTyCandidateSet
ProjectionTyError	When attempting to resolve <T as TraitRef>::Name ...
Reveal	Depending on the stage of compilation, we want projection to be more or less conservative.

Traits

ProjectionCacheKeyExt

Functions

assemble_candidates_from_impls
assemble_candidates_from_object_ty	In the case of a trait object like <dyn Iterator<Item = ()> as Iterator>::Item we can use the existential predicate in the trait object.
assemble_candidates_from_param_env	The first thing we have to do is scan through the parameter environment to see whether there are any projection predicates there that can answer this question.
assemble_candidates_from_predicates
assemble_candidates_from_trait_def	In the case of a nested projection like <::FooT as Bar>::BarT, we may find that the definition of Foo has some clues:
assoc_ty_def	Locate the definition of an associated type in the specialization hierarchy, starting from the given impl.
assoc_ty_own_obligations
confirm_callable_candidate
confirm_candidate
confirm_closure_candidate
confirm_discriminant_kind_candidate
confirm_fn_pointer_candidate
confirm_generator_candidate
confirm_impl_candidate
confirm_param_env_candidate
confirm_select_candidate
normalize	Normalizes any associated type projections in value, replacing them with a fully resolved type where possible. The return value combines the normalized result and any additional obligations that were incurred as result.
normalize_projection_type	The guts of normalize: normalize a specific projection like <T as Trait>::Item. The result is always a type (and possibly additional obligations). If ambiguity arises, which implies that there are unresolved type variables in the projection, we will substitute a fresh type variable $X and generate a new obligation <T as Trait>::Item == $X for later.
normalize_to
normalize_to_error	If we are projecting <T as Trait>::Item, but T: Trait does not hold. In various error cases, we cannot generate a valid normalized projection. Therefore, we create an inference variable return an associated obligation that, when fulfilled, will lead to an error.
normalize_with_depth	As normalize, but with a custom depth.
normalize_with_depth_to
opt_normalize_projection_type	The guts of normalize: normalize a specific projection like <T as Trait>::Item. The result is always a type (and possibly additional obligations). Returns None in the case of ambiguity, which indicates that there are unbound type variables.
poly_project_and_unify_type	Evaluates constraints of the form:
project_and_unify_type	Evaluates constraints of the form:
project_type	Computes the result of a projection type (if we can).
prune_cache_value_obligations	If there are unresolved type variables, then we need to include any subobligations that bind them, at least until those type variables are fully resolved.

Type Definitions

PolyProjectionObligation
ProjectionObligation
ProjectionTyObligation