Struct rustc_infer::traits::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<'tcx, TraitPredicate<'tcx>>>

pub fn is_const(&self) -> bool

Returns true if the trait predicate is considered const in its ParamEnv.

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

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

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

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

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

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

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

pub fn polarity(&self) -> ImplPolarity

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

Feeds a slice of this type into the given Hasher.

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

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

This method tests for self and other values to be equal, and is used by ==.

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

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

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

fn try_fold_with<F: FallibleTypeFolder<'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) -> Selfwhere
    F: TypeFolder<'tcx>,

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

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

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

fn has_vars_bound_at_or_above(&self, binder: DebruijnIndex) -> bool

Returns true if self has any late-bound regions that are either bound by binder or bound by some binder outside of binder. If binder is ty::INNERMOST, this indicates whether there are any late-bound regions that appear free.

fn has_vars_bound_above(&self, binder: DebruijnIndex) -> bool

Returns true if this self has any regions that escape binder (and hence are not bound by it).

fn has_escaping_bound_vars(&self) -> bool

fn has_type_flags(&self, flags: TypeFlags) -> bool

fn has_projections(&self) -> bool

fn has_opaque_types(&self) -> bool

fn references_error(&self) -> bool

fn error_reported(&self) -> Option<ErrorGuaranteed>

fn has_param_types_or_consts(&self) -> bool

fn has_infer_regions(&self) -> bool

fn has_infer_types(&self) -> bool

fn has_infer_types_or_consts(&self) -> bool

fn needs_infer(&self) -> bool

fn has_placeholders(&self) -> bool

fn needs_subst(&self) -> bool

fn has_free_regions(&self) -> bool

“Free” regions in this context means that it has any region that is not (a) erased or (b) late-bound.

fn has_erased_regions(&self) -> bool

fn has_erasable_regions(&self) -> bool

True if there are any un-erased free regions.

fn is_global(&self) -> bool

Indicates whether this value references only ‘global’ generic parameters that are the same regardless of what fn we are in. This is used for caching.

fn has_late_bound_regions(&self) -> bool

True if there are any late-bound regions

fn still_further_specializable(&self) -> bool

Indicates whether this value still has parameters/placeholders/inference variables which could be replaced later, in a way that would change the results of impl specialization.

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

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

impl<'tcx, T> StructuralPartialEq for Obligation<'tcx, 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.