Enum FulfillmentEngine 

pub enum FulfillmentEngine<'tcx, E> {
    Old(FulfillmentContext<'tcx, E>),
    Next(FulfillmentCtxt<'tcx, E>),
}

A fulfillment engine, stored inline rather than boxed as a dyn TraitEngine because some of its holders (e.g. ObligationCtxt) are created very often (once per candidate probe during method resolution), so the heap allocation would be expensive.

Variants

Old(FulfillmentContext<'tcx, E>)

Next(FulfillmentCtxt<'tcx, E>)

Implementations

impl<'tcx, E> FulfillmentEngine<'tcx, E>

where E: FromSolverError<'tcx, NextSolverError<'tcx>> + FromSolverError<'tcx, OldSolverError<'tcx>>,

pub fn new(infcx: &InferCtxt<'tcx>) -> Self

Trait Implementations

impl<'tcx, E> TraitEngine<'tcx, E> for FulfillmentEngine<'tcx, E>

where E: FromSolverError<'tcx, NextSolverError<'tcx>> + FromSolverError<'tcx, OldSolverError<'tcx>>,

fn register_predicate_obligation( &mut self, infcx: &InferCtxt<'tcx>, obligation: PredicateObligation<'tcx>, )

fn register_predicate_obligations( &mut self, infcx: &InferCtxt<'tcx>, obligations: PredicateObligations<'tcx>, )

fn try_evaluate_obligations(&mut self, infcx: &InferCtxt<'tcx>) -> Vec<E>

Go over the list of pending obligations and try to evaluate them.

fn collect_remaining_errors(&mut self, infcx: &InferCtxt<'tcx>) -> Vec<E>

fn has_pending_obligations(&self) -> bool

fn pending_obligations(&self) -> PredicateObligations<'tcx>

fn pending_obligations_potentially_referencing_sub_root( &self, infcx: &InferCtxt<'tcx>, sub_root: TyVid, ) -> PredicateObligations<'tcx>

Pending obligations potentially referencing an inference variable whose sub-unification root is _sub_root. May be conservative: implementations can return obligations that don’t actually reference _sub_root (the default just returns everything).

fn drain_stalled_obligations_for_coroutines( &mut self, infcx: &InferCtxt<'tcx>, ) -> PredicateObligations<'tcx>

Among all pending obligations, collect those are stalled on a inference variable which has changed since the last call to try_evaluate_obligations. Those obligations are marked as successful and returned.

fn register_bound( &mut self, infcx: &InferCtxt<'tcx>, param_env: ParamEnv<'tcx>, ty: Ty<'tcx>, def_id: DefId, cause: ObligationCause<'tcx>, )

Requires that ty must implement the trait with def_id in the given environment. This trait must not have any type parameters (except for Self).

fn evaluate_obligations_error_on_ambiguity( &mut self, infcx: &InferCtxt<'tcx>, ) -> Vec<E>

Evaluate all pending obligations, return error if they can’t be evaluated.

fn pending_obligations_potentially_referencing_float_infer( &self, _infcx: &InferCtxt<'tcx>, ) -> ThinVec<Obligation<'tcx, Predicate<'tcx>>>

Pending obligations potentially referencing float inference variables.

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

Size for each variant:

• Old: 160 bytes
• Next: 48 bytes