Struct ObligationCause

pub struct ObligationCause<'tcx> {
    pub span: Span,
    pub body_id: LocalDefId,
    code: InternedObligationCauseCode<'tcx>,
}

The reason why we incurred this obligation; used for error reporting.

Non-misc ObligationCauseCodes are stored on the heap. This gives the best trade-off between keeping the type small (which makes copies cheaper) while not doing too many heap allocations.

We do not want to intern this as there are a lot of obligation causes which only live for a short period of time.

Fields

span: Span

body_id: LocalDefId

The ID of the fn body that triggered this obligation. This is used for region obligations to determine the precise environment in which the region obligation should be evaluated (in particular, closures can add new assumptions). See the field region_obligations of the FulfillmentContext for more information.

code: InternedObligationCauseCode<'tcx>

Implementations

impl<'tcx> ObligationCause<'tcx>

pub fn new( span: Span, body_id: LocalDefId, code: ObligationCauseCode<'tcx>, ) -> ObligationCause<'tcx>

pub fn misc(span: Span, body_id: LocalDefId) -> ObligationCause<'tcx>

pub fn dummy() -> ObligationCause<'tcx>

pub fn dummy_with_span(span: Span) -> ObligationCause<'tcx>

pub fn code(&self) -> &ObligationCauseCode<'tcx>

pub fn map_code( &mut self, f: impl FnOnce(InternedObligationCauseCode<'tcx>) -> ObligationCauseCode<'tcx>, )

pub fn derived_cause( self, parent_trait_pred: Binder<TyCtxt<'tcx>, TraitPredicate<TyCtxt<'tcx>>>, variant: impl FnOnce(DerivedCause<'tcx>) -> ObligationCauseCode<'tcx>, ) -> ObligationCause<'tcx>

Creates a cause for obligations that are derived from obligation by a recursive search (e.g., for a builtin bound, or eventually a auto trait Foo). If obligation is itself a derived obligation, this is just a clone, but otherwise we create a “derived obligation” cause so as to keep track of the original root obligation for error reporting.

pub fn to_constraint_category(&self) -> ConstraintCategory<'tcx>

Trait Implementations

impl<'tcx> Clone for ObligationCause<'tcx>

fn clone(&self) -> ObligationCause<'tcx>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'tcx> Debug for ObligationCause<'tcx>

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

Formats the value using the given formatter.

impl<'tcx, __D> Decodable<__D> for ObligationCause<'tcx>

where __D: TyDecoder<I = TyCtxt<'tcx>>,

fn decode(__decoder: &mut __D) -> ObligationCause<'tcx>

impl<'tcx, __E> Encodable<__E> for ObligationCause<'tcx>

where __E: TyEncoder<I = TyCtxt<'tcx>>,

fn encode(&self, __encoder: &mut __E)

impl Hash for ObligationCause<'_>

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, '__ctx> HashStable<StableHashingContext<'__ctx>> for ObligationCause<'tcx>

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher<SipHasher128>, )

impl<'tcx> ObligationCauseExt<'tcx> for ObligationCause<'tcx>

fn as_failure_code(&self, terr: TypeError<'tcx>) -> FailureCode

fn as_failure_code_diag( &self, terr: TypeError<'tcx>, span: Span, subdiags: Vec<TypeErrorAdditionalDiags>, ) -> ObligationCauseFailureCode

fn as_requirement_str(&self) -> &'static str

impl<'tcx> PartialEq for ObligationCause<'tcx>

fn eq(&self, other: &ObligationCause<'tcx>) -> 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> TypeFoldable<TyCtxt<'tcx>> for ObligationCause<'tcx>

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<ObligationCause<'tcx>, <__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> TypeVisitable<TyCtxt<'tcx>> for ObligationCause<'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<'tcx> Eq for ObligationCause<'tcx>

impl<'tcx> StructuralPartialEq for ObligationCause<'tcx>

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 24 bytes