Enum rustc_trait_selection::traits::ObligationCauseCode[−][src]

pub enum ObligationCauseCode<'tcx> {

Show 50 variants    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,
    SizedBoxType,
    InlineAsmSized,
    RepeatVec(bool),
    FieldSized {
        adt_kind: AdtKind,
        span: Span,
        last: bool,
    },
    ConstSized,
    SharedStatic,
    BuiltinDerivedObligation(DerivedObligationCause<'tcx>),
    ImplDerivedObligation(DerivedObligationCause<'tcx>),
    DerivedObligation(DerivedObligationCause<'tcx>),
    FunctionArgumentObligation {
        arg_hir_id: HirId,
        call_hir_id: HirId,
        parent_code: Rc<ObligationCauseCode<'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,
    LetElse,
    MethodReceiver,
    UnifyReceiver(Box<UnifyReceiverContext<'tcx>, Global>),
    ReturnNoExpression,
    ReturnValue(HirId),
    ReturnType,
    BlockTailExpression(HirId),
    TrivialBound,
    OpaqueType,
    WellFormed(Option<WellFormedLoc>),
    MatchImpl(ObligationCause<'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.

Tuple Fields of ProjectionWf

0: ProjectionTy<'tcx>
ItemObligation(DefId)

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

Tuple Fields of ItemObligation

0: DefId
BindingObligation(DefId, Span)

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

Tuple Fields of BindingObligation

0: DefId1: Span
ReferenceOutlivesReferent(&'tcx TyS<'tcx>)

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

Tuple Fields of ReferenceOutlivesReferent

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

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

Tuple Fields of ObjectTypeBound

0: &'tcx TyS<'tcx>1: &'tcx RegionKind
ObjectCastObligation(&'tcx TyS<'tcx>)

Obligation incurred due to an object cast.

Tuple Fields of ObjectCastObligation

0: &'tcx TyS<'tcx>
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.

Tuple Fields of VariableType

0: HirId
SizedArgumentType(Option<Span>)

Argument type must be Sized.

Tuple Fields of SizedArgumentType

0: Option<Span>
SizedReturnType

Return type must be Sized.

SizedYieldType

Yield type must be Sized.

SizedBoxType

Box expression result 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.

Tuple Fields of RepeatVec

0: bool
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>)

Tuple Fields of BuiltinDerivedObligation

0: DerivedObligationCause<'tcx>
ImplDerivedObligation(DerivedObligationCause<'tcx>)

Tuple Fields of ImplDerivedObligation

0: DerivedObligationCause<'tcx>
DerivedObligation(DerivedObligationCause<'tcx>)

Tuple Fields of DerivedObligation

0: DerivedObligationCause<'tcx>
FunctionArgumentObligation

Fields of FunctionArgumentObligation

arg_hir_id: HirId

The node of the relevant argument in the function call.

call_hir_id: HirId

The node of the function call.

parent_code: Rc<ObligationCauseCode<'tcx>>

The obligation introduced by this argument.

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

Tuple Fields of MatchExpressionArm

0: Box<MatchExpressionArmCause<'tcx>, Global>
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

Tuple Fields of IfExpression

0: Box<IfExpressionCause, Global>
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

LetElse

A let else block does not diverge

MethodReceiver

Method receiver

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

Tuple Fields of UnifyReceiver

0: Box<UnifyReceiverContext<'tcx>, Global>
ReturnNoExpression

return with no expression

ReturnValue(HirId)

return with an expression

Tuple Fields of ReturnValue

0: HirId
ReturnType

Return type of this function

BlockTailExpression(HirId)

Block implicit return

Tuple Fields of BlockTailExpression

0: HirId
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)

Tuple Fields of WellFormed

0: Option<WellFormedLoc>
MatchImpl(ObligationCause<'tcx>, DefId)

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

Tuple Fields of MatchImpl

0: ObligationCause<'tcx>1: DefId

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Performs the conversion.

Performs the conversion.

The resulting type after obtaining ownership.

Creates owned data from borrowed data, usually by cloning. Read more

🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.

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: 40 bytes

Size for each variant: