Enum moore_svlog::hir::ExprKind

pub enum ExprKind {
    IntConst {
        width: usize,
        value: BigInt,
        signed: bool,
        special_bits: BitVec,
        x_bits: BitVec,
    },
    UnsizedConst(char),
    TimeConst(BigRational),
    StringConst(Spanned<Name>),
    Ident(Spanned<Name>),
    Unary(UnaryOp, NodeId),
    Binary(BinaryOp, NodeId, NodeId),
    Field(NodeId, Spanned<Name>),
    Index(NodeId, IndexMode),
    Builtin(BuiltinCall),
    Ternary(NodeId, NodeId, NodeId),
    Scope(NodeId, Spanned<Name>),
    PositionalPattern(Vec<NodeId>),
    NamedPattern(Vec<(PatternMapping, NodeId)>),
    RepeatPattern(NodeId, Vec<NodeId>),
    EmptyPattern,
    Concat(Option<NodeId>, Vec<NodeId>),
    Cast(NodeId, NodeId),
    Inside(NodeId, Vec<Spanned<InsideRange>>),
}

The different forms an expression can take.

Variants

IntConst

An integer constant literal such as 42 or 'd42 or 32'd42.

The special_bits mask keeps track of which bits in the number are x or z. The x_bits mask tracks which of these special bits are x.

Fields of IntConst

width: usizevalue: BigIntsigned: boolspecial_bits: BitVecx_bits: BitVec

UnsizedConst(char)

An unsized and unbased constant literal such as '0.

TimeConst(BigRational)

A time constant literal.

StringConst(Spanned<Name>)

A string constant literal.

Ident(Spanned<Name>)

An identifier.

Unary(UnaryOp, NodeId)

A unary operator.

Binary(BinaryOp, NodeId, NodeId)

A binary operator.

Field(NodeId, Spanned<Name>)

A field access such as a.b.

Index(NodeId, IndexMode)

An index access such as a[b] or a[b:c].

Builtin(BuiltinCall)

A builtin function call such as $clog2(x).

Ternary(NodeId, NodeId, NodeId)

A ternary expression such as a ? b : c.

Scope(NodeId, Spanned<Name>)

A scope expression such as foo::bar.

PositionalPattern(Vec<NodeId>)

A positional pattern such as '{a, b, c}.

NamedPattern(Vec<(PatternMapping, NodeId)>)

A named pattern such as '{logic: a, foo: b, 31: c, default: d}.

RepeatPattern(NodeId, Vec<NodeId>)

A repeat pattern such as '{32{a, b, c}}.

EmptyPattern

The empty pattern '{}.

Concat(Option<NodeId>, Vec<NodeId>)

A concatenation such as {a,b} or {4{a,b}}.

Cast(NodeId, NodeId)

A cast (ty, expr) such as foo'(bar).

Inside(NodeId, Vec<Spanned<InsideRange>>)

An inside expression such as a inside {b, c}.

Trait Implementations

impl Clone for ExprKind

fn clone(&self) -> ExprKind

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ExprKind

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

Formats the value using the given formatter.

impl Eq for ExprKind

impl PartialEq<ExprKind> for ExprKind

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

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

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

This method tests for !=.

impl StructuralEq for ExprKind

impl StructuralPartialEq for ExprKind