Struct Obligation

pub struct Obligation<'tcx, T> {
    pub cause: ObligationCause<'tcx>,
    pub param_env: ParamEnv<'tcx>,
    pub predicate: T,
    pub recursion_depth: usize,
}

An Obligation represents some trait reference (e.g., i32: Eq) for which the “impl_source” must be found. The process of finding an “impl_source” is called “resolving” the Obligation. This process consists of either identifying an impl (e.g., impl Eq for i32) that satisfies the obligation, or else finding a bound that is in scope. The eventual result is usually a Selection (defined below).

Fields

cause: ObligationCause<'tcx>

The reason we have to prove this thing.

param_env: ParamEnv<'tcx>

The environment in which we should prove this thing.

predicate: T

The thing we are trying to prove.

recursion_depth: usize

If we started proving this as a result of trying to prove something else, track the total depth to ensure termination. If this goes over a certain threshold, we abort compilation – in such cases, we can not say whether or not the predicate holds for certain. Stupid halting problem; such a drag.

Implementations

impl<'tcx> Obligation<'tcx, Predicate<'tcx>>

pub fn flip_polarity( &self, tcx: TyCtxt<'tcx>, ) -> Option<Obligation<'tcx, Predicate<'tcx>>>

Flips the polarity of the inner predicate.

Given T: Trait predicate it returns T: !Trait and given T: !Trait returns T: Trait.

impl<'tcx> Obligation<'tcx, Binder<TyCtxt<'tcx>, TraitPredicate<TyCtxt<'tcx>>>>

pub fn derived_cause( &self, variant: impl FnOnce(DerivedCause<'tcx>) -> ObligationCauseCode<'tcx>, ) -> ObligationCause<'tcx>

impl<'tcx, O> Obligation<'tcx, O>

pub fn new( tcx: TyCtxt<'tcx>, cause: ObligationCause<'tcx>, param_env: ParamEnv<'tcx>, predicate: impl Upcast<TyCtxt<'tcx>, O>, ) -> Obligation<'tcx, O>

pub fn set_depth_from_parent(&mut self, parent_depth: usize)

We often create nested obligations without setting the correct depth.

To deal with this evaluate and fulfill explicitly update the depth of nested obligations using this function.

pub fn with_depth( tcx: TyCtxt<'tcx>, cause: ObligationCause<'tcx>, recursion_depth: usize, param_env: ParamEnv<'tcx>, predicate: impl Upcast<TyCtxt<'tcx>, O>, ) -> Obligation<'tcx, O>

pub fn misc( tcx: TyCtxt<'tcx>, span: Span, body_id: LocalDefId, param_env: ParamEnv<'tcx>, trait_ref: impl Upcast<TyCtxt<'tcx>, O>, ) -> Obligation<'tcx, O>

pub fn with<P>( &self, tcx: TyCtxt<'tcx>, value: impl Upcast<TyCtxt<'tcx>, P>, ) -> Obligation<'tcx, P>

impl<'tcx> Obligation<'tcx, Binder<TyCtxt<'tcx>, TraitPredicate<TyCtxt<'tcx>>>>

pub fn polarity(&self) -> PredicatePolarity

pub fn self_ty(&self) -> Binder<TyCtxt<'tcx>, Ty<'tcx>>

Trait Implementations

impl<'tcx, T> Clone for Obligation<'tcx, T>

where T: Clone,

fn clone(&self) -> Obligation<'tcx, T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'tcx, O> Debug for Obligation<'tcx, O>

where O: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'tcx> Elaboratable<TyCtxt<'tcx>> for Obligation<'tcx, Predicate<'tcx>>

For Obligation, a sub-obligation is combined with the current obligation’s param-env and cause code.

fn predicate(&self) -> Predicate<'tcx>

fn child(&self, clause: Clause<'tcx>) -> Obligation<'tcx, Predicate<'tcx>>

fn child_with_derived_cause( &self, clause: Clause<'tcx>, span: Span, parent_trait_pred: Binder<TyCtxt<'tcx>, TraitPredicate<TyCtxt<'tcx>>>, index: usize, ) -> Obligation<'tcx, Predicate<'tcx>>

impl<'tcx, P> From<Obligation<'tcx, P>> for Goal<TyCtxt<'tcx>, P>

fn from(value: Obligation<'tcx, P>) -> Goal<TyCtxt<'tcx>, P>

Converts to this type from the input type.

impl<T> Hash for Obligation<'_, T>

where T: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'tcx, T> PartialEq for Obligation<'tcx, T>

where T: PartialEq,

fn eq(&self, other: &Obligation<'tcx, T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'tcx, O> TypeFoldable<TyCtxt<'tcx>> for Obligation<'tcx, O>

where O: TypeFoldable<TyCtxt<'tcx>>,

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<Obligation<'tcx, O>, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, folder: &mut F) -> Self

where F: TypeFolder<I>,

A convenient alternative to try_fold_with for use with infallible folders. Do not override this method, to ensure coherence with try_fold_with.

impl<'tcx, O> TypeVisitable<TyCtxt<'tcx>> for Obligation<'tcx, O>

where O: TypeVisitable<TyCtxt<'tcx>>,

fn visit_with<V>( &self, visitor: &mut V, ) -> <V as TypeVisitor<TyCtxt<'tcx>>>::Result

where V: TypeVisitor<TyCtxt<'tcx>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<T> Eq for Obligation<'_, T>

where T: Eq,

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.