Struct rustc_trait_selection::solve::EvalCtxt

pub struct EvalCtxt<'a, 'tcx> {
    infcx: &'a InferCtxt<'tcx>,
    variables: CanonicalVarInfos<'tcx>,
    pub(super) var_values: CanonicalVarValues<'tcx>,
    predefined_opaques_in_body: PredefinedOpaques<'tcx>,
    pub(super) max_input_universe: UniverseIndex,
    pub(super) search_graph: &'a mut SearchGraph<'tcx>,
    pub(super) nested_goals: NestedGoals<'tcx>,
    tainted: Result<(), NoSolution>,
    pub(super) inspect: ProofTreeBuilder<'tcx>,
}

Fields

infcx: &'a InferCtxt<'tcx>

The inference context that backs (mostly) inference and placeholder terms instantiated while solving goals.

NOTE: The InferCtxt that backs the EvalCtxt is intentionally private, because the InferCtxt is much more general than EvalCtxt. Methods such as take_registered_region_obligations can mess up query responses, using At::normalize is totally wrong, calling evaluate_root_goal can cause coinductive unsoundness, etc.

Methods that are generally of use for trait solving are intentionally re-declared through the EvalCtxt below, often with cleaner signatures since we don’t care about things like ObligationCauses and Spans here. If some InferCtxt method is missing, please first think defensively about the method’s compatibility with this solver, or if an existing one does the job already.

variables: CanonicalVarInfos<'tcx>

The variable info for the var_values, only used to make an ambiguous response with no constraints.

var_values: CanonicalVarValues<'tcx>

predefined_opaques_in_body: PredefinedOpaques<'tcx>

max_input_universe: UniverseIndex

The highest universe index nameable by the caller.

When we enter a new binder inside of the query we create new universes which the caller cannot name. We have to be careful with variables from these new universes when creating the query response.

Both because these new universes can prevent us from reaching a fixpoint if we have a coinductive cycle and because that’s the only way we can return new placeholders to the caller.

search_graph: &'a mut SearchGraph<'tcx>

nested_goals: NestedGoals<'tcx>

tainted: Result<(), NoSolution>

inspect: ProofTreeBuilder<'tcx>

Implementations

impl<'tcx> EvalCtxt<'_, 'tcx>

pub(super) fn compute_alias_relate_goal( &mut self, goal: Goal<'tcx, (Term<'tcx>, Term<'tcx>, AliasRelationDirection)> ) -> QueryResult<'tcx>

fn try_normalize_term( &mut self, param_env: ParamEnv<'tcx>, term: Term<'tcx> ) -> Result<Option<Term<'tcx>>, NoSolution>

Normalize the term to equate it later. This does not define opaque types.

fn define_opaque( &mut self, param_env: ParamEnv<'tcx>, opaque: AliasTy<'tcx>, term: Term<'tcx> ) -> QueryResult<'tcx>

fn relate_rigid_alias_or_opaque( &mut self, param_env: ParamEnv<'tcx>, lhs: AliasTy<'tcx>, variance: Variance, rhs: AliasTy<'tcx> ) -> QueryResult<'tcx>

impl<'tcx> EvalCtxt<'_, 'tcx>

pub(super) fn assemble_and_evaluate_candidates<G: GoalKind<'tcx>>( &mut self, goal: Goal<'tcx, G> ) -> Vec<Candidate<'tcx>>

fn forced_ambiguity(&mut self, cause: MaybeCause) -> Vec<Candidate<'tcx>>

fn assemble_non_blanket_impl_candidates<G: GoalKind<'tcx>>( &mut self, goal: Goal<'tcx, G>, candidates: &mut Vec<Candidate<'tcx>> )

fn assemble_blanket_impl_candidates<G: GoalKind<'tcx>>( &mut self, goal: Goal<'tcx, G>, candidates: &mut Vec<Candidate<'tcx>> )

fn assemble_builtin_impl_candidates<G: GoalKind<'tcx>>( &mut self, goal: Goal<'tcx, G>, candidates: &mut Vec<Candidate<'tcx>> )

fn assemble_param_env_candidates<G: GoalKind<'tcx>>( &mut self, goal: Goal<'tcx, G>, candidates: &mut Vec<Candidate<'tcx>> )

fn assemble_alias_bound_candidates<G: GoalKind<'tcx>>( &mut self, goal: Goal<'tcx, G>, candidates: &mut Vec<Candidate<'tcx>> )

fn assemble_alias_bound_candidates_recur<G: GoalKind<'tcx>>( &mut self, self_ty: Ty<'tcx>, goal: Goal<'tcx, G>, candidates: &mut Vec<Candidate<'tcx>> )

For some deeply nested <T>::A::B::C::D rigid associated type, we should explore the item bounds for all levels, since the associated_type_bounds feature means that a parent associated type may carry bounds for a nested associated type.

If we have a projection, check that its self type is a rigid projection. If so, continue searching by recursively calling after normalization.

pub(super) fn validate_alias_bound_self_from_param_env<G: GoalKind<'tcx>>( &mut self, goal: Goal<'tcx, G> ) -> QueryResult<'tcx>

Check that we are allowed to use an alias bound originating from the self type of this goal. This means something different depending on the self type’s alias kind.

• Projection: Given a goal with a self type such as <Ty as Trait>::Assoc, we require that the bound Ty: Trait can be proven using either a nested alias bound candidate, or a param-env candidate.

• Opaque: The param-env must be in Reveal::UserFacing mode. Otherwise, the goal should be proven by using the hidden type instead.

fn assemble_alias_bound_candidates_for_builtin_impl_default_items<G: GoalKind<'tcx>>( &mut self, goal: Goal<'tcx, G>, candidates: &mut Vec<Candidate<'tcx>> )

Assemble a subset of builtin impl candidates for a class of candidates called “defaulted” built-in traits.

For example, we always know that T: Pointee is implemented, but we do not always know what <T as Pointee>::Metadata actually is! See the comment in EvalCtxt::validate_alias_bound_self_from_param_env for more detail.

fn assemble_object_bound_candidates<G: GoalKind<'tcx>>( &mut self, goal: Goal<'tcx, G>, candidates: &mut Vec<Candidate<'tcx>> )

fn assemble_coherence_unknowable_candidates<G: GoalKind<'tcx>>( &mut self, goal: Goal<'tcx, G>, candidates: &mut Vec<Candidate<'tcx>> )

In coherence we have to not only care about all impls we know about, but also consider impls which may get added in a downstream or sibling crate or which an upstream impl may add in a minor release.

To do so we add an ambiguous candidate in case such an unknown impl could apply to the current goal.

fn discard_impls_shadowed_by_env<G: GoalKind<'tcx>>( &mut self, goal: Goal<'tcx, G>, candidates: &mut Vec<Candidate<'tcx>> )

If there’s a where-bound for the current goal, do not use any impl candidates to prove the current goal. Most importantly, if there is a where-bound which does not specify any associated types, we do not allow normalizing the associated type by using an impl, even if it would apply.

https://github.com/rust-lang/trait-system-refactor-initiative/issues/76

pub(super) fn merge_candidates( &mut self, candidates: Vec<Candidate<'tcx>> ) -> QueryResult<'tcx>

If there are multiple ways to prove a trait or projection goal, we have to somehow try to merge the candidates into one. If that fails, we return ambiguity.

impl<'tcx> EvalCtxt<'_, 'tcx>

pub(super) fn canonicalize_goal<T: TypeFoldable<TyCtxt<'tcx>>>( &self, goal: Goal<'tcx, T> ) -> (Vec<GenericArg<'tcx>>, CanonicalInput<'tcx, T>)

Canonicalizes the goal remembering the original values for each bound variable.

pub(in solve) fn evaluate_added_goals_and_make_canonical_response( &mut self, certainty: Certainty ) -> QueryResult<'tcx>

To return the constraints of a canonical query to the caller, we canonicalize:

• var_values: a map from bound variables in the canonical goal to the values inferred while solving the instantiated goal.
• external_constraints: additional constraints which aren’t expressible using simple unification of inference variables.

pub(in solve) fn make_ambiguous_response_no_constraints( &self, maybe_cause: MaybeCause ) -> CanonicalResponse<'tcx>

Constructs a totally unconstrained, ambiguous response to a goal.

Take care when using this, since often it’s useful to respond with ambiguity but return constrained variables to guide inference.

fn compute_external_query_constraints( &self ) -> Result<ExternalConstraintsData<'tcx>, NoSolution>

Computes the region constraints and new opaque types registered when proving a goal.

If an opaque was already constrained before proving this goal, then the external constraints do not need to record that opaque, since if it is further constrained by inference, that will be passed back in the var values.

pub(super) fn instantiate_and_apply_query_response( &mut self, param_env: ParamEnv<'tcx>, original_values: Vec<GenericArg<'tcx>>, response: CanonicalResponse<'tcx> ) -> Result<(Certainty, Vec<Goal<'tcx, Predicate<'tcx>>>), NoSolution>

After calling a canonical query, we apply the constraints returned by the query using this function.

This happens in three steps:

• we instantiate the bound variables of the query response
• we unify the var_values of the response with the original_values
• we apply the external_constraints returned by the query

fn compute_query_response_substitution<T: ResponseT<'tcx>>( infcx: &InferCtxt<'tcx>, original_values: &[GenericArg<'tcx>], response: &Canonical<'tcx, T> ) -> CanonicalVarValues<'tcx>

This returns the substitutions to instantiate the bound variables of the canonical response. This depends on the original_values for the bound variables.

fn unify_query_var_values( infcx: &InferCtxt<'tcx>, param_env: ParamEnv<'tcx>, original_values: &[GenericArg<'tcx>], var_values: CanonicalVarValues<'tcx> ) -> Result<Vec<Goal<'tcx, Predicate<'tcx>>>, NoSolution>

fn register_region_constraints( &mut self, region_constraints: &QueryRegionConstraints<'tcx> )

fn register_opaque_types( &mut self, param_env: ParamEnv<'tcx>, opaque_types: &[(OpaqueTypeKey<'tcx>, Ty<'tcx>)] ) -> Result<(), NoSolution>

impl<'a, 'tcx> EvalCtxt<'a, 'tcx>

pub(in solve) fn commit_if_ok<T>( &mut self, f: impl FnOnce(&mut EvalCtxt<'_, 'tcx>) -> Result<T, NoSolution> ) -> Result<T, NoSolution>

impl<'a, 'tcx> EvalCtxt<'a, 'tcx>

pub(in solve) fn probe<F, T>( &mut self, probe_kind: F ) -> ProbeCtxt<'_, 'a, 'tcx, F, T>

where F: FnOnce(&T) -> ProbeKind<'tcx>,

probe_kind is only called when proof tree building is enabled so it can be as expensive as necessary to output the desired information.

pub(in solve) fn probe_misc_candidate( &mut self, name: &'static str ) -> ProbeCtxt<'_, 'a, 'tcx, impl FnOnce(&QueryResult<'tcx>) -> ProbeKind<'tcx>, QueryResult<'tcx>>

pub(in solve) fn probe_trait_candidate( &mut self, source: CandidateSource ) -> TraitProbeCtxt<'_, 'a, 'tcx, impl FnOnce(&QueryResult<'tcx>) -> ProbeKind<'tcx>>

impl<'tcx> EvalCtxt<'_, 'tcx>

fn compute_canonical_trait_candidates( &mut self, canonical_input: CanonicalInput<'tcx> ) -> Vec<Candidate<'tcx>>

impl<'a, 'tcx> EvalCtxt<'a, 'tcx>

pub(super) fn solver_mode(&self) -> SolverMode

pub(super) fn local_overflow_limit(&self) -> usize

fn enter_root<R>( infcx: &InferCtxt<'tcx>, generate_proof_tree: GenerateProofTree, f: impl FnOnce(&mut EvalCtxt<'_, 'tcx>) -> R ) -> (R, Option<GoalEvaluation<'tcx>>)

Creates a root evaluation context and search graph. This should only be used from outside of any evaluation, and other methods should be preferred over using this manually (such as InferCtxtEvalExt::evaluate_root_goal).

fn enter_canonical<R>( tcx: TyCtxt<'tcx>, search_graph: &'a mut SearchGraph<'tcx>, canonical_input: CanonicalInput<'tcx>, canonical_goal_evaluation: &mut ProofTreeBuilder<'tcx>, f: impl FnOnce(&mut EvalCtxt<'_, 'tcx>, Goal<'tcx, Predicate<'tcx>>) -> R ) -> R

Creates a nested evaluation context that shares the same search graph as the one passed in. This is suitable for evaluation, granted that the search graph has had the nested goal recorded on its stack (SearchGraph::with_new_goal), but it’s preferable to use other methods that call this one rather than this method directly.

This function takes care of setting up the inference context, setting the anchor, and registering opaques from the canonicalized input.

fn evaluate_canonical_goal( tcx: TyCtxt<'tcx>, search_graph: &'a mut SearchGraph<'tcx>, canonical_input: CanonicalInput<'tcx>, goal_evaluation: &mut ProofTreeBuilder<'tcx> ) -> QueryResult<'tcx>

The entry point of the solver.

This function deals with (coinductive) cycles, overflow, and caching and then calls EvalCtxt::compute_goal which contains the actual logic of the solver.

Instead of calling this function directly, use either EvalCtxt::evaluate_goal if you’re inside of the solver or InferCtxtEvalExt::evaluate_root_goal if you’re outside of it.

fn evaluate_goal( &mut self, goal_evaluation_kind: GoalEvaluationKind, source: GoalSource, goal: Goal<'tcx, Predicate<'tcx>> ) -> Result<(bool, Certainty, Vec<Goal<'tcx, Predicate<'tcx>>>), NoSolution>

Recursively evaluates goal, returning whether any inference vars have been constrained and the certainty of the result.

fn instantiate_response_discarding_overflow( &mut self, param_env: ParamEnv<'tcx>, source: GoalSource, original_values: Vec<GenericArg<'tcx>>, response: CanonicalResponse<'tcx> ) -> Result<(Certainty, bool, Vec<Goal<'tcx, Predicate<'tcx>>>), NoSolution>

fn compute_goal( &mut self, goal: Goal<'tcx, Predicate<'tcx>> ) -> QueryResult<'tcx>

pub(super) fn try_evaluate_added_goals( &mut self ) -> Result<Certainty, NoSolution>

fn evaluate_added_goals_step(&mut self) -> Result<Option<Certainty>, NoSolution>

Iterate over all added goals: returning Ok(Some(_)) in case we can stop rerunning.

Goals for the next step get directly added to the nested goals of the EvalCtxt.

impl<'tcx> EvalCtxt<'_, 'tcx>

pub(super) fn tcx(&self) -> TyCtxt<'tcx>

pub(super) fn next_ty_infer(&self) -> Ty<'tcx>

pub(super) fn next_const_infer(&self, ty: Ty<'tcx>) -> Const<'tcx>

pub(super) fn next_term_infer_of_kind(&self, kind: Term<'tcx>) -> Term<'tcx>

Returns a ty infer or a const infer depending on whether kind is a Ty or Const. If kind is an integer inference variable this will still return a ty infer var.

pub(super) fn term_is_fully_unconstrained( &self, goal: Goal<'tcx, NormalizesTo<'tcx>> ) -> bool

Is the projection predicate is of the form exists<T> <Ty as Trait>::Assoc = T.

This is the case if the term is an inference variable in the innermost universe and does not occur in any other part of the predicate.

pub(super) fn eq<T: ToTrace<'tcx>>( &mut self, param_env: ParamEnv<'tcx>, lhs: T, rhs: T ) -> Result<(), NoSolution>

pub(super) fn sub<T: ToTrace<'tcx>>( &mut self, param_env: ParamEnv<'tcx>, sub: T, sup: T ) -> Result<(), NoSolution>

pub(super) fn relate<T: ToTrace<'tcx>>( &mut self, param_env: ParamEnv<'tcx>, lhs: T, variance: Variance, rhs: T ) -> Result<(), NoSolution>

pub(super) fn eq_and_get_goals<T: ToTrace<'tcx>>( &self, param_env: ParamEnv<'tcx>, lhs: T, rhs: T ) -> Result<Vec<Goal<'tcx, Predicate<'tcx>>>, NoSolution>

Equates two values returning the nested goals without adding them to the nested goals of the EvalCtxt.

If possible, try using eq instead which automatically handles nested goals correctly.

pub(super) fn instantiate_binder_with_infer<T: TypeFoldable<TyCtxt<'tcx>> + Copy>( &self, value: Binder<'tcx, T> ) -> T

pub(super) fn enter_forall<T: TypeFoldable<TyCtxt<'tcx>> + Copy, U>( &self, value: Binder<'tcx, T>, f: impl FnOnce(T) -> U ) -> U

pub(super) fn resolve_vars_if_possible<T>(&self, value: T) -> T

where T: TypeFoldable<TyCtxt<'tcx>>,

pub(super) fn fresh_args_for_item(&self, def_id: DefId) -> GenericArgsRef<'tcx>

pub(super) fn translate_args( &self, param_env: ParamEnv<'tcx>, source_impl: DefId, source_args: GenericArgsRef<'tcx>, target_node: Node ) -> GenericArgsRef<'tcx>

pub(super) fn register_ty_outlives(&self, ty: Ty<'tcx>, lt: Region<'tcx>)

pub(super) fn register_region_outlives(&self, a: Region<'tcx>, b: Region<'tcx>)

pub(super) fn well_formed_goals( &self, param_env: ParamEnv<'tcx>, arg: GenericArg<'tcx> ) -> Option<impl Iterator<Item = Goal<'tcx, Predicate<'tcx>>>>

Computes the list of goals required for arg to be well-formed

pub(super) fn is_transmutable( &self, src_and_dst: Types<'tcx>, scope: Ty<'tcx>, assume: Assume ) -> Result<Certainty, NoSolution>

pub(super) fn can_define_opaque_ty(&self, def_id: LocalDefId) -> bool

pub(super) fn insert_hidden_type( &mut self, opaque_type_key: OpaqueTypeKey<'tcx>, param_env: ParamEnv<'tcx>, hidden_ty: Ty<'tcx> ) -> Result<(), NoSolution>

pub(super) fn add_item_bounds_for_hidden_type( &mut self, opaque_def_id: DefId, opaque_args: GenericArgsRef<'tcx>, param_env: ParamEnv<'tcx>, hidden_ty: Ty<'tcx> )

pub(super) fn unify_existing_opaque_tys( &mut self, param_env: ParamEnv<'tcx>, key: OpaqueTypeKey<'tcx>, ty: Ty<'tcx> ) -> Vec<CanonicalResponse<'tcx>>

pub(super) fn try_const_eval_resolve( &self, param_env: ParamEnv<'tcx>, unevaluated: UnevaluatedConst<'tcx>, ty: Ty<'tcx> ) -> Option<Const<'tcx>>

pub(super) fn walk_vtable( &mut self, principal: PolyTraitRef<'tcx>, supertrait_visitor: impl FnMut(&mut Self, PolyTraitRef<'tcx>, usize, Option<usize>) )

Walk through the vtable of a principal trait ref, executing a supertrait_visitor for every trait ref encountered (including the principal). Passes both the vtable base and the (optional) vptr slot.

impl<'tcx> EvalCtxt<'_, 'tcx>

pub(super) fn normalize_inherent_associated_type( &mut self, goal: Goal<'tcx, NormalizesTo<'tcx>> ) -> QueryResult<'tcx>

impl<'tcx> EvalCtxt<'_, 'tcx>

pub(super) fn normalize_opaque_type( &mut self, goal: Goal<'tcx, NormalizesTo<'tcx>> ) -> QueryResult<'tcx>

impl<'tcx> EvalCtxt<'_, 'tcx>

pub(super) fn normalize_weak_type( &mut self, goal: Goal<'tcx, NormalizesTo<'tcx>> ) -> QueryResult<'tcx>

impl<'tcx> EvalCtxt<'_, 'tcx>

pub(super) fn compute_normalizes_to_goal( &mut self, goal: Goal<'tcx, NormalizesTo<'tcx>> ) -> QueryResult<'tcx>

fn normalize_anon_const( &mut self, goal: Goal<'tcx, NormalizesTo<'tcx>> ) -> QueryResult<'tcx>

impl<'tcx> EvalCtxt<'_, 'tcx>

pub(super) fn compute_projection_goal( &mut self, goal: Goal<'tcx, ProjectionPredicate<'tcx>> ) -> QueryResult<'tcx>

impl<'tcx> EvalCtxt<'_, 'tcx>

fn consider_builtin_dyn_upcast_candidates( &mut self, goal: Goal<'tcx, (Ty<'tcx>, Ty<'tcx>)>, a_data: &'tcx List<PolyExistentialPredicate<'tcx>>, a_region: Region<'tcx>, b_data: &'tcx List<PolyExistentialPredicate<'tcx>>, b_region: Region<'tcx> ) -> Vec<(CanonicalResponse<'tcx>, BuiltinImplSource)>

Trait upcasting allows for coercions between trait objects:

trait Super {}
trait Trait: Super {}
// results in builtin impls upcasting to a super trait
impl<'a, 'b: 'a> Unsize<dyn Super + 'a> for dyn Trait + 'b {}
// and impls removing auto trait bounds.
impl<'a, 'b: 'a> Unsize<dyn Trait + 'a> for dyn Trait + Send + 'b {}

fn consider_builtin_unsize_to_dyn_candidate( &mut self, goal: Goal<'tcx, (Ty<'tcx>, Ty<'tcx>)>, b_data: &'tcx List<PolyExistentialPredicate<'tcx>>, b_region: Region<'tcx> ) -> QueryResult<'tcx>

fn consider_builtin_upcast_to_principal( &mut self, goal: Goal<'tcx, (Ty<'tcx>, Ty<'tcx>)>, a_data: &'tcx List<PolyExistentialPredicate<'tcx>>, a_region: Region<'tcx>, b_data: &'tcx List<PolyExistentialPredicate<'tcx>>, b_region: Region<'tcx>, upcast_principal: Option<PolyExistentialTraitRef<'tcx>> ) -> QueryResult<'tcx>

fn consider_builtin_array_unsize( &mut self, goal: Goal<'tcx, (Ty<'tcx>, Ty<'tcx>)>, a_elem_ty: Ty<'tcx>, b_elem_ty: Ty<'tcx> ) -> QueryResult<'tcx>

We have the following builtin impls for arrays:

impl<T: ?Sized, const N: usize> Unsize<[T]> for [T; N] {}

While the impl itself could theoretically not be builtin, the actual unsizing behavior is builtin. Its also easier to make all impls of Unsize builtin as we’re able to use #[rustc_deny_explicit_impl] in this case.

fn consider_builtin_struct_unsize( &mut self, goal: Goal<'tcx, (Ty<'tcx>, Ty<'tcx>)>, def: AdtDef<'tcx>, a_args: GenericArgsRef<'tcx>, b_args: GenericArgsRef<'tcx> ) -> QueryResult<'tcx>

We generate a builtin Unsize impls for structs with generic parameters only mentioned by the last field.

struct Foo<T, U: ?Sized> {
    sized_field: Vec<T>,
    unsizable: Box<U>,
}
// results in the following builtin impl
impl<T: ?Sized, U: ?Sized, V: ?Sized> Unsize<Foo<T, V>> for Foo<T, U>
where
    Box<U>: Unsize<Box<V>>,
{}

fn consider_builtin_tuple_unsize( &mut self, goal: Goal<'tcx, (Ty<'tcx>, Ty<'tcx>)>, a_tys: &'tcx List<Ty<'tcx>>, b_tys: &'tcx List<Ty<'tcx>> ) -> QueryResult<'tcx>

We generate the following builtin impl for tuples of all sizes.

This impl is still unstable and we emit a feature error when it when it is used by a coercion.

impl<T: ?Sized, U: ?Sized, V: ?Sized> Unsize<(T, V)> for (T, U)
where
    U: Unsize<V>,
{}

fn disqualify_auto_trait_candidate_due_to_possible_impl( &mut self, goal: Goal<'tcx, TraitPredicate<'tcx>> ) -> Option<QueryResult<'tcx>>

fn probe_and_evaluate_goal_for_constituent_tys( &mut self, goal: Goal<'tcx, TraitPredicate<'tcx>>, constituent_tys: impl Fn(&EvalCtxt<'_, 'tcx>, Ty<'tcx>) -> Result<Vec<Binder<'tcx, Ty<'tcx>>>, NoSolution> ) -> QueryResult<'tcx>

Convenience function for traits that are structural, i.e. that only have nested subgoals that only change the self type. Unlike other evaluate-like helpers, this does a probe, so it doesn’t need to be wrapped in one.

pub(super) fn compute_trait_goal( &mut self, goal: Goal<'tcx, TraitPredicate<'tcx>> ) -> QueryResult<'tcx>

impl<'a, 'tcx> EvalCtxt<'a, 'tcx>

fn compute_type_outlives_goal( &mut self, goal: Goal<'tcx, TypeOutlivesPredicate<'tcx>> ) -> QueryResult<'tcx>

fn compute_region_outlives_goal( &mut self, goal: Goal<'tcx, RegionOutlivesPredicate<'tcx>> ) -> QueryResult<'tcx>

fn compute_coerce_goal( &mut self, goal: Goal<'tcx, CoercePredicate<'tcx>> ) -> QueryResult<'tcx>

fn compute_subtype_goal( &mut self, goal: Goal<'tcx, SubtypePredicate<'tcx>> ) -> QueryResult<'tcx>

fn compute_object_safe_goal(&mut self, trait_def_id: DefId) -> QueryResult<'tcx>

fn compute_well_formed_goal( &mut self, goal: Goal<'tcx, GenericArg<'tcx>> ) -> QueryResult<'tcx>

fn compute_const_evaluatable_goal( &mut self, _: Goal<'tcx, Const<'tcx>> ) -> QueryResult<'tcx>

fn compute_const_arg_has_type_goal( &mut self, goal: Goal<'tcx, (Const<'tcx>, Ty<'tcx>)> ) -> QueryResult<'tcx>

impl<'tcx> EvalCtxt<'_, 'tcx>

fn set_normalizes_to_hack_goal(&mut self, goal: Goal<'tcx, NormalizesTo<'tcx>>)

fn add_goal(&mut self, source: GoalSource, goal: Goal<'tcx, Predicate<'tcx>>)

fn add_goals( &mut self, source: GoalSource, goals: impl IntoIterator<Item = Goal<'tcx, Predicate<'tcx>>> )

fn try_merge_responses( &mut self, responses: &[CanonicalResponse<'tcx>] ) -> Option<CanonicalResponse<'tcx>>

Try to merge multiple possible ways to prove a goal, if that is not possible returns None.

In this case we tend to flounder and return ambiguity by calling [EvalCtxt::flounder].

fn flounder( &mut self, responses: &[CanonicalResponse<'tcx>] ) -> QueryResult<'tcx>

If we fail to merge responses we flounder and return overflow or ambiguity.

fn try_normalize_ty( &mut self, param_env: ParamEnv<'tcx>, ty: Ty<'tcx> ) -> Option<Ty<'tcx>>

Normalize a type when it is structually matched on.

In nearly all cases this function must be used before matching on a type. Not doing so is likely to be incomplete and therefore unsound during coherence.

fn try_normalize_ty_recur( &mut self, param_env: ParamEnv<'tcx>, define_opaque_types: DefineOpaqueTypes, depth: usize, ty: Ty<'tcx> ) -> Option<Ty<'tcx>>

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 112 bytes