Enum Type

pub enum Type {
    Primitive(TypeId, Sym, Pos),
    Enum {
        name: Sym,
        id: TypeId,
        is_extern: bool,
        is_nodebug: bool,
        variants: Vec<Variant>,
        pos: Pos,
    },
}

A type.

Variants

Primitive(TypeId, Sym, Pos)

A primitive, Copy type.

These are always defined externally, and we allow literals of these types to pass through from ISLE source code to the emitted Rust code.

Enum

A sum type.

Note that enums with only one variant are equivalent to a “struct”.

Fields

name: Sym

The name of this enum.

id: TypeId

This enum’s type id.

is_extern: bool

Is this enum defined in external Rust code?

If so, ISLE will not emit a definition for it. If not, then it will emit a Rust definition for it.

is_nodebug: bool

Whether this type should not derive Debug.

Incompatible with is_extern.

variants: Vec<Variant>

The different variants for this enum.

pos: Pos

The ISLE source position where this enum is defined.

Implementations

impl Type

pub fn name<'a>(&self, tyenv: &'a TypeEnv) -> &'a str

Get the name of this Type.

pub fn pos(&self) -> Pos

Get the position where this type was defined.

pub fn is_prim(&self) -> bool

Is this a primitive type?

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

impl StructuralPartialEq for Type