Struct rustc_trait_selection::infer::InferCtxt

pub struct InferCtxt<'tcx> {

    pub tcx: TyCtxt<'tcx>,
    pub defining_use_anchor: DefiningAnchor,
    pub considering_regions: bool,
    skip_leak_check: bool,
    pub inner: RefCell<InferCtxtInner<'tcx>>,
    lexical_region_resolutions: RefCell<Option<LexicalRegionResolutions<'tcx>>>,
    pub selection_cache: Cache<(ParamEnv<'tcx>, TraitPredicate<'tcx>), Result<Option<SelectionCandidate<'tcx>>, SelectionError<'tcx>>>,
    pub evaluation_cache: Cache<(ParamEnv<'tcx>, Binder<'tcx, TraitPredicate<'tcx>>), EvaluationResult>,
    pub reported_trait_errors: RefCell<IndexMap<Span, Vec<Predicate<'tcx>, Global>, BuildHasherDefault<FxHasher>>>,
    pub reported_closure_mismatch: RefCell<HashSet<(Span, Option<Span>), BuildHasherDefault<FxHasher>>>,
    tainted_by_errors: Cell<Option<ErrorGuaranteed>>,
    err_count_on_creation: usize,
    universe: Cell<UniverseIndex>,
    pub intercrate: bool,
    next_trait_solver: bool,
}

Fields

tcx: TyCtxt<'tcx>

defining_use_anchor: DefiningAnchor

The DefId of the item in whose context we are performing inference or typeck. It is used to check whether an opaque type use is a defining use.

If it is DefiningAnchor::Bubble, we can’t resolve opaque types here and need to bubble up the obligation. This frequently happens for short lived InferCtxt within queries. The opaque type obligations are forwarded to the outside until the end up in an InferCtxt for typeck or borrowck.

Its default value is DefiningAnchor::Error, this way it is easier to catch errors that might come up during inference or typeck.

considering_regions: bool

Whether this inference context should care about region obligations in the root universe. Most notably, this is used during hir typeck as region solving is left to borrowck instead.

skip_leak_check: bool

inner: RefCell<InferCtxtInner<'tcx>>

lexical_region_resolutions: RefCell<Option<LexicalRegionResolutions<'tcx>>>

selection_cache: Cache<(ParamEnv<'tcx>, TraitPredicate<'tcx>), Result<Option<SelectionCandidate<'tcx>>, SelectionError<'tcx>>>

Caches the results of trait selection. This cache is used for things that have to do with the parameters in scope.

evaluation_cache: Cache<(ParamEnv<'tcx>, Binder<'tcx, TraitPredicate<'tcx>>), EvaluationResult>

Caches the results of trait evaluation.

reported_trait_errors: RefCell<IndexMap<Span, Vec<Predicate<'tcx>, Global>, BuildHasherDefault<FxHasher>>>

The set of predicates on which errors have been reported, to avoid reporting the same error twice.

reported_closure_mismatch: RefCell<HashSet<(Span, Option<Span>), BuildHasherDefault<FxHasher>>>

tainted_by_errors: Cell<Option<ErrorGuaranteed>>

err_count_on_creation: usize

universe: Cell<UniverseIndex>

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, we 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.

next_trait_solver: bool

Trait Implementations

impl<'tcx> InferCtxtEvalExt<'tcx> for InferCtxt<'tcx>

fn evaluate_root_goal( &self, goal: Goal<'tcx, Predicate<'tcx>>, generate_proof_tree: GenerateProofTree ) -> (Result<(bool, Certainty, Vec<Goal<'tcx, Predicate<'tcx>>>), NoSolution>, Option<GoalEvaluation<'tcx>>)

Evaluates a goal from outside of the trait solver.

impl<'a, 'tcx: 'a> InferCtxtExt<'a, 'tcx> for InferCtxt<'tcx>

fn implied_outlives_bounds( &self, param_env: ParamEnv<'tcx>, body_id: LocalDefId, ty: Ty<'tcx> ) -> Vec<OutlivesBound<'tcx>>

Implied bounds are region relationships that we deduce automatically. The idea is that (e.g.) a caller must check that a function’s argument types are well-formed immediately before calling that fn, and hence the callee can assume that its argument types are well-formed. This may imply certain relationships between generic parameters. For example:

fn foo<T>(x: &T) {}

can only be called with a 'a and T such that &'a T is WF. For &'a T to be WF, T: 'a must hold. So we can assume T: 'a.

Parameters

• param_env, the where-clauses in scope
• body_id, the body-id to use when normalizing assoc types. Note that this may cause outlives obligations to be injected into the inference context with this body-id.
• ty, the type that we are supposed to assume is WF.

fn implied_bounds_tys( &'a self, param_env: ParamEnv<'tcx>, body_id: LocalDefId, tys: FxIndexSet<Ty<'tcx>> ) -> Bounds<'a, 'tcx>

impl<'tcx> InferCtxtExt<'tcx> for InferCtxt<'tcx>

fn type_is_copy_modulo_regions( &self, param_env: ParamEnv<'tcx>, ty: Ty<'tcx> ) -> bool

fn type_is_sized_modulo_regions( &self, param_env: ParamEnv<'tcx>, ty: Ty<'tcx> ) -> bool

fn type_implements_trait( &self, trait_def_id: DefId, params: impl IntoIterator<Item: Into<GenericArg<'tcx>>>, param_env: ParamEnv<'tcx> ) -> EvaluationResult

Check whether a ty implements given trait(trait_def_id). The inputs are:

impl<'tcx> InferCtxtExt<'tcx> for InferCtxt<'tcx>

fn predicate_may_hold(&self, obligation: &PredicateObligation<'tcx>) -> bool

Evaluates whether the predicate can be satisfied (by any means) in the given ParamEnv.

fn predicate_must_hold_considering_regions( &self, obligation: &PredicateObligation<'tcx> ) -> bool

Evaluates whether the predicate can be satisfied in the given ParamEnv, and returns false if not certain. However, this is not entirely accurate if inference variables are involved.

This version may conservatively fail when outlives obligations are required.

fn predicate_must_hold_modulo_regions( &self, obligation: &PredicateObligation<'tcx> ) -> bool

Evaluates whether the predicate can be satisfied in the given ParamEnv, and returns false if not certain. However, this is not entirely accurate if inference variables are involved.

This version ignores all outlives constraints.

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

Evaluate a given predicate, capturing overflow and propagating it back.

fn evaluate_obligation_no_overflow( &self, obligation: &PredicateObligation<'tcx> ) -> EvaluationResult

impl<'tcx> InferCtxtExt<'tcx> for InferCtxt<'tcx>

fn get_fn_like_arguments( &self, node: Node<'_> ) -> Option<(Span, Option<Span>, Vec<ArgKind>)>

Given some node representing a fn-like thing in the HIR map, returns a span and ArgKind information that describes the arguments it expects. This can be supplied to report_arg_count_mismatch.

fn report_arg_count_mismatch( &self, span: Span, found_span: Option<Span>, expected_args: Vec<ArgKind>, found_args: Vec<ArgKind>, is_closure: bool, closure_arg_span: Option<Span> ) -> DiagnosticBuilder<'tcx, ErrorGuaranteed>

Reports an error when the number of arguments needed by a trait match doesn’t match the number that the expression provides.

fn type_implements_fn_trait( &self, param_env: ParamEnv<'tcx>, ty: Binder<'tcx, Ty<'tcx>>, polarity: ImplPolarity ) -> Result<(ClosureKind, Binder<'tcx, Ty<'tcx>>), ()>

Checks if the type implements one of Fn, FnMut, or FnOnce in that order, and returns the generic type corresponding to the argument of that trait (corresponding to the closure arguments).

impl<'tcx> InferCtxtSelectExt<'tcx> for InferCtxt<'tcx>

fn select_in_new_trait_solver( &self, obligation: &PolyTraitObligation<'tcx> ) -> SelectionResult<'tcx, Selection<'tcx>>

impl<'tcx> ProofTreeInferCtxtExt<'tcx> for InferCtxt<'tcx>

fn visit_proof_tree<V: ProofTreeVisitor<'tcx>>( &self, goal: Goal<'tcx, Predicate<'tcx>>, visitor: &mut V ) -> ControlFlow<V::BreakTy>

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