Enum moore_svlog::ty::TypeKind

pub enum TypeKind<'t> {
    Error,
    Void,
    Time,
    Bit(Domain),
    Int(usize, Domain),
    Named(Spanned<Name>, NodeId, Type<'t>),
    Struct(NodeId),
    PackedArray(usize, Type<'t>),
    BitScalar {
        domain: Domain,
        sign: Sign,
    },
    BitVector {
        domain: Domain,
        sign: Sign,
        range: Range,
        dubbed: bool,
    },
}

Type data.

Variants

Error

An error occurred during type computation.

Void

The void type.

Time

The time type.

Bit(Domain)

A single bit type.

Int(usize, Domain)

An integer type.

Named(Spanned<Name>, NodeId, Type<'t>)

A named type.

The first field represents how the type was originally named by the user. The second field represents the binding of the resolved name. The third field represents the actual type.

Struct(NodeId)

A struct type.

PackedArray(usize, Type<'t>)

A packed array type.

BitScalar

A single bit type.

Fields of BitScalar

domain: Domainsign: Sign

BitVector

A simple bit vector type (SBVT).

The innermost dimension of a multi-dimensional bit vector type is always represented as a SBVT.

Fields of BitVector

domain: Domainsign: Signrange: Rangedubbed: bool

Implementations

impl<'t> TypeKind<'t>

pub fn is_error(&self) -> bool

Check if this is the error type.

pub fn is_void(&self) -> bool

Check if this is the void type.

pub fn is_struct(&self) -> bool

Check if this is a struct type.

pub fn is_array(&self) -> bool

Check if this is an array type.

pub fn get_struct_def(&self) -> Option<NodeId>

Get the definition of a struct.

pub fn get_array_element(&self) -> Option<Type<'t>>

Get the element type of an array.

pub fn get_array_length(&self) -> Option<usize>

Get the length of an array.

pub fn width(&self) -> usize

Get the width of the type.

Panics if the type is not an integer.

pub fn is_bit_vector(&self) -> bool

Check if this is a bit vector type.

pub fn is_bit_scalar(&self) -> bool

Check if this is a bit scalar type.

pub fn is_dubbed(&self) -> bool

Check if this type uses a predefined type alias as name.

pub fn is_bool(&self) -> bool

Check if this type is a valid boolean.

pub fn resolve_name(&self) -> &Self

Remove all typedefs and reveal the concrete fundamental type.

pub fn get_value_domain(&self) -> Option<Domain>

Return the domain of the type, if it has one.

pub fn get_sign(&self) -> Option<Sign>

Return the sign of the type, if it has one.

pub fn get_range(&self) -> Option<Range>

Return the range of the type, if it has one.

pub fn is_unsigned(&self) -> bool

Check whether the type is unsigned.

Returns false for types which have no sign.

pub fn is_signed(&self) -> bool

Check whether the type is signed.

Returns false for types which have no sign.

pub fn change_value_domain<'gcx>(
    &'gcx self,
    cx: &impl Context<'gcx>,
    domain: Domain
) -> Type<'gcx>

Change the value domain of a type.

pub fn change_sign<'gcx>(
    &'gcx self,
    cx: &impl Context<'gcx>,
    sign: Sign
) -> Type<'gcx>

Change the sign of a simple bit type.

pub fn change_range<'gcx>(
    &'gcx self,
    cx: &impl Context<'gcx>,
    range: Range
) -> Type<'gcx>

Change the range of a simple bit type.

pub fn has_simple_bit_vector(&self) -> bool

Check if this type has a simple bit vector equivalent.

pub fn is_simple_bit_vector(&self) -> bool

Check if this type is a simple bit vector type.

pub fn get_simple_bit_vector<'gcx>(
    &'gcx self,
    cx: &impl Context<'gcx>,
    env: ParamEnv,
    force_vector: bool
) -> Option<Type<'gcx>>

Try to convert to an equivalent simple bit vector type.

All integral data types have an equivalent simple bit vector type. These include the following:

• all basic integers
• packed arrays
• packed structures
• packed unions
• enums
• time (excluded in this implementation)

If force_vector is true, the returned type has range [0:0] if it would otherwise be a single bit.

pub fn try_bit_size<'gcx>(
    &'gcx self,
    cx: &impl Context<'gcx>,
    env: ParamEnv
) -> Result<usize>

Compute the size of the type in bits.

Trait Implementations

impl<'t> Debug for TypeKind<'t>

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

Formats the value using the given formatter.

impl<'t> Display for TypeKind<'t>

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

Formats the value using the given formatter.

impl<'t> Eq for TypeKind<'t>

impl<'a> From<&'a TypeKind<'a>> for TypeContext<'a>

fn from(ty: Type<'a>) -> Self

Performs the conversion.

impl<'a> From<&'a TypeKind<'a>> for CastType<'a>

fn from(ty: Type<'a>) -> CastType<'a>

Performs the conversion.

impl<'t> Hash for TypeKind<'t>

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<'t> PartialEq<TypeKind<'t>> for TypeKind<'t>

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

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

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

This method tests for !=.

impl<'t> StructuralEq for TypeKind<'t>

impl<'t> StructuralPartialEq for TypeKind<'t>