Enum moore_svlog::hir::ExprKind

pub enum ExprKind<'a> {
    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<'a>),
    Ternary(NodeId, NodeId, NodeId),
    Scope(NodeId, Spanned<Name>),
    PositionalPattern(Vec<NodeId>),
    NamedPattern(Vec<(PatternMapping, NodeId)>),
    RepeatPattern(NodeId, Vec<NodeId>),
    Concat(Option<NodeId>, Vec<NodeId>),
    Cast(NodeId, NodeId),
    CastSign(Spanned<Sign>, NodeId),
    CastSize(NodeId, NodeId),
    Inside(NodeId, Vec<Spanned<InsideRange>>),
    FunctionCall(NodeId, Vec<CallArg>),
    Assign {
        op: AssignOp,
        lhs: &'a Expr<'a>,
        rhs: &'a Expr<'a>,
    },
}

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.

Tuple Fields of UnsizedConst

0: char

TimeConst(BigRational)

A time constant literal.

Tuple Fields of TimeConst

0: BigRational

StringConst(Spanned<Name>)

A string constant literal.

Tuple Fields of StringConst

0: Spanned<Name>

Ident(Spanned<Name>)

An identifier.

Tuple Fields of Ident

0: Spanned<Name>

Unary(UnaryOp, NodeId)

A unary operator.

Tuple Fields of Unary

0: UnaryOp1: NodeId

Binary(BinaryOp, NodeId, NodeId)

A binary operator.

Tuple Fields of Binary

0: BinaryOp1: NodeId2: NodeId

Field(NodeId, Spanned<Name>)

A field access such as a.b.

Tuple Fields of Field

0: NodeId1: Spanned<Name>

Index(NodeId, IndexMode)

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

Tuple Fields of Index

0: NodeId1: IndexMode

Builtin(BuiltinCall<'a>)

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

Tuple Fields of Builtin

0: BuiltinCall<'a>

Ternary(NodeId, NodeId, NodeId)

A ternary expression such as a ? b : c.

Tuple Fields of Ternary

0: NodeId1: NodeId2: NodeId

Scope(NodeId, Spanned<Name>)

A scope expression such as foo::bar.

Tuple Fields of Scope

0: NodeId1: Spanned<Name>

PositionalPattern(Vec<NodeId>)

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

Tuple Fields of PositionalPattern

0: Vec<NodeId>

NamedPattern(Vec<(PatternMapping, NodeId)>)

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

Tuple Fields of NamedPattern

0: Vec<(PatternMapping, NodeId)>

RepeatPattern(NodeId, Vec<NodeId>)

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

Tuple Fields of RepeatPattern

0: NodeId1: Vec<NodeId>

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

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

Tuple Fields of Concat

0: Option<NodeId>1: Vec<NodeId>

Cast(NodeId, NodeId)

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

Tuple Fields of Cast

0: NodeId1: NodeId

CastSign(Spanned<Sign>, NodeId)

A sign cast such as unsigned'(foo).

Tuple Fields of CastSign

0: Spanned<Sign>1: NodeId

CastSize(NodeId, NodeId)

A size cast (size_expr, expr) such as 42'(foo).

Tuple Fields of CastSize

0: NodeId1: NodeId

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

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

Tuple Fields of Inside

0: NodeId1: Vec<Spanned<InsideRange>>

FunctionCall(NodeId, Vec<CallArg>)

A function call such as foo(a, b, c).

Tuple Fields of FunctionCall

0: NodeId1: Vec<CallArg>

Assign

An assignment.

Fields of Assign

op: AssignOplhs: &'a Expr<'a>rhs: &'a Expr<'a>

Trait Implementations

impl<'a> Clone for ExprKind<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for ExprKind<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq<ExprKind<'a>> for ExprKind<'a>

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

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

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

This method tests for !=.

impl<'a> Eq for ExprKind<'a>

impl<'a> StructuralEq for ExprKind<'a>

impl<'a> StructuralPartialEq for ExprKind<'a>