Enum IrType 

pub enum IrType {
    Primitive {
        name: String,
    },
    Unit,
    Never,
    Array {
        element: Box<IrType>,
        size: Option<usize>,
    },
    Slice {
        element: Box<IrType>,
    },
    Tuple {
        elements: Vec<IrType>,
    },
    Named {
        name: String,
        generics: Vec<IrType>,
    },
    Reference {
        lifetime: Option<String>,
        mutable: bool,
        inner: Box<IrType>,
    },
    Pointer {
        mutable: bool,
        inner: Box<IrType>,
    },
    Function {
        params: Vec<IrType>,
        return_type: Box<IrType>,
        is_async: bool,
    },
    Evidential {
        inner: Box<IrType>,
        evidence: IrEvidence,
    },
    Cycle {
        modulus: u64,
    },
    Simd {
        element: Box<IrType>,
        lanes: usize,
    },
    Atomic {
        inner: Box<IrType>,
    },
    Var {
        id: String,
    },
    Infer,
    Lifetime {
        name: String,
    },
    TraitObject {
        bounds: Vec<IrType>,
    },
    Hrtb {
        lifetimes: Vec<String>,
        bound: Box<IrType>,
    },
    InlineStruct {
        fields: Vec<(String, IrType)>,
    },
    ImplTrait {
        bounds: Vec<IrType>,
    },
    InlineEnum {
        variants: Vec<String>,
    },
    AssocTypeBinding {
        name: String,
        ty: Box<IrType>,
    },
    Error,
}

Type representation in IR

Variants

Primitive

Primitive types (i32, f64, bool, str, etc.)

Fields

name: String

Unit

Unit type ()

Never

Never type !

Array

Array type [T; N]

Fields

element: Box<IrType>

size: Option<usize>

Slice

Slice type [T]

Fields

element: Box<IrType>

Tuple

Tuple type (A, B, C)

Fields

elements: Vec<IrType>

Named

Named struct/enum type

Fields

name: String

generics: Vec<IrType>

Reference

Reference &T, &mut T, &’a T, &’static mut T

Fields

lifetime: Option<String>

mutable: bool

inner: Box<IrType>

Pointer

Pointer *const T or *mut T

Fields

mutable: bool

inner: Box<IrType>

Function

Function type fn(A, B) -> C

Fields

params: Vec<IrType>

return_type: Box<IrType>

is_async: bool

Evidential

Evidential wrapper E with evidence level

Fields

inner: Box<IrType>

evidence: IrEvidence

Cycle

Cyclic arithmetic type Z/nZ

Fields

modulus: u64

Simd

SIMD vector type

Fields

element: Box<IrType>

lanes: usize

Atomic

Atomic type

Fields

inner: Box<IrType>

Var

Type variable (for inference)

Fields

id: String

Infer

Infer placeholder _

Lifetime

Lifetime bound ’static, ’a

Fields

name: String

TraitObject

Trait object: dyn Trait

Fields

bounds: Vec<IrType>

Hrtb

Higher-ranked trait bound: for<’a> Trait<’a>

Fields

lifetimes: Vec<String>

bound: Box<IrType>

InlineStruct

Inline struct type: struct { field: Type, … }

Fields

fields: Vec<(String, IrType)>

ImplTrait

Impl trait: impl Trait bounds

Fields

bounds: Vec<IrType>

InlineEnum

Inline enum type: enum { Variant1, Variant2, … }

Fields

variants: Vec<String>

AssocTypeBinding

Associated type binding: Output = Type

Fields

name: String

ty: Box<IrType>

Error

Error recovery type

Trait Implementations

impl Clone for IrType

fn clone(&self) -> IrType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for IrType

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

Formats the value using the given formatter.

impl Default for IrType

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for IrType

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for IrType

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

where __S: Serializer,

Serialize this value into the given Serde serializer.