Enum moore_svlog::hir::TypeKind

pub enum TypeKind {
    Implicit,
    Builtin(BuiltinType),
    Named(Spanned<Name>),
    Struct(Vec<NodeId>),
    PackedArray(Box<TypeKind>, NodeId, NodeId),
    Scope(NodeId, Spanned<Name>),
    Enum(Vec<(Spanned<Name>, NodeId)>, Option<NodeId>),
    RefExpr(NodeId),
    RefType(NodeId),
}

The different forms a type can take.

Variants

Implicit

An implicit type.

Builtin(BuiltinType)

A builtin type.

Tuple Fields of Builtin

0: BuiltinType

Named(Spanned<Name>)

A named type.

Tuple Fields of Named

0: Spanned<Name>

Struct(Vec<NodeId>)

A struct or union type.

Tuple Fields of Struct

0: Vec<NodeId>

PackedArray(Box<TypeKind>, NodeId, NodeId)

A packed array such as bit [31:0].

Represented as (inner_type, range_lhs, range_rhs).

Tuple Fields of PackedArray

0: Box<TypeKind>1: NodeId2: NodeId

Scope(NodeId, Spanned<Name>)

A scope access such as foo::bar.

Tuple Fields of Scope

0: NodeId1: Spanned<Name>

Enum(Vec<(Spanned<Name>, NodeId)>, Option<NodeId>)

An enum type.

Each element in the vector refers to a EnumVariant. The optional field indicates the representation type.

Tuple Fields of Enum

0: Vec<(Spanned<Name>, NodeId)>1: Option<NodeId>

RefExpr(NodeId)

A type reference on an expression, such as type(x).

Tuple Fields of RefExpr

0: NodeId

RefType(NodeId)

A type reference on a type, such as type(int).

Tuple Fields of RefType

0: NodeId

Trait Implementations

impl Clone for TypeKind

fn clone(&self) -> TypeKind

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TypeKind

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

Formats the value using the given formatter.

impl HasDesc for TypeKind

fn desc(&self) -> &'static str

Obtain a human-readable descriptive name for this node.

fn desc_full(&self) -> String

Obtain a human-readable description for this node, possibly containing the node’s name.

impl PartialEq<TypeKind> for TypeKind

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

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

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

This method tests for !=.

impl Eq for TypeKind

impl StructuralEq for TypeKind

impl StructuralPartialEq for TypeKind