Enum Type 

pub enum Type {
    Int(IntType),
    Bool,
    Ptr(PtrType),
    Tuple {
        sized_fields: List<(Size, Type)>,
        sized_head_layout: TupleHeadLayout,
        unsized_field: GcCow<Option<Type>>,
    },
    Array {
        elem: GcCow<Type>,
        count: Int,
    },
    Slice {
        elem: GcCow<Type>,
    },
    Union {
        fields: List<(Size, Type)>,
        chunks: List<(Size, Size)>,
        size: Size,
        align: Align,
    },
    Enum {
        variants: Map<Int, Variant>,
        discriminant_ty: IntType,
        discriminator: Discriminator,
        size: Size,
        align: Align,
    },
    TraitObject(TraitName),
}

The types of MiniRust.

Variants

Int(IntType)

Bool

Ptr(PtrType)

Ptr represents all pointer types: references, raw pointers, boxes, function and vtable pointers. A pointer type does not need the full pointee type, since (de)serializing a pointer does not require knowledge about the pointee. We only track the metadata kind and basic pointee information like size and alignment that is required to check reference validity. This also means types have a finite representation even when the Rust type is recursive.

Tuple

“Tuple” is used for all heterogeneous types, i.e., both Rust tuples and structs.

Fields

sized_fields: List<(Size, Type)>

Fields must not overlap.

sized_head_layout: TupleHeadLayout

The layout of the sized fiels, i.e., the head.

unsized_field: GcCow<Option<Type>>

A last field (in terms of offset), i.e., the tail, may contain an unsized type, then its offset is given by rounding the end of sized_head_layout up to the alignment of this type.

Array

Fields

elem: GcCow<Type>

count: Int

Slice

Slices, i.e. [T] are unsized types which therefore cannot be represented as values. This type is also used for strings: str are treated as [u8].

Fields

elem: GcCow<Type>

Union

Fields

fields: List<(Size, Type)>

Fields may overlap. Fields only exist for field access place projections, they are irrelevant for the representation relation.

chunks: List<(Size, Size)>

A union can be split into multiple “chunks”, where only the data inside those chunks is preserved, and data between chunks is lost (like padding in a struct). This is necessary to model the behavior of some repr(C) unions, see https://github.com/rust-lang/unsafe-code-guidelines/issues/156 for details.

size: Size

The total size of the union, can indicate padding after the last chunk.

align: Align

Total alignment of the union. Due to repr(packed) and repr(align), this is independent of the fields’ alignment.

Enum

Fields

variants: Map<Int, Variant>

The map variants, each identified by a discriminant. Each variant is given by a type and its tag description. All variants are thought to “start at offset 0”; if the discriminant is encoded as an explicit tag, then that will be put into the padding of the active variant. (This means it is not safe to hand out mutable references to a variant at that type, as then the tag might be overwritten!) The Rust type ! is encoded as an Enum with an empty list of variants.

discriminant_ty: IntType

The IntType for the discriminant. This is used for the type of GetDiscriminant and SetDiscriminant. It is entirely independent of how the discriminant is represented in memory (the “tag”).

discriminator: Discriminator

The decision tree to decode the discriminant from the tag at runtime.

size: Size

The total size of the enum can indicate trailing padding. Must be large enough to contain all variants.

align: Align

Total alignment of the enum. Due to repr(packed) and repr(align), this is independent of the fields’ alignment.

TraitObject(TraitName)

A dyn TraitName. Commonly only used behind a pointer.

Implementations

impl Type

pub fn layout<T>(self) -> LayoutStrategy

where T: Target + Obj,

The layout, i.e. the size and align of the type. For ?Sized types, this needs to be computed.

pub fn meta_kind(self) -> PointerMetaKind

Returns the metadata kind when this type is used as a pointee. This matches the meta kind of the layout, but without needing to specify a target.

Trait Implementations

impl Clone for Type

fn clone(&self) -> Type

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Type

impl Debug for Type

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Type

fn deserialize<__D>( __deserializer: __D, ) -> Result<Type, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Type

impl Hash for Type

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

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 Ord for Type

fn cmp(&self, other: &Type) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

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

Restrict a value to a certain range.

impl PartialEq for Type

fn eq(&self, other: &Type) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PartialOrd for Type

fn partial_cmp(&self, other: &Type) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Type

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Type