Struct moore_svlog::ty::PackedType

pub struct PackedType<'a> {
    pub core: PackedCore<'a>,
    pub sign: Sign,
    pub sign_explicit: bool,
    pub dims: Vec<PackedDim>,
    // some fields omitted
}

A packed type.

Fields

core: PackedCore<'a>

The core packed type.

sign: Sign

The type sign.

sign_explicit: bool

Whether the sign was explicit in the source code.

dims: Vec<PackedDim>

The packed dimensions.

Implementations

impl<'a> PackedType<'a>

pub fn new(core: impl Into<PackedCore<'a>>) -> Self

Create a new type with default sign and no packed dimensions.

This creates the type on the stack. In general you will want to use the make_* functions to create a type that is interned into a context.

pub fn with_dims(core: impl Into<PackedCore<'a>>, dims: Vec<PackedDim>) -> Self

Create a new type with default sign and packed dimensions.

This creates the type on the stack. In general you will want to use the make_* functions to create a type that is interned into a context.

pub fn with_sign(
    core: impl Into<PackedCore<'a>>,
    sign: Sign,
    sign_explicit: bool
) -> Self

Create a new type with no packed dimensions.

This creates the type on the stack. In general you will want to use the make_* functions to create a type that is interned into a context.

pub fn with_sign_and_dims(
    core: impl Into<PackedCore<'a>>,
    sign: Sign,
    sign_explicit: bool,
    dims: Vec<PackedDim>
) -> Self

Create a new type with packed dimensions.

This creates the type on the stack. In general you will want to use the make_* functions to create a type that is interned into a context.

pub fn with_simple_bit_vector(sbv: SbvType) -> Self

Create a new type from an SBVT.

pub fn make(
    cx: &impl TypeContext<'a>,
    core: impl Into<PackedCore<'a>>
) -> &'a Self

Create an interned type with default sign and no packed dimensions.

pub fn make_dims(
    cx: &impl TypeContext<'a>,
    core: impl Into<PackedCore<'a>>,
    dims: Vec<PackedDim>
) -> &'a Self

Create an interned type with default sign and packed dimensions.

pub fn make_sign(
    cx: &impl TypeContext<'a>,
    core: impl Into<PackedCore<'a>>,
    sign: Sign,
    sign_explicit: bool
) -> &'a Self

Create an interned type with no packed dimensions.

pub fn make_sign_and_dims(
    cx: &impl TypeContext<'a>,
    core: impl Into<PackedCore<'a>>,
    sign: Sign,
    sign_explicit: bool,
    dims: Vec<PackedDim>
) -> &'a Self

Create an interned type with packed dimensions.

pub fn make_simple_bit_vector(
    cx: &impl TypeContext<'a>,
    sbv: SbvType
) -> &'a Self

Create an interned type from an SBVT.

pub fn make_error() -> &'a Self

Create a tombstone.

pub fn make_void() -> &'a Self

Create a void type.

pub fn make_logic() -> &'a Self

Create a logic type.

pub fn make_time() -> &'a Self

Create a time type.

pub fn intern(self, cx: &impl TypeContext<'a>) -> &'a Self

Internalize this type in a context and resolve it.

pub fn to_unpacked(&'a self, cx: &impl TypeContext<'a>) -> &'a UnpackedType<'a>

Wrap this packed type up in an unpacked type.

pub fn resolve(&self) -> &Self

Resolve one level of name or type reference indirection.

For example, given typedef int foo; typedef foo bar;, resolves bar to foo.

pub fn resolve_full(&self) -> &Self

Resolve all name or type reference indirections recursively.

For example, given typedef int foo; typedef foo bar;, resolves bar to int.

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 equal to another one.

Types which coalesce to iN in LLHD are checked for equality of their SBVT.

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

Check if this type is strictly equal to another one.

pub fn domain(&self) -> Domain

Get the domain for this type.

pub fn sign(&self) -> Sign

Get the sign for this type.

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

Compute the size of this type in bits.

Returns None if one of the type’s dimensions is [].

pub fn is_simple_bit_vector(&self) -> bool

Check if this type is trivially a SBVT.

pub fn is_integer_vec(&self) -> bool

Check if this type is a simple integer vector type, like logic [x:y] or logic.

pub fn is_integer_atom(&self) -> bool

Check if this type is an integer atom type, like int.

pub fn is_single_bit(&self) -> bool

Check if this type is a single bit type, like bit.

pub fn is_time(&self) -> bool

Check if this type is the time type.

pub fn coalesces_to_llhd_scalar(&self) -> bool

Check if this type will coalesce to a scalar type in LLHD, like i42.

pub fn get_simple_bit_vector(&self) -> Option<SbvType>

Convert this type into an SBVT if possible.

pub fn simple_bit_vector(&self, cx: &impl DiagEmitter, span: Span) -> SbvType

Convert this type into an SBVT, or report a bug with the given span.

pub fn pop_dim(&self, cx: &impl TypeContext<'a>) -> Option<&'a Self>

Pop the outermost dimension off the type.

For example, maps bit [3:0][7:0] to bit [7:0].

pub fn replace_dim(&self, cx: &impl TypeContext<'a>, dim: PackedDim) -> &'a Self

Replace the outermost dimension of the type.

Panics if the type has no dimensions.

pub fn outermost_dim(&self) -> Option<PackedDim>

Get the outermost dimension of the type.

For example, yields the [3:0] in bit [3:0][7:0].

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.

Trait Implementations

impl<'a> Clone for PackedType<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PackedType<'_>

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

Formats the value using the given formatter.

impl Display for PackedType<'_>

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 Hash for PackedType<'_>

fn hash<H: Hasher>(&self, h: &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 PartialEq<PackedType<'_>> for PackedType<'_>

fn eq(&self, other: &Self) -> 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 !=.

impl Eq for PackedType<'_>