Type Alias rustc_middle::mir::AssertMessage

pub type AssertMessage<'tcx> = AssertKind<Operand<'tcx>>;

Type for MIR Assert terminator error messages.

Aliased Type

enum AssertMessage<'tcx> {
    BoundsCheck {
        len: Operand<'tcx>,
        index: Operand<'tcx>,
    },
    Overflow(BinOp, Operand<'tcx>, Operand<'tcx>),
    OverflowNeg(Operand<'tcx>),
    DivisionByZero(Operand<'tcx>),
    RemainderByZero(Operand<'tcx>),
    ResumedAfterReturn(GeneratorKind),
    ResumedAfterPanic(GeneratorKind),
    MisalignedPointerDereference {
        required: Operand<'tcx>,
        found: Operand<'tcx>,
    },
}

Variants

BoundsCheck

Fields

len: Operand<'tcx>

index: Operand<'tcx>

Overflow(BinOp, Operand<'tcx>, Operand<'tcx>)

OverflowNeg(Operand<'tcx>)

DivisionByZero(Operand<'tcx>)

RemainderByZero(Operand<'tcx>)

ResumedAfterReturn(GeneratorKind)

ResumedAfterPanic(GeneratorKind)

MisalignedPointerDereference

Fields

required: Operand<'tcx>

found: Operand<'tcx>

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 description(&self) -> &'static str

Get the message that is printed at runtime when this assertion fails.

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.

pub fn fmt_assert_args<W: Write>(&self, f: &mut W) -> Resultwhere 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::description 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) -> DiagnosticMessage

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::description 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(Cow<'static, str>, DiagnosticArgValue<'static>) )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<'tcx, O, __D: TyDecoder<I = TyCtxt<'tcx>>> Decodable<__D> for AssertKind<O>where O: Decodable<__D>,

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

impl<'tcx, O, __E: TyEncoder<I = TyCtxt<'tcx>>> 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<AssertKind<O>> for AssertKind<O>

fn eq(&self, other: &AssertKind<O>) -> 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<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) -> Selfwhere 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 ) -> ControlFlow<__V::BreakTy>

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

Size for each variant:

• BoundsCheck: 55 bytes
• Overflow: 55 bytes
• OverflowNeg: 31 bytes
• DivisionByZero: 31 bytes
• RemainderByZero: 31 bytes
• ResumedAfterReturn: 1 byte
• ResumedAfterPanic: 1 byte
• MisalignedPointerDereference: 55 bytes