Enum rustc_trait_selection::traits::ObligationCauseCode

pub enum ObligationCauseCode<'tcx> {
    MiscObligation,
    SliceOrArrayElem,
    TupleElem,
    ProjectionWf(ProjectionTy<'tcx>),
    ItemObligation(DefId),
    BindingObligation(DefId, Span),
    ReferenceOutlivesReferent(&'tcx TyS<'tcx>),
    ObjectTypeBound(&'tcx TyS<'tcx>, &'tcx RegionKind),
    ObjectCastObligation(&'tcx TyS<'tcx>),
    Coercion {
        source: &'tcx TyS<'tcx>,
        target: &'tcx TyS<'tcx>,
    },
    AssignmentLhsSized,
    TupleInitializerSized,
    StructInitializerSized,
    VariableType(HirId),
    SizedArgumentType(Option<Span>),
    SizedReturnType,
    SizedYieldType,
    InlineAsmSized,
    RepeatVec(bool),
    FieldSized {
        adt_kind: AdtKind,
        span: Span,
        last: bool,
    },
    ConstSized,
    SharedStatic,
    BuiltinDerivedObligation(DerivedObligationCause<'tcx>),
    ImplDerivedObligation(DerivedObligationCause<'tcx>),
    DerivedObligation(DerivedObligationCause<'tcx>),
    CompareImplConstObligation,
    CompareImplMethodObligation {
        item_name: Symbol,
        impl_item_def_id: DefId,
        trait_item_def_id: DefId,
    },
    CompareImplTypeObligation {
        item_name: Symbol,
        impl_item_def_id: DefId,
        trait_item_def_id: DefId,
    },
    ExprAssignable,
    MatchExpressionArm(Box<MatchExpressionArmCause<'tcx>, Global>),
    Pattern {
        span: Option<Span>,
        root_ty: &'tcx TyS<'tcx>,
        origin_expr: bool,
    },
    ConstPatternStructural,
    IfExpression(Box<IfExpressionCause, Global>),
    IfExpressionWithNoElse,
    MainFunctionType,
    StartFunctionType,
    IntrinsicType,
    MethodReceiver,
    UnifyReceiver(Box<UnifyReceiverContext<'tcx>, Global>),
    ReturnNoExpression,
    ReturnValue(HirId),
    ReturnType,
    BlockTailExpression(HirId),
    TrivialBound,
    OpaqueType,
    WellFormed(Option<WellFormedLoc>),
    MatchImpl(Rc<ObligationCauseCode<'tcx>>, DefId),
}

Variants

MiscObligation

Not well classified or should be obvious from the span.

SliceOrArrayElem

A slice or array is WF only if T: Sized.

TupleElem

A tuple is WF only if its middle elements are Sized.

ProjectionWf(ProjectionTy<'tcx>)

This is the trait reference from the given projection.

ItemObligation(DefId)

In an impl of trait X for type Y, type Y must also implement all supertraits of X.

BindingObligation(DefId, Span)

Like ItemObligation, but with extra detail on the source of the obligation.

ReferenceOutlivesReferent(&'tcx TyS<'tcx>)

A type like &'a T is WF only if T: 'a.

ObjectTypeBound(&'tcx TyS<'tcx>, &'tcx RegionKind)

A type like Box<Foo<'a> + 'b> is WF only if 'b: 'a.

ObjectCastObligation(&'tcx TyS<'tcx>)

Obligation incurred due to an object cast.

Coercion

Obligation incurred due to a coercion.

Fields of Coercion

source: &'tcx TyS<'tcx>target: &'tcx TyS<'tcx>

AssignmentLhsSized

Various cases where expressions must be Sized / Copy / etc. L = X implies that L is Sized.

TupleInitializerSized

(x1, .., xn) must be Sized.

StructInitializerSized

S { ... } must be Sized.

VariableType(HirId)

Type of each variable must be Sized.

SizedArgumentType(Option<Span>)

Argument type must be Sized.

SizedReturnType

Return type must be Sized.

SizedYieldType

Yield type must be Sized.

InlineAsmSized

Inline asm operand type must be Sized.

RepeatVec(bool)

[T, ..n] implies that T must be Copy. If the function in the array repeat expression is a const fn, display a help message suggesting to move the function call to a new const item while saying that T doesn’t implement Copy.

FieldSized

Types of fields (other than the last, except for packed structs) in a struct must be sized.

Fields of FieldSized

adt_kind: AdtKindspan: Spanlast: bool

ConstSized

Constant expressions must be sized.

SharedStatic

static items must have Sync type.

BuiltinDerivedObligation(DerivedObligationCause<'tcx>)

ImplDerivedObligation(DerivedObligationCause<'tcx>)

DerivedObligation(DerivedObligationCause<'tcx>)

CompareImplConstObligation

Error derived when matching traits/impls; see ObligationCause for more details

CompareImplMethodObligation

Error derived when matching traits/impls; see ObligationCause for more details

Fields of CompareImplMethodObligation

item_name: Symbolimpl_item_def_id: DefIdtrait_item_def_id: DefId

CompareImplTypeObligation

Error derived when matching traits/impls; see ObligationCause for more details

Fields of CompareImplTypeObligation

item_name: Symbolimpl_item_def_id: DefIdtrait_item_def_id: DefId

ExprAssignable

Checking that this expression can be assigned where it needs to be

MatchExpressionArm(Box<MatchExpressionArmCause<'tcx>, Global>)

Computing common supertype in the arms of a match expression

Pattern

Type error arising from type checking a pattern against an expected type.

Fields of Pattern

span: Option<Span>

The span of the scrutinee or type expression which caused the root_ty type.

root_ty: &'tcx TyS<'tcx>

The root expected type induced by a scrutinee or type expression.

origin_expr: bool

Whether the Span came from an expression or a type expression.

ConstPatternStructural

Constants in patterns must have Structural type.

IfExpression(Box<IfExpressionCause, Global>)

Computing common supertype in an if expression

IfExpressionWithNoElse

Computing common supertype of an if expression with no else counter-part

MainFunctionType

main has wrong type

StartFunctionType

start has wrong type

IntrinsicType

Intrinsic has wrong type

MethodReceiver

Method receiver

UnifyReceiver(Box<UnifyReceiverContext<'tcx>, Global>)

ReturnNoExpression

return with no expression

ReturnValue(HirId)

return with an expression

ReturnType

Return type of this function

BlockTailExpression(HirId)

Block implicit return

TrivialBound

#[feature(trivial_bounds)] is not enabled

OpaqueType

If X is the concrete type of an opaque type impl Y, then X must implement Y

WellFormed(Option<WellFormedLoc>)

Well-formed checking. If a WellFormedLoc is provided, then it will be used to eprform HIR-based wf checking after an error occurs, in order to generate a more precise error span. This is purely for diagnostic purposes - it is always correct to use MiscObligation instead, or to specify WellFormed(None)

MatchImpl(Rc<ObligationCauseCode<'tcx>>, DefId)

From match_impl. The cause for us having to match an impl, and the DefId we are matching against.

Layout

Note: Most layout information is completely unstable and may be different between compiler versions and platforms. 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: 40 bytes