Enum Type 

pub enum Type {
    Unknown,
    Never,
    I1,
    I8,
    U8,
    I16,
    U16,
    I32,
    U32,
    I64,
    U64,
    I128,
    U128,
    U256,
    F64,
    Felt,
    Ptr(Arc<PointerType>),
    Struct(Arc<StructType>),
    Enum(Arc<EnumType>),
    Array(Arc<ArrayType>),
    List(Arc<Type>),
    Function(Arc<FunctionType>),
}

Represents the type of a value in the HIR type system

Variants

Unknown

This indicates a failure to type a value, or a value which is untypable

Never

This type is the bottom type, and represents divergence, akin to Rust’s Never/! type

I1

A 1-bit integer, i.e. a boolean value.

When the bit is 1, the value is true; 0 is false.

I8

An 8-bit signed integer.

U8

An 8-bit unsigned integer.

I16

A 16-bit signed integer.

U16

A 16-bit unsigned integer.

I32

A 32-bit signed integer.

U32

A 32-bit unsigned integer.

I64

A 64-bit signed integer.

U64

A 64-bit unsigned integer.

I128

A 128-bit signed integer.

U128

A 128-bit unsigned integer.

U256

A 256-bit unsigned integer.

F64

A 64-bit IEEE-754 floating-point value.

NOTE: These are currently unsupported in practice, but is reserved here for future use.

Felt

A field element corresponding to the native Miden field (currently the Goldilocks field)

Ptr(Arc<PointerType>)

A pointer to a value in a byte-addressable address space.

Pointers of this type are not equivalent to element addresses as referred to in the Miden Assembly documentation, but do have a straightforward conversion.

Struct(Arc<StructType>)

A compound type of fixed shape and size

Enum(Arc<EnumType>)

A tagged type enumeration with a fixed number of variants

Array(Arc<ArrayType>)

A vector of fixed size

List(Arc<Type>)

A dynamically sized list of values of the given type

NOTE: Currently this only exists to support the Wasm Canonical ABI, but it has no defined represenation yet, so in practice cannot be used in most places except during initial translation in the Wasm frontend.

Function(Arc<FunctionType>)

A reference to a function with the given type signature

Implementations

impl Type

pub fn to_raw_parts(self) -> Option<SmallVec<[Type; 4]>>

Convert this type into a vector of types corresponding to how this type will be represented in memory.

The largest “part” size is 32 bits, so types that fit in 32 bits remain unchanged. For types larger than 32 bits, they will be broken up into parts that do fit in 32 bits, preserving accurate types to the extent possible. For types smaller than 32 bits, they will be merged into packed structs no larger than 32 bits, to preserve the type information, and make it possible to reason about how to extract parts of the original type.

For an example, a struct of type { *ptr, u8, u8 } will be encoded on the operand stack as [*ptr, {u8, u8}], where the first value is the 32-bit pointer field, and the remaining fields are encoded as a 16-bit struct in the second value.

pub fn split(self, n: usize) -> (Type, Option<Type>)

Split this type into two parts:

• The first part is no more than n bytes in size, and may contain the type itself if it fits
• The second part is None if the first part is smaller than or equal in size to the requested split size
• The second part is Some if there is data left in the original type after the split. This part will be a type that attempts to preserve, to the extent possible, the original type structure, but will fall back to an array of bytes if a larger type must be split down the middle somewhere.

pub fn min_alignment(&self) -> usize

Returns the minimum alignment, in bytes, of this type

pub fn size_in_bits(&self) -> usize

Returns the size in bits of this type, without alignment padding.

pub fn size_in_bytes(&self) -> usize

Returns the minimum number of bytes required to store a value of this type

pub fn aligned_size_in_bytes(&self) -> usize

Same as size_in_bytes, but with sufficient padding to guarantee alignment of the value.

pub fn size_in_felts(&self) -> usize

Returns the size in field elements of this type

pub fn size_in_words(&self) -> usize

Returns the size in words of this type

pub fn layout(&self) -> Layout

Returns the layout of this type in memory

pub fn is_loadable(&self) -> bool

Returns true if this type can be loaded on to the operand stack

The rule for “loadability” is a bit arbitrary, but the purpose is to force users of the IR to either pass large values by reference, or calculate the addresses of the individual fields needed from a large structure or array, and issue loads/stores against those instead.

In effect, we reject loads of values that are larger than a single word, as that is the largest value which can be worked with on the operand stack of the Miden VM.

impl Type

pub fn is_zst(&self) -> bool

Returns true if this type is a zero-sized type, which includes:

• Types with no size, e.g. Never
• Zero-sized arrays
• Arrays with a zero-sized element type
• Structs composed of nothing but zero-sized fields

pub fn is_numeric(&self) -> bool

Returns true if this type is any numeric type

pub fn is_integer(&self) -> bool

Returns true if this type is any integral type

pub fn is_signed_integer(&self) -> bool

Returns true if this type is any signed integral type

pub fn is_unsigned_integer(&self) -> bool

Returns true if this type is any unsigned integral type

pub fn as_unsigned(&self) -> Type

Get this type as its unsigned integral twin, e.g. i32 becomes u32.

This function will panic if the type is not an integer type, or has no unsigned representation

pub fn as_signed(&self) -> Type

Get this type as its signed integral twin, e.g. u32 becomes i32.

This function will panic if the type is not an integer type, or has no signed representation

pub fn is_float(&self) -> bool

Returns true if this type is a floating-point type

pub fn is_felt(&self) -> bool

Returns true if this type is the field element type

pub fn is_pointer(&self) -> bool

Returns true if this type is a pointer type

pub fn pointee(&self) -> Option<&Type>

Returns the type of the pointee, if this type is a pointer type

pub fn is_struct(&self) -> bool

Returns true if this type is a struct type

pub fn is_array(&self) -> bool

Returns true if this type is an array type

pub fn is_list(&self) -> bool

Returns true if this type is a dynamically-sized vector/list type

pub fn is_function(&self) -> bool

Returns true if this type is a function reference type

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

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

Formats the value using the given formatter.

impl Deserializable for Type

fn read_from<R>(source: &mut R) -> Result<Type, DeserializationError>

where R: ByteReader,

Reads a sequence of bytes from the provided source, attempts to deserialize these bytes into Self, and returns the result.

fn min_serialized_size() -> usize

Returns the minimum serialized size for one instance of this type.

fn read_from_bytes(bytes: &[u8]) -> Result<Self, DeserializationError>

Attempts to deserialize the provided bytes into Self and returns the result.

fn read_from_bytes_with_budget( bytes: &[u8], budget: usize, ) -> Result<Self, DeserializationError>

Deserializes Self from bytes with a byte budget limit.

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

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

Print this type for display using the provided module context

impl From<Arc<ArrayType>> for Type

fn from(ty: Arc<ArrayType>) -> Type

Converts to this type from the input type.

impl From<Arc<FunctionType>> for Type

fn from(ty: Arc<FunctionType>) -> Type

Converts to this type from the input type.

impl From<Arc<PointerType>> for Type

fn from(ty: Arc<PointerType>) -> Type

Converts to this type from the input type.

impl From<Arc<StructType>> for Type

fn from(ty: Arc<StructType>) -> Type

Converts to this type from the input type.

impl From<ArrayType> for Type

fn from(ty: ArrayType) -> Type

Converts to this type from the input type.

impl From<Box<ArrayType>> for Type

fn from(ty: Box<ArrayType>) -> Type

Converts to this type from the input type.

impl From<Box<FunctionType>> for Type

fn from(ty: Box<FunctionType>) -> Type

Converts to this type from the input type.

impl From<Box<PointerType>> for Type

fn from(ty: Box<PointerType>) -> Type

Converts to this type from the input type.

impl From<Box<StructType>> for Type

fn from(ty: Box<StructType>) -> Type

Converts to this type from the input type.

impl From<FunctionType> for Type

fn from(ty: FunctionType) -> Type

Converts to this type from the input type.

impl From<PointerType> for Type

fn from(ty: PointerType) -> Type

Converts to this type from the input type.

impl From<StructType> for Type

fn from(ty: StructType) -> Type

Converts to this type from the input type.

impl From<Type> for NameAndType

fn from(ty: Type) -> NameAndType

Converts to this type from the input type.

impl From<Type> for TypeExpr

fn from(ty: Type) -> TypeExpr

Converts to this type from the input 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 PartialEq for Type

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

fn render(&self) -> Document

The core of the [PrettyPrint] functionality.

fn to_pretty_string(&self) -> String

Produce a String containing the results of pretty-printing this object.

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

Pretty-print this object to the given core::fmt::Formatter.

impl Serializable for Type

Provides Type serialization support via the miden-serde-utils serializer.

This is a temporary implementation to allow type information to be serialized with libraries, but in a future release we’ll either rely on the serde serialization for these types, or provide the serialization implementation in midenc-hir-type instead

fn write_into<W>(&self, target: &mut W)

where W: ByteWriter,

Serializes self into bytes and writes these bytes into the target.

fn to_bytes(&self) -> Vec<u8>

Serializes self into a vector of bytes.

fn get_size_hint(&self) -> usize

Returns an estimate of how many bytes are needed to represent self.

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 TryFrom<Type> for StructType

type Error = Type

The type returned in the event of a conversion error.

fn try_from( ty: Type, ) -> Result<StructType, <StructType as TryFrom<Type>>::Error>

Performs the conversion.

impl Eq for Type

impl StructuralPartialEq for Type