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>,
    ) -> TraitErrors<E>;
    fn collect_remaining_errors(
        &mut self,
        infcx: &InferCtxt<'tcx>,
    ) -> TraitErrors<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>,
    ) -> TraitErrors<E> { ... }
    fn pending_obligations_potentially_referencing_sub_root(
        &self,
        _infcx: &InferCtxt<'tcx>,
        _sub_root: TyVid,
    ) -> ThinVec<Obligation<'tcx, Predicate<'tcx>>> { ... }
    fn pending_obligations_potentially_referencing_float_infer(
        &self,
        _infcx: &InferCtxt<'tcx>,
    ) -> ThinVec<Obligation<'tcx, Predicate<'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>, ) -> TraitErrors<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>, ) -> TraitErrors<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>, ) -> TraitErrors<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.

fn pending_obligations_potentially_referencing_sub_root( &self, _infcx: &InferCtxt<'tcx>, _sub_root: TyVid, ) -> ThinVec<Obligation<'tcx, Predicate<'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 pending_obligations_potentially_referencing_float_infer( &self, _infcx: &InferCtxt<'tcx>, ) -> ThinVec<Obligation<'tcx, Predicate<'tcx>>>

Pending obligations potentially referencing float inference variables.

FIXME: use a generic filter for pending_obligations_potentially_referencing_sub_root and this after TraitEngine doesn’t need to be dyn compatible.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

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

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

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

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

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

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