Struct Obligation 

pub struct Obligation<'db, T> {
    pub cause: ObligationCause,
    pub param_env: ParamEnv<'db>,
    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

The reason we have to prove this thing.

param_env: ParamEnv<'db>

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<'db, T> Obligation<'db, T>

where T: Copy,

pub fn as_goal(&self) -> Goal<DbInterner<'db>, T>

impl<'db> Obligation<'db, Predicate<'db>>

pub fn flip_polarity( &self, _interner: DbInterner<'db>, ) -> Option<Obligation<'db, Predicate<'db>>>

Flips the polarity of the inner predicate.

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

impl<'db, O> Obligation<'db, O>

pub fn new( interner: DbInterner<'db>, cause: ObligationCause, param_env: ParamEnv<'db>, predicate: impl Upcast<DbInterner<'db>, O>, ) -> Obligation<'db, 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( interner: DbInterner<'db>, cause: ObligationCause, recursion_depth: usize, param_env: ParamEnv<'db>, predicate: impl Upcast<DbInterner<'db>, O>, ) -> Obligation<'db, O>

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

Trait Implementations

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

where T: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'db, T> Debug for Obligation<'db, T>

where T: Debug,

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

Formats the value using the given formatter.

impl<'db> Elaboratable<DbInterner<'db>> for Obligation<'db, Predicate<'db>>

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

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

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

fn child_with_derived_cause( &self, clause: Clause<'db>, span: Span, _parent_trait_pred: Binder<DbInterner<'db>, TraitPredicate<DbInterner<'db>>>, _index: usize, ) -> Obligation<'db, Predicate<'db>>

impl<'db, P> From<Obligation<'db, P>> for Goal<DbInterner<'db>, P>

fn from(value: Obligation<'db, P>) -> Goal<DbInterner<'db>, P>

Converts to this type from the input type.

impl<'db, T> Hash for Obligation<'db, 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<'db, T> PartialEq for Obligation<'db, T>

where T: PartialEq,

fn eq(&self, other: &Obligation<'db, 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<'db, T> TypeFoldable<DbInterner<'db>> for Obligation<'db, T>

where T: TypeFoldable<DbInterner<'db>>,

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<Obligation<'db, T>, <__F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where __F: FallibleTypeFolder<DbInterner<'db>>,

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) -> Obligation<'db, T>

where __F: TypeFolder<DbInterner<'db>>,

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

impl<'db, T> TypeVisitable<DbInterner<'db>> for Obligation<'db, T>

where T: TypeVisitable<DbInterner<'db>>,

fn visit_with<__V>( &self, __visitor: &mut __V, ) -> <__V as TypeVisitor<DbInterner<'db>>>::Result

where __V: TypeVisitor<DbInterner<'db>>,

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

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

where T: Eq,