Enum Discriminator 

pub enum Discriminator {
    Known(VariantId),
    Invalid,
    Branch {
        offset: OffsetExpr,
        int_ty: IntegerTy,
        children: Vec<(RangeInclusive<IntegerValue>, Discriminator)>,
        fallback: Box<Discriminator>,
    },
}

Decision tree used to determine the active variant by reading memory. Mirrors MiniRust’s Discriminator.

Variants

Known(VariantId)

The variant is known.

Invalid

No valid variant (e.g., invalid tag value).

Branch

Branch on an integer value read from memory at offset.

Fields

offset: OffsetExpr

Byte offset to read from.

int_ty: IntegerTy

Integer type to read.

children: Vec<(RangeInclusive<IntegerValue>, Discriminator)>

If the integer is in one of these ranges, continue with the given Discriminator. The ranges are sorted.

fallback: Box<Discriminator>

Fallback if no range in children matches.

Implementations

impl Discriminator

pub fn trivial(variant_id: VariantId) -> Self

Make a trivial discriminator that always returns the given variant id.

pub fn read_discriminant( &self, read: impl Fn(ByteCount, IntegerTy) -> Result<IntegerValue, DiscriminantReadError> + Copy, ) -> Result<VariantId, DiscriminantReadError>

Read a discriminant from memory. The read function simulates reading an integer of the given type at the given byte offset from memory and can return UninitByte if the byte could not be read.

Trait Implementations

impl AstVisitable for Discriminator

fn drive<V: VisitAst>(&self, v: &mut V) -> ControlFlow<V::Break>

Recursively visit this type with the provided visitor. This calls the visitor’s visit_$any method if it exists, otherwise visit_inner.

fn drive_mut<V: VisitAstMut>(&mut self, v: &mut V) -> ControlFlow<V::Break>

Recursively visit this type with the provided visitor. This calls the visitor’s visit_$any method if it exists, otherwise visit_inner.

fn drive_two<V: ZipAst>(&self, other: &Self, v: &mut V) -> ControlFlow<V::Break>

Recursively visit this type with the provided visitor. This calls the visitor’s visit_$any method if it exists, otherwise visit_inner.

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

The name of the type, used for debug logging.

fn dyn_visit<T: AstVisitable>(&self, f: impl FnMut(&T))

where Self: Sized,

Visit all occurrences of that type inside self, in pre-order traversal.

fn dyn_visit_mut<T: AstVisitable>(&mut self, f: impl FnMut(&mut T))

where Self: Sized,

Visit all occurrences of that type inside self, in pre-order traversal.

impl Clone for Discriminator

fn clone(&self) -> Discriminator

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Discriminator

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

Formats the value using the given formatter.

impl<'de, __State: ?Sized + DedupSerializerState> DeserializeState<'de, __State> for Discriminator

fn deserialize_state<__D>( __state: &__State, __deserializer: __D, ) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

impl<'s, V> Drive<'s, V> for Discriminator

where V: Visitor + Visit<'s, VariantId> + Visit<'s, OffsetExpr> + Visit<'s, IntegerTy> + Visit<'s, Vec<(RangeInclusive<IntegerValue>, Discriminator)>> + Visit<'s, Box<Discriminator>>,

fn drive_inner(&'s self, visitor: &mut V) -> ControlFlow<V::Break>

Call v.visit() on the immediate contents of self.

impl<'s, V> DriveMut<'s, V> for Discriminator

where V: Visitor + VisitMut<'s, VariantId> + VisitMut<'s, OffsetExpr> + VisitMut<'s, IntegerTy> + VisitMut<'s, Vec<(RangeInclusive<IntegerValue>, Discriminator)>> + VisitMut<'s, Box<Discriminator>>,

fn drive_inner_mut(&'s mut self, visitor: &mut V) -> ControlFlow<V::Break>

Call v.visit() on the immediate contents of self.

impl<'s, V> DriveTwo<'s, V> for Discriminator

where V: Visitor<Break: Default> + VisitTwo<'s, VariantId> + VisitTwo<'s, OffsetExpr> + VisitTwo<'s, IntegerTy> + VisitTwo<'s, Vec<(RangeInclusive<IntegerValue>, Discriminator)>> + VisitTwo<'s, Box<Discriminator>>,

fn drive_two_inner( &'s self, other: &'s Self, visitor: &mut V, ) -> ControlFlow<V::Break>

Call v.visit() on the immediate contents of self and other, if they correspond. If the values don’t match up, this returns Break(Default::default()).

impl<C: AstFormatter> FmtWithCtx<C> for Discriminator

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

fn with_ctx<'a>(&'a self, ctx: &'a C) -> WithCtx<'a, C, Self>

Returns a struct that implements Display. This allows the following:

fn to_string_with_ctx(&self, ctx: &C) -> String

impl<__State: ?Sized + DedupSerializerState> SerializeState<__State> for Discriminator

fn serialize_state<__S>( &self, __state: &__State, __serializer: __S, ) -> Result<__S::Ok, __S::Error>

where __S: Serializer,