Enum RustType 

pub enum RustType {
    CVoid,
    CInt {
        unsigned: bool,
        size: CIntegralSize,
    },
    CFloat(CFloatSize),
    CAlias(Ident),
    Array(Box<RustType>, usize),
    Option(Box<RustType>),
    Vec(Box<RustType>),
    Unit,
    I32,
    U8,
    SizeT,
    Isize,
    Usize,
    TVar(TVar),
    Never,
    ExternFn(Vec<Box<RustType>>, bool, Box<RustType>),
    Reference(RustMutability, Box<RustType>),
    Pointer(Box<RustType>),
}

Variants

CVoid

CInt

Fields

unsigned: bool

size: CIntegralSize

CFloat(CFloatSize)

CAlias(Ident)

Array(Box<RustType>, usize)

Option(Box<RustType>)

Vec(Box<RustType>)

Unit

I32

U8

SizeT

Isize

Usize

TVar(TVar)

Never

ExternFn(Vec<Box<RustType>>, bool, Box<RustType>)

Reference(RustMutability, Box<RustType>)

immutable reference

Pointer(Box<RustType>)

*mut T

Implementations

impl RustType

pub fn resolve(&mut self, ctxt: &ProgramTypeContext) -> HashSet<Ident>

Resolves a type according to the type context, avoiding loops, returning the list of types visited

Trait Implementations

impl Clone for RustType

fn clone(&self) -> RustType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RustType

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

Formats the value using the given formatter.

impl Display for RustType

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

Formats the value using the given formatter.

impl From<Type> for RustType

fn from(ty: Type) -> Self

Converts to this type from the input type.

impl Hash for RustType

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 Into<Type> for RustType

fn into(self) -> Type

Converts this type into the (usually inferred) input type.

impl PartialEq for RustType

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

type Error = Error

Defines the type to return when merging of two values fails. If merging is infallible, use the special struct NoError found in this crate, which unlocks various more convenient methods on the unification table.

fn unify_values(value1: &Self, value2: &Self) -> Result<Self, Self::Error>

Given two values, produce a new value that combines them. If that is not possible, produce an error.

impl Eq for RustType

impl StructuralPartialEq for RustType