Module project 

Code for projecting associated types out of trait references.

Re-exports

use std::ops::ControlFlow; 🔒

use rustc_attr_ir::lang_items::LangItem; 🔒

use rustc_data_structures::sso::SsoHashSet; 🔒

use rustc_errors::ErrorGuaranteed; 🔒

use rustc_hir::def_id::DefId; 🔒

use rustc_infer::infer::DefineOpaqueTypes; 🔒

use rustc_infer::traits::ObligationCauseCode; 🔒

use rustc_infer::traits::PredicateObligations; 🔒

use rustc_middle::traits::select::OverflowError; 🔒

use rustc_middle::traits::BuiltinImplSource; 🔒

use rustc_middle::traits::ImplSource; 🔒

use rustc_middle::traits::ImplSourceUserDefinedData; 🔒

use rustc_middle::ty::fast_reject::DeepRejectCtxt; 🔒

use rustc_middle::ty; 🔒

use rustc_middle::ty::CallerBoundsIterator; 🔒

use rustc_middle::ty::FieldInfo; 🔒

use rustc_middle::ty::Term; 🔒

use rustc_middle::ty::Ty; 🔒

use rustc_middle::ty::TyCtxt; 🔒

use rustc_middle::ty::TypeVisitableExt; 🔒

use rustc_middle::ty::TypingMode; 🔒

use rustc_middle::ty::Unnormalized; 🔒

use rustc_middle::ty::Upcast; 🔒

use rustc_span::bug; 🔒

use rustc_span::span_bug; 🔒

use rustc_span::sym; 🔒

use tracing::debug; 🔒

use tracing::instrument; 🔒

use tracing::instrument; 🔒

use super::MismatchedProjectionTypes; 🔒

use super::Normalized; 🔒

use super::NormalizedTerm; 🔒

use super::Obligation; 🔒

use super::ObligationCause; 🔒

use super::PredicateObligation; 🔒

use super::ProjectionCacheEntry; 🔒

use super::ProjectionCacheKey; 🔒

use super::Selection; 🔒

use super::SelectionContext; 🔒

use super::SelectionError; 🔒

use super::specialization_graph; 🔒

use super::translate_args; 🔒

use super::util; 🔒

use crate::diagnostics::InherentProjectionNormalizationOverflow; 🔒

use crate::error_reporting::traits::report_dyn_incompatibility; 🔒

use crate::infer::BoundRegionConversionTime; 🔒

use crate::infer::InferOk; 🔒

use crate::traits::normalize::normalize_with_depth; 🔒

use crate::traits::normalize::normalize_with_depth_to; 🔒

use crate::traits::query::evaluate_obligation::InferCtxtExt as _; 🔒

use crate::traits::select::ProjectionMatchesProjection; 🔒

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

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

const_of_item_or_delayed_bug

The old solver does not support references to non-type-consts. Emit a delayed bug if there is a type system reference to a non type const, as this should have already errored elsewhere.

coroutine_closure_output_coroutine 🔒

Given a CoroutineClosure(def_id, args), interpret it as a closure, and return its output type for the given goal_kind and env_region.

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