Enum AssertKind

pub enum AssertKind<O> {
    BoundsCheck {
        len: O,
        index: O,
    },
    Overflow(BinOp, O, O),
    OverflowNeg(O),
    DivisionByZero(O),
    RemainderByZero(O),
    ResumedAfterReturn(CoroutineKind),
    ResumedAfterPanic(CoroutineKind),
    MisalignedPointerDereference {
        required: O,
        found: O,
    },
    NullPointerDereference,
}

Information about an assertion failure.

Variants

BoundsCheck

Fields

len: O

index: O

Overflow(BinOp, O, O)

OverflowNeg(O)

DivisionByZero(O)

RemainderByZero(O)

ResumedAfterReturn(CoroutineKind)

ResumedAfterPanic(CoroutineKind)

MisalignedPointerDereference

Fields

required: O

found: O

NullPointerDereference

Implementations

impl<O> AssertKind<O>

pub fn is_optional_overflow_check(&self) -> bool

Returns true if this an overflow checking assertion controlled by -C overflow-checks.

pub fn panic_function(&self) -> LangItem

Get the lang item that is invoked to print a static message when this assert fires.

The caller is expected to handle BoundsCheck and MisalignedPointerDereference by invoking the appropriate lang item (panic_bounds_check/panic_misaligned_pointer_dereference) instead of printing a static message. Those have dynamic arguments that aren’t present for the rest of the messages here.

pub fn fmt_assert_args<W: Write>(&self, f: &mut W) -> Result

where O: Debug,

Format the message arguments for the assert(cond, msg..) terminator in MIR printing.

Needs to be kept in sync with the run-time behavior (which is defined by AssertKind::panic_function and the lang items mentioned in its docs). Note that we deliberately show more details here than we do at runtime, such as the actual numbers that overflowed – it is much easier to do so here than at runtime.

pub fn diagnostic_message(&self) -> DiagMessage

Format the diagnostic message for use in a lint (e.g. when the assertion fails during const-eval).

Needs to be kept in sync with the run-time behavior (which is defined by AssertKind::panic_function and the lang items mentioned in its docs). Note that we deliberately show more details here than we do at runtime, such as the actual numbers that overflowed – it is much easier to do so here than at runtime.

pub fn add_args(self, adder: &mut dyn FnMut(DiagArgName, DiagArgValue))

where O: Debug,

Trait Implementations

impl<O: Clone> Clone for AssertKind<O>

fn clone(&self) -> AssertKind<O>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<O: Debug> Debug for AssertKind<O>

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

Formats the value using the given formatter.

impl<O, __D: TyDecoder> Decodable<__D> for AssertKind<O>

where O: Decodable<__D>,

fn decode(__decoder: &mut __D) -> Self

impl<O, __E: TyEncoder> Encodable<__E> for AssertKind<O>

where O: Encodable<__E>,

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

impl<O: Hash> Hash for AssertKind<O>

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<'__ctx, O> HashStable<StableHashingContext<'__ctx>> for AssertKind<O>

where O: HashStable<StableHashingContext<'__ctx>>,

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

impl<O: PartialEq> PartialEq for AssertKind<O>

fn eq(&self, other: &AssertKind<O>) -> 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>> for AssertKind<O>

where O: TypeFoldable<TyCtxt<'tcx>>,

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>> for AssertKind<O>

where O: TypeVisitable<TyCtxt<'tcx>>,

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<O> StructuralPartialEq for AssertKind<O>

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.