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<PredicateObligation<'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<'tcx, Ty<'tcx>>

Trait Implementations

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

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> Debug for Obligation<'tcx, O>

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

Formats the value using the given formatter.

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

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

Converts to this type from the input type.

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

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

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> PartialEq for Obligation<'tcx, T>

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>>> TypeFoldable<TyCtxt<'tcx>> for Obligation<'tcx, O>

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

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>>> TypeVisitable<TyCtxt<'tcx>> for Obligation<'tcx, O>

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

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

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

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.