Enum debris_llir::types::Type

pub enum Type {
    Any,
    Null,
    Never,
    ComptimeInt,
    DynamicInt,
    ComptimeBool,
    DynamicBool,
    String,
    FormatString,
    Function,
    FunctionRef,
    Type,
    Module,
    Struct,
    StructObject,
    Tuple,
    TupleObject,
}

The type of a class object

Variants

Any

Type which matches with every other type Objects of type any should not exist.

Null

The null type, implicitly returned by functions which don’t specify a return type, also the value that statements return (since everything is an expression)

Never

Marks a value that cannot be constructed, for example The return value of loop {}

ComptimeInt

Compile time known 32-bit signed integer

DynamicInt

32-bit signed integer known at runtime

ComptimeBool

A boolean value known at compile time

DynamicBool

Runtime boolean

String

A compile time known string

FormatString

A compile time known format string

Function

Any function, native or api

FunctionRef

A reference to a compiled function A compiled function is uniquely identified by its block id Basically a function after monomorphization

Type

The type of a type

Module

Module type

Struct

Type of a struct definition

StructObject

An instantiated struct

Tuple

Type of a tuple TODO: Could a Type::Tuple not just be a Type::TupleObject with types as elements?

TupleObject

An instantiated tuple

Implementations

impl Type

pub fn is_int(&self) -> bool

pub fn is_never(&self) -> bool

pub fn diverges(&self) -> bool

pub fn runtime_encodable(&self) -> bool

Returns whether this type can be completely encoded at runtime

pub fn comptime_encodable(&self) -> bool

Returns whether this type can be encoded at compile time.

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

Returns whether other matches the pattern of self

pub fn is_reference(&self) -> bool

Returns whether this type should be treated as a reference. This effects e.g. whether variables get copied when assigned or passed to functions TODO: implement some proper reference object, to make this less implicit and confusing. Right now, only structs are treated as references

Trait Implementations

impl Clone for Type

fn clone(&self) -> Type

Returns a copy 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

Formats the value using the given formatter.

impl Display for Type

Error messages can safely use the debug impl for display

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

Formats the value using the given formatter.

impl From<Type> for ClassKind

fn from(value: Type) -> Self

Converts to this type from the input type.

impl Hash for Type

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

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Type

impl Eq for Type

impl StructuralEq for Type

impl StructuralPartialEq for Type