Enum moore_svlog::ty::UnpackedCore

pub enum UnpackedCore<'a> {
    Error,
    Packed(&'a PackedType<'a>),
    Real(RealType),
    Struct(StructType<'a>),
    String,
    Chandle,
    Event,
    Named {
        name: Spanned<Name>,
        ty: &'a UnpackedType<'a>,
    },
    Ref {
        span: Span,
        ty: &'a UnpackedType<'a>,
    },
    Module(ModuleType<'a>),
    Interface(InterfaceType<'a>),
}

A core unpacked type.

Variants

Error

An error occurred during type computation.

Packed(&'a PackedType<'a>)

A packed type.

Tuple Fields of Packed

0: &'a PackedType<'a>

Real(RealType)

A real type.

Tuple Fields of Real

0: RealType

Struct(StructType<'a>)

A unpacked struct.

Tuple Fields of Struct

0: StructType<'a>

String

A string.

Chandle

A chandle.

Event

An event.

Named

A named type.

Fields of Named

name: Spanned<Name>

How the user originally called the type.

ty: &'a UnpackedType<'a>

The type this name expands to.

Ref

A type reference.

Fields of Ref

span: Span

Location of the type(...) in the source file.

ty: &'a UnpackedType<'a>

The type that this reference expands to.

Module(ModuleType<'a>)

A module instance.

Tuple Fields of Module

0: ModuleType<'a>

Interface(InterfaceType<'a>)

An interface instance.

Tuple Fields of Interface

0: InterfaceType<'a>

Implementations

impl<'a> UnpackedCore<'a>

pub fn is_error(&self) -> bool

Check if this is a tombstone.

pub fn is_identical(&self, other: &Self) -> bool

Check if this type is identical to another one.

pub fn is_strictly_identical(&self, other: &Self) -> bool

Check if this type is strictly identical to another one.

pub fn get_packed(&self) -> Option<&'a PackedType<'a>>

If this type is strictly a packed type, convert it.

pub fn get_struct(&self) -> Option<&StructType<'a>>

Get the underlying struct, or None if the type is no struct.

pub fn get_enum(&self) -> Option<&EnumType<'a>>

Get the underlying enum, or None if the type is no enum.

pub fn get_module(&self) -> Option<&ModuleType<'a>>

Get the underlying module, or None if the type is not a module.

pub fn get_interface(&self) -> Option<&InterfaceType<'a>>

Get the underlying interface, or None if the type is not a interface.

Trait Implementations

impl<'a> Clone for UnpackedCore<'a>

fn clone(&self) -> UnpackedCore<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for UnpackedCore<'a>

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

Formats the value using the given formatter.

impl Display for UnpackedCore<'_>

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

Formats the value using the given formatter.

impl<'a> From<&'a PackedType<'a>> for UnpackedCore<'a>

fn from(inner: &'a PackedType<'a>) -> Self

Performs the conversion.

impl<'a> From<InterfaceType<'a>> for UnpackedCore<'a>

fn from(inner: InterfaceType<'a>) -> Self

Performs the conversion.

impl<'a> From<ModuleType<'a>> for UnpackedCore<'a>

fn from(inner: ModuleType<'a>) -> Self

Performs the conversion.

impl<'a> From<RealType> for UnpackedCore<'a>

fn from(inner: RealType) -> Self

Performs the conversion.

impl<'a> From<StructType<'a>> for UnpackedCore<'a>

fn from(inner: StructType<'a>) -> Self

Performs the conversion.

impl<'a> Hash for UnpackedCore<'a>

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, 

Feeds a slice of this type into the given Hasher.

impl<'a> PartialEq<UnpackedCore<'a>> for UnpackedCore<'a>

fn eq(&self, other: &UnpackedCore<'a>) -> bool

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

fn ne(&self, other: &UnpackedCore<'a>) -> bool

This method tests for !=.

impl<'a> Eq for UnpackedCore<'a>

impl<'a> StructuralEq for UnpackedCore<'a>

impl<'a> StructuralPartialEq for UnpackedCore<'a>