Trait TraitEngine 

pub trait TraitEngine<'tcx, E>: 'tcx
where
    E: 'tcx,
{
    // Required methods
    fn register_predicate_obligation(
        &mut self,
        infcx: &InferCtxt<'tcx>,
        obligation: Obligation<'tcx, Predicate<'tcx>>,
    );
    fn try_evaluate_obligations(&mut self, infcx: &InferCtxt<'tcx>) -> Vec<E>;
    fn collect_remaining_errors(&mut self, infcx: &InferCtxt<'tcx>) -> Vec<E>;
    fn has_pending_obligations(&self) -> bool;
    fn pending_obligations(&self) -> ThinVec<Obligation<'tcx, Predicate<'tcx>>>;
    fn drain_stalled_obligations_for_coroutines(
        &mut self,
        infcx: &InferCtxt<'tcx>,
    ) -> ThinVec<Obligation<'tcx, Predicate<'tcx>>>;

    // Provided methods
    fn register_bound(
        &mut self,
        infcx: &InferCtxt<'tcx>,
        param_env: ParamEnv<'tcx>,
        ty: Ty<'tcx>,
        def_id: DefId,
        cause: ObligationCause<'tcx>,
    ) { ... }
    fn register_predicate_obligations(
        &mut self,
        infcx: &InferCtxt<'tcx>,
        obligations: ThinVec<Obligation<'tcx, Predicate<'tcx>>>,
    ) { ... }
    fn evaluate_obligations_error_on_ambiguity(
        &mut self,
        infcx: &InferCtxt<'tcx>,
    ) -> Vec<E> { ... }
}

Required Methods

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

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

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

For each result: Ok: remove the obligation from the list Ambiguous: leave the obligation in the list to be evaluated later Err: remove the obligation from the list and return an error

Returns a list of errors from obligations that evaluated to Err.

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

fn has_pending_obligations(&self) -> bool

fn pending_obligations(&self) -> ThinVec<Obligation<'tcx, Predicate<'tcx>>>

fn drain_stalled_obligations_for_coroutines( &mut self, infcx: &InferCtxt<'tcx>, ) -> ThinVec<Obligation<'tcx, Predicate<'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.

Provided Methods

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 register_predicate_obligations( &mut self, infcx: &InferCtxt<'tcx>, obligations: ThinVec<Obligation<'tcx, Predicate<'tcx>>>, )

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.

For each result: Ok: remove the obligation from the list Ambiguous: remove the obligation from the list and return an error Err: remove the obligation from the list and return an error

Returns a list of errors from obligations that evaluated to Ambiguous or Err.

Trait Implementations

impl<'tcx, E> TraitEngineExt<'tcx, E> for dyn TraitEngine<'tcx, E>

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

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

Implementors

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

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

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

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