Struct rustc_trait_selection::traits::SelectionContext

pub struct SelectionContext<'cx, 'tcx> {
    infcx: &'cx InferCtxt<'cx, 'tcx>,
    freshener: TypeFreshener<'cx, 'tcx>,
    intercrate: bool,
    intercrate_ambiguity_causes: Option<FxIndexSet<IntercrateAmbiguityCause>>,
    query_mode: TraitQueryMode,
}

Fields

infcx: &'cx InferCtxt<'cx, 'tcx>

freshener: TypeFreshener<'cx, 'tcx>

Freshener used specifically for entries on the obligation stack. This ensures that all entries on the stack at one time will have the same set of placeholder entries, which is important for checking for trait bounds that recursively require themselves.

intercrate: bool

During coherence we have to assume that other crates may add additional impls which we currently don’t know about.

To deal with this evaluation should be conservative and consider the possibility of impls from outside this crate. This comes up primarily when resolving ambiguity. Imagine there is some trait reference $0: Bar where $0 is an inference variable. If intercrate is true, then we can never say for sure that this reference is not implemented, even if there are no impls at all for Bar, because $0 could be bound to some type that in a downstream crate that implements Bar.

Outside of coherence we set this to false because we are only interested in types that the user could actually have written. In other words, we consider $0: Bar to be unimplemented if there is no type that the user could actually name that would satisfy it. This avoids crippling inference, basically.

intercrate_ambiguity_causes: Option<FxIndexSet<IntercrateAmbiguityCause>>

If intercrate is set, we remember predicates which were considered ambiguous because of impls potentially added in other crates. This is used in coherence to give improved diagnostics. We don’t do his until we detect a coherence error because it can lead to false overflow results (#47139) and because always computing it may negatively impact performance.

query_mode: TraitQueryMode

The mode that trait queries run in, which informs our error handling policy. In essence, canonicalized queries need their errors propagated rather than immediately reported because we do not have accurate spans.

Implementations

impl<'cx, 'tcx> SelectionContext<'cx, 'tcx>

pub(super) fn candidate_from_obligation<'o>(
    &mut self,
    stack: &TraitObligationStack<'o, 'tcx>
) -> SelectionResult<'tcx, SelectionCandidate<'tcx>>

fn candidate_from_obligation_no_cache<'o>(
    &mut self,
    stack: &TraitObligationStack<'o, 'tcx>
) -> SelectionResult<'tcx, SelectionCandidate<'tcx>>

pub(super) fn assemble_candidates<'o>(
    &mut self,
    stack: &TraitObligationStack<'o, 'tcx>
) -> Result<SelectionCandidateSet<'tcx>, SelectionError<'tcx>>

fn assemble_candidates_from_projected_tys(
    &mut self,
    obligation: &TraitObligation<'tcx>,
    candidates: &mut SelectionCandidateSet<'tcx>
)

fn assemble_candidates_from_caller_bounds<'o>(
    &mut self,
    stack: &TraitObligationStack<'o, 'tcx>,
    candidates: &mut SelectionCandidateSet<'tcx>
) -> Result<(), SelectionError<'tcx>>

Given an obligation like <SomeTrait for T>, searches the obligations that the caller supplied to find out whether it is listed among them.

Never affects the inference environment.

fn assemble_generator_candidates(
    &mut self,
    obligation: &TraitObligation<'tcx>,
    candidates: &mut SelectionCandidateSet<'tcx>
)

fn assemble_closure_candidates(
    &mut self,
    obligation: &TraitObligation<'tcx>,
    candidates: &mut SelectionCandidateSet<'tcx>
)

Checks for the artificial impl that the compiler will create for an obligation like X : FnMut<..> where X is a closure type.

Note: the type parameters on a closure candidate are modeled as output type parameters and hence do not affect whether this trait is a match or not. They will be unified during the confirmation step.

fn assemble_fn_pointer_candidates(
    &mut self,
    obligation: &TraitObligation<'tcx>,
    candidates: &mut SelectionCandidateSet<'tcx>
)

Implements one of the Fn() family for a fn pointer.

fn assemble_candidates_from_impls(
    &mut self,
    obligation: &TraitObligation<'tcx>,
    candidates: &mut SelectionCandidateSet<'tcx>
)

Searches for impls that might apply to obligation.

fn assemble_candidates_from_auto_impls(
    &mut self,
    obligation: &TraitObligation<'tcx>,
    candidates: &mut SelectionCandidateSet<'tcx>
)

fn assemble_candidates_from_object_ty(
    &mut self,
    obligation: &TraitObligation<'tcx>,
    candidates: &mut SelectionCandidateSet<'tcx>
)

Searches for impls that might apply to obligation.

fn need_migrate_deref_output_trait_object(
    &mut self,
    ty: Ty<'tcx>,
    param_env: ParamEnv<'tcx>,
    cause: &ObligationCause<'tcx>
) -> Option<(Ty<'tcx>, DefId)>

Temporary migration for #89190

fn assemble_candidates_for_unsizing(
    &mut self,
    obligation: &TraitObligation<'tcx>,
    candidates: &mut SelectionCandidateSet<'tcx>
)

Searches for unsizing that might apply to obligation.

fn assemble_candidates_for_transmutability(
    &mut self,
    obligation: &TraitObligation<'tcx>,
    candidates: &mut SelectionCandidateSet<'tcx>
)

fn assemble_candidates_for_trait_alias(
    &mut self,
    obligation: &TraitObligation<'tcx>,
    candidates: &mut SelectionCandidateSet<'tcx>
)

fn assemble_builtin_bound_candidates(
    &mut self,
    conditions: BuiltinImplConditions<'tcx>,
    candidates: &mut SelectionCandidateSet<'tcx>
)

Assembles the trait which are built-in to the language itself: Copy, Clone and Sized.

fn assemble_const_destruct_candidates(
    &mut self,
    obligation: &TraitObligation<'tcx>,
    candidates: &mut SelectionCandidateSet<'tcx>
)

fn assemble_candidate_for_tuple(
    &mut self,
    obligation: &TraitObligation<'tcx>,
    candidates: &mut SelectionCandidateSet<'tcx>
)

impl<'cx, 'tcx> SelectionContext<'cx, 'tcx>

pub(super) fn confirm_candidate(
    &mut self,
    obligation: &TraitObligation<'tcx>,
    candidate: SelectionCandidate<'tcx>
) -> Result<Selection<'tcx>, SelectionError<'tcx>>

fn confirm_projection_candidate(
    &mut self,
    obligation: &TraitObligation<'tcx>,
    idx: usize
) -> Result<Vec<PredicateObligation<'tcx>>, SelectionError<'tcx>>

fn confirm_param_candidate(
    &mut self,
    obligation: &TraitObligation<'tcx>,
    param: PolyTraitRef<'tcx>
) -> Vec<PredicateObligation<'tcx>>

fn confirm_builtin_candidate(
    &mut self,
    obligation: &TraitObligation<'tcx>,
    has_nested: bool
) -> ImplSourceBuiltinData<PredicateObligation<'tcx>>

fn confirm_transmutability_candidate(
    &mut self,
    obligation: &TraitObligation<'tcx>
) -> Result<ImplSourceBuiltinData<PredicateObligation<'tcx>>, SelectionError<'tcx>>

fn confirm_auto_impl_candidate(
    &mut self,
    obligation: &TraitObligation<'tcx>,
    trait_def_id: DefId
) -> ImplSourceAutoImplData<PredicateObligation<'tcx>>

This handles the case where an auto trait Foo impl is being used. The idea is that the impl applies to X : Foo if the following conditions are met:

1. For each constituent type Y in X, Y : Foo holds
2. For each where-clause C declared on Foo, [Self => X] C holds.

fn vtable_auto_impl(
    &mut self,
    obligation: &TraitObligation<'tcx>,
    trait_def_id: DefId,
    nested: Binder<'tcx, Vec<Ty<'tcx>>>
) -> ImplSourceAutoImplData<PredicateObligation<'tcx>>

See confirm_auto_impl_candidate.

fn confirm_impl_candidate(
    &mut self,
    obligation: &TraitObligation<'tcx>,
    impl_def_id: DefId
) -> ImplSourceUserDefinedData<'tcx, PredicateObligation<'tcx>>

fn vtable_impl(
    &mut self,
    impl_def_id: DefId,
    substs: Normalized<'tcx, SubstsRef<'tcx>>,
    cause: &ObligationCause<'tcx>,
    recursion_depth: usize,
    param_env: ParamEnv<'tcx>,
    parent_trait_pred: Binder<'tcx, TraitPredicate<'tcx>>
) -> ImplSourceUserDefinedData<'tcx, PredicateObligation<'tcx>>

fn confirm_object_candidate(
    &mut self,
    obligation: &TraitObligation<'tcx>,
    index: usize
) -> Result<ImplSourceObjectData<'tcx, PredicateObligation<'tcx>>, SelectionError<'tcx>>

fn confirm_fn_pointer_candidate(
    &mut self,
    obligation: &TraitObligation<'tcx>
) -> Result<ImplSourceFnPointerData<'tcx, PredicateObligation<'tcx>>, SelectionError<'tcx>>

fn confirm_trait_alias_candidate(
    &mut self,
    obligation: &TraitObligation<'tcx>,
    alias_def_id: DefId
) -> ImplSourceTraitAliasData<'tcx, PredicateObligation<'tcx>>

fn confirm_generator_candidate(
    &mut self,
    obligation: &TraitObligation<'tcx>
) -> Result<ImplSourceGeneratorData<'tcx, PredicateObligation<'tcx>>, SelectionError<'tcx>>

fn confirm_closure_candidate(
    &mut self,
    obligation: &TraitObligation<'tcx>
) -> Result<ImplSourceClosureData<'tcx, PredicateObligation<'tcx>>, SelectionError<'tcx>>

fn confirm_poly_trait_refs(
    &mut self,
    obligation: &TraitObligation<'tcx>,
    expected_trait_ref: PolyTraitRef<'tcx>
) -> Result<Vec<PredicateObligation<'tcx>>, SelectionError<'tcx>>

In the case of closure types and fn pointers, we currently treat the input type parameters on the trait as outputs. This means that when we have a match we have only considered the self type, so we have to go back and make sure to relate the argument types too. This is kind of wrong, but since we control the full set of impls, also not that wrong, and it DOES yield better error messages (since we don’t report errors as if there is no applicable impl, but rather report errors are about mismatched argument types.

Here is an example. Imagine we have a closure expression and we desugared it so that the type of the expression is Closure, and Closure expects i32 as argument. Then it is “as if” the compiler generated this impl:

impl Fn(i32) for Closure { ... }

Now imagine our obligation is Closure: Fn(usize). So far we have matched the self type Closure. At this point we’ll compare the i32 to usize and generate an error.

Note that this checking occurs after the impl has selected, because these output type parameters should not affect the selection of the impl. Therefore, if there is a mismatch, we report an error to the user.

fn confirm_trait_upcasting_unsize_candidate(
    &mut self,
    obligation: &TraitObligation<'tcx>,
    idx: usize
) -> Result<ImplSourceTraitUpcastingData<'tcx, PredicateObligation<'tcx>>, SelectionError<'tcx>>

fn confirm_builtin_unsize_candidate(
    &mut self,
    obligation: &TraitObligation<'tcx>
) -> Result<ImplSourceBuiltinData<PredicateObligation<'tcx>>, SelectionError<'tcx>>

fn confirm_const_destruct_candidate(
    &mut self,
    obligation: &TraitObligation<'tcx>,
    impl_def_id: Option<DefId>
) -> Result<ImplSourceConstDestructData<PredicateObligation<'tcx>>, SelectionError<'tcx>>

impl<'cx, 'tcx> SelectionContext<'cx, 'tcx>

pub fn new(infcx: &'cx InferCtxt<'cx, 'tcx>) -> SelectionContext<'cx, 'tcx>

pub fn intercrate(
    infcx: &'cx InferCtxt<'cx, 'tcx>
) -> SelectionContext<'cx, 'tcx>

pub fn with_query_mode(
    infcx: &'cx InferCtxt<'cx, 'tcx>,
    query_mode: TraitQueryMode
) -> SelectionContext<'cx, 'tcx>

pub fn enable_tracking_intercrate_ambiguity_causes(&mut self)

Enables tracking of intercrate ambiguity causes. See the documentation of Self::intercrate_ambiguity_causes for more.

pub fn take_intercrate_ambiguity_causes(
    &mut self
) -> FxIndexSet<IntercrateAmbiguityCause>

Gets the intercrate ambiguity causes collected since tracking was enabled and disables tracking at the same time. If tracking is not enabled, just returns an empty vector.

pub fn infcx(&self) -> &'cx InferCtxt<'cx, 'tcx>

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

pub fn is_intercrate(&self) -> bool

pub fn select(
    &mut self,
    obligation: &TraitObligation<'tcx>
) -> SelectionResult<'tcx, Selection<'tcx>>

Attempts to satisfy the obligation. If successful, this will affect the surrounding type environment by performing unification.

pub(crate) fn select_from_obligation(
    &mut self,
    obligation: &TraitObligation<'tcx>
) -> SelectionResult<'tcx, SelectionCandidate<'tcx>>

pub fn predicate_may_hold_fatal(
    &mut self,
    obligation: &PredicateObligation<'tcx>
) -> bool

Evaluates whether the obligation obligation can be satisfied (by any means).

pub fn evaluate_root_obligation(
    &mut self,
    obligation: &PredicateObligation<'tcx>
) -> Result<EvaluationResult, OverflowError>

Evaluates whether the obligation obligation can be satisfied and returns an EvaluationResult. This is meant for the initial call.

fn evaluation_probe(
    &mut self,
    op: impl FnOnce(&mut Self) -> Result<EvaluationResult, OverflowError>
) -> Result<EvaluationResult, OverflowError>

fn evaluate_predicates_recursively<'o, I>(
    &mut self,
    stack: TraitObligationStackList<'o, 'tcx>,
    predicates: I
) -> Result<EvaluationResult, OverflowError>where
    I: IntoIterator<Item = PredicateObligation<'tcx>> + Debug,

Evaluates the predicates in predicates recursively. Note that this applies projections in the predicates, and therefore is run within an inference probe.

fn evaluate_predicate_recursively<'o>(
    &mut self,
    previous_stack: TraitObligationStackList<'o, 'tcx>,
    obligation: PredicateObligation<'tcx>
) -> Result<EvaluationResult, OverflowError>

fn evaluate_trait_predicate_recursively<'o>(
    &mut self,
    previous_stack: TraitObligationStackList<'o, 'tcx>,
    obligation: TraitObligation<'tcx>
) -> Result<EvaluationResult, OverflowError>

fn check_evaluation_cycle(
    &mut self,
    stack: &TraitObligationStack<'_, 'tcx>
) -> Option<EvaluationResult>

If there is any previous entry on the stack that precisely matches this obligation, then we can assume that the obligation is satisfied for now (still all other conditions must be met of course). One obvious case this comes up is marker traits like Send. Think of a linked list:

struct List { data: T, next: Option<Box<List>> }

Box<List<T>> will be Send if T is Send and Option<Box<List<T>>> is Send, and in turn Option<Box<List<T>>> is Send if Box<List<T>> is Send.

Note that we do this comparison using the fresh_trait_ref fields. Because these have all been freshened using self.freshener, we can be sure that (a) this will not affect the inferencer state and (b) that if we see two fresh regions with the same index, they refer to the same unbound type variable.

fn evaluate_stack<'o>(
    &mut self,
    stack: &TraitObligationStack<'o, 'tcx>
) -> Result<EvaluationResult, OverflowError>

pub(crate) fn coinductive_match<I>(&mut self, cycle: I) -> boolwhere
    I: Iterator<Item = Predicate<'tcx>>,

For defaulted traits, we use a co-inductive strategy to solve, so that recursion is ok. This routine returns true if the top of the stack (cycle[0]):

• is a defaulted trait,
• it also appears in the backtrace at some position X,
• all the predicates at positions X.. between X and the top are also defaulted traits.

fn coinductive_predicate(&self, predicate: Predicate<'tcx>) -> bool

fn evaluate_candidate<'o>(
    &mut self,
    stack: &TraitObligationStack<'o, 'tcx>,
    candidate: &SelectionCandidate<'tcx>
) -> Result<EvaluationResult, OverflowError>

Further evaluates candidate to decide whether all type parameters match and whether nested obligations are met. Returns whether candidate remains viable after this further scrutiny.

fn check_evaluation_cache(
    &self,
    param_env: ParamEnv<'tcx>,
    trait_pred: PolyTraitPredicate<'tcx>
) -> Option<EvaluationResult>

fn insert_evaluation_cache(
    &mut self,
    param_env: ParamEnv<'tcx>,
    trait_pred: PolyTraitPredicate<'tcx>,
    dep_node: DepNodeIndex,
    result: EvaluationResult
)

fn add_depth<T: 'cx, I: Iterator<Item = &'cx mut Obligation<'tcx, T>>>(
    &self,
    it: I,
    min_depth: usize
)

For various reasons, it’s possible for a subobligation to have a lower recursion_depth than the obligation used to create it. Projection sub-obligations may be returned from the projection cache, which results in obligations with an ‘old’ recursion_depth. Additionally, methods like InferCtxt.subtype_predicate produce subobligations without taking in a ‘parent’ depth, causing the generated subobligations to have a recursion_depth of 0.

To ensure that obligation_depth never decreases, we force all subobligations to have at least the depth of the original obligation.

fn check_recursion_depth<T: Display + TypeFoldable<'tcx>>(
    &self,
    depth: usize,
    error_obligation: &Obligation<'tcx, T>
) -> Result<(), OverflowError>

fn check_recursion_limit<T: Display + TypeFoldable<'tcx>, V: Display + TypeFoldable<'tcx>>(
    &self,
    obligation: &Obligation<'tcx, T>,
    error_obligation: &Obligation<'tcx, V>
) -> Result<(), OverflowError>

Checks that the recursion limit has not been exceeded.

The weird return type of this function allows it to be used with the try (?) operator within certain functions.

fn in_task<OP, R>(&mut self, op: OP) -> (R, DepNodeIndex)where
    OP: FnOnce(&mut Self) -> R,

fn filter_impls(
    &mut self,
    candidates: Vec<SelectionCandidate<'tcx>>,
    obligation: &TraitObligation<'tcx>
) -> Vec<SelectionCandidate<'tcx>>

filter_impls filters constant trait obligations and candidates that have a positive impl for a negative goal and a negative impl for a positive goal

fn filter_reservation_impls(
    &mut self,
    candidate: SelectionCandidate<'tcx>,
    obligation: &TraitObligation<'tcx>
) -> SelectionResult<'tcx, SelectionCandidate<'tcx>>

filter_reservation_impls filter reservation impl for any goal as ambiguous

fn is_knowable<'o>(
    &mut self,
    stack: &TraitObligationStack<'o, 'tcx>
) -> Result<(), Conflict>

fn can_use_global_caches(&self, param_env: ParamEnv<'tcx>) -> bool

Returns true if the global caches can be used.

fn check_candidate_cache(
    &mut self,
    param_env: ParamEnv<'tcx>,
    cache_fresh_trait_pred: PolyTraitPredicate<'tcx>
) -> Option<SelectionResult<'tcx, SelectionCandidate<'tcx>>>

fn can_cache_candidate(
    &self,
    result: &SelectionResult<'tcx, SelectionCandidate<'tcx>>
) -> bool

Determines whether can we safely cache the result of selecting an obligation. This is almost always true, except when dealing with certain ParamCandidates.

Ordinarily, a ParamCandidate will contain no inference variables, since it was usually produced directly from a DefId. However, certain cases (currently only librustdoc’s blanket impl finder), a ParamEnv may be explicitly constructed with inference types. When this is the case, we do not want to cache the resulting selection candidate. This is due to the fact that it might not always be possible to equate the obligation’s trait ref and the candidate’s trait ref, if more constraints end up getting added to an inference variable.

Because of this, we always want to re-run the full selection process for our obligation the next time we see it, since we might end up picking a different SelectionCandidate (or none at all).

fn insert_candidate_cache(
    &mut self,
    param_env: ParamEnv<'tcx>,
    cache_fresh_trait_pred: PolyTraitPredicate<'tcx>,
    dep_node: DepNodeIndex,
    candidate: SelectionResult<'tcx, SelectionCandidate<'tcx>>
)

fn match_projection_obligation_against_definition_bounds(
    &mut self,
    obligation: &TraitObligation<'tcx>
) -> SmallVec<[usize; 2]>

Matches a predicate against the bounds of its self type.

Given an obligation like <T as Foo>::Bar: Baz where the self type is a projection, look at the bounds of T::Bar, see if we can find a Baz bound. We return indexes into the list returned by tcx.item_bounds for any applicable bounds.

fn match_normalize_trait_ref(
    &mut self,
    obligation: &TraitObligation<'tcx>,
    trait_bound: PolyTraitRef<'tcx>,
    placeholder_trait_ref: TraitRef<'tcx>
) -> Result<Option<PolyTraitRef<'tcx>>, ()>

Equates the trait in obligation with trait bound. If the two traits can be equated and the normalized trait bound doesn’t contain inference variables or placeholders, the normalized bound is returned.

fn where_clause_may_apply<'o>(
    &mut self,
    stack: &TraitObligationStack<'o, 'tcx>,
    where_clause_trait_ref: PolyTraitRef<'tcx>
) -> Result<EvaluationResult, OverflowError>

pub(super) fn match_projection_projections(
    &mut self,
    obligation: &Obligation<'tcx, ProjectionTy<'tcx>>,
    env_predicate: PolyProjectionPredicate<'tcx>,
    potentially_unnormalized_candidates: bool
) -> ProjectionMatchesProjection

Return Yes if the obligation’s predicate type applies to the env_predicate, and No if it does not. Return Ambiguous in the case that the projection type is a GAT, and applying this env_predicate constrains any of the obligation’s GAT substitutions.

This behavior is a somewhat of a hack to prevent over-constraining inference variables in cases like #91762.

fn candidate_should_be_dropped_in_favor_of(
    &mut self,
    victim: &EvaluatedCandidate<'tcx>,
    other: &EvaluatedCandidate<'tcx>,
    needs_infer: bool
) -> bool

Returns true if victim should be dropped in favor of other. Generally speaking we will drop duplicate candidates and prefer where-clause candidates.

See the comment for “SelectionCandidate” for more details.

fn sized_conditions(
    &mut self,
    obligation: &TraitObligation<'tcx>
) -> BuiltinImplConditions<'tcx>

fn copy_clone_conditions(
    &mut self,
    obligation: &TraitObligation<'tcx>
) -> BuiltinImplConditions<'tcx>

fn constituent_types_for_ty(
    &self,
    t: Binder<'tcx, Ty<'tcx>>
) -> Binder<'tcx, Vec<Ty<'tcx>>>

For default impls, we need to break apart a type into its “constituent types” – meaning, the types that it contains.

Here are some (simple) examples:

(i32, u32) -> [i32, u32]
Foo where struct Foo { x: i32, y: u32 } -> [i32, u32]
Bar<i32> where struct Bar<T> { x: T, y: u32 } -> [i32, u32]
Zed<i32> where enum Zed { A(T), B(u32) } -> [i32, u32]

fn collect_predicates_for_types(
    &mut self,
    param_env: ParamEnv<'tcx>,
    cause: ObligationCause<'tcx>,
    recursion_depth: usize,
    trait_def_id: DefId,
    types: Binder<'tcx, Vec<Ty<'tcx>>>
) -> Vec<PredicateObligation<'tcx>>

fn rematch_impl(
    &mut self,
    impl_def_id: DefId,
    obligation: &TraitObligation<'tcx>
) -> Normalized<'tcx, SubstsRef<'tcx>>

fn match_impl(
    &mut self,
    impl_def_id: DefId,
    impl_trait_ref: EarlyBinder<TraitRef<'tcx>>,
    obligation: &TraitObligation<'tcx>
) -> Result<Normalized<'tcx, SubstsRef<'tcx>>, ()>

fn fast_reject_trait_refs(
    &mut self,
    obligation: &TraitObligation<'tcx>,
    impl_trait_ref: &TraitRef<'tcx>
) -> bool

fn match_where_clause_trait_ref(
    &mut self,
    obligation: &TraitObligation<'tcx>,
    where_clause_trait_ref: PolyTraitRef<'tcx>
) -> Result<Vec<PredicateObligation<'tcx>>, ()>

Normalize where_clause_trait_ref and try to match it against obligation. If successful, return any predicates that result from the normalization.

fn match_poly_trait_ref(
    &mut self,
    obligation: &TraitObligation<'tcx>,
    poly_trait_ref: PolyTraitRef<'tcx>
) -> Result<Vec<PredicateObligation<'tcx>>, ()>

Returns Ok if poly_trait_ref being true implies that the obligation is satisfied.

fn match_fresh_trait_refs(
    &self,
    previous: PolyTraitPredicate<'tcx>,
    current: PolyTraitPredicate<'tcx>,
    param_env: ParamEnv<'tcx>
) -> bool

fn push_stack<'o>(
    &mut self,
    previous_stack: TraitObligationStackList<'o, 'tcx>,
    obligation: &'o TraitObligation<'tcx>
) -> TraitObligationStack<'o, 'tcx>

fn closure_trait_ref_unnormalized(
    &mut self,
    obligation: &TraitObligation<'tcx>,
    substs: SubstsRef<'tcx>
) -> PolyTraitRef<'tcx>

fn generator_trait_ref_unnormalized(
    &mut self,
    obligation: &TraitObligation<'tcx>,
    substs: SubstsRef<'tcx>
) -> PolyTraitRef<'tcx>

fn impl_or_trait_obligations(
    &mut self,
    cause: &ObligationCause<'tcx>,
    recursion_depth: usize,
    param_env: ParamEnv<'tcx>,
    def_id: DefId,
    substs: SubstsRef<'tcx>,
    parent_trait_pred: Binder<'tcx, TraitPredicate<'tcx>>
) -> Vec<PredicateObligation<'tcx>>

Returns the obligations that are implied by instantiating an impl or trait. The obligations are substituted and fully normalized. This is used when confirming an impl or default impl.

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: 160 bytes