Module project 

Code for projecting associated types out of trait references.

Structs

InProgress 🔒

Progress 🔒

Enums

ProjectAndUnifyResult 🔒

States returned from poly_project_and_unify_type. Takes the place of the old return type, which was:

Projected 🔒

ProjectionCandidate 🔒

ProjectionCandidateSet 🔒

ProjectionError

When attempting to resolve <T as TraitRef>::Name …

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 <<A as Foo>::FooT as Bar>::BarT, we may find that the definition of Foo has some clues:

assoc_term_own_obligations 🔒

compute_inherent_assoc_term_args

confirm_async_closure_candidate 🔒

confirm_async_fn_kind_helper_candidate 🔒

confirm_async_iterator_candidate 🔒

confirm_builtin_candidate 🔒

confirm_callable_candidate 🔒

confirm_candidate 🔒

confirm_closure_candidate 🔒

confirm_coroutine_candidate 🔒

confirm_fn_pointer_candidate 🔒

confirm_future_candidate 🔒

confirm_impl_candidate 🔒

confirm_iterator_candidate 🔒

confirm_param_env_candidate 🔒

confirm_select_candidate 🔒

normalize_inherent_projection

Confirm and normalize the given inherent projection.

normalize_projection_term

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 instantiate it with a fresh type variable $X and generate a new obligation <T as Trait>::Item == $X for later.

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.

opt_normalize_projection_term 🔒

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_term 🔒

Evaluates constraints of the form:

project 🔒

Computes the result of a projection type (if we can).

project_and_unify_term 🔒

Evaluates constraints of the form:

push_const_arg_has_type_obligation 🔒

When normalizing a const alias, register a ConstArgHasType obligation to ensure the const value’s type matches the declared type.

Type Aliases

PolyProjectionObligation

ProjectionObligation

ProjectionTermObligation