Enum Expression

pub enum Expression {
    InfixOp {
        meta: Meta,
        lhe: Box<Expression>,
        infix_op: ExpressionInfixOpcode,
        rhe: Box<Expression>,
    },
    PrefixOp {
        meta: Meta,
        prefix_op: ExpressionPrefixOpcode,
        rhe: Box<Expression>,
    },
    SwitchOp {
        meta: Meta,
        cond: Box<Expression>,
        if_true: Box<Expression>,
        if_false: Box<Expression>,
    },
    Variable {
        meta: Meta,
        name: VariableName,
    },
    Number(Meta, BigInt),
    Call {
        meta: Meta,
        name: String,
        args: Vec<Expression>,
    },
    InlineArray {
        meta: Meta,
        values: Vec<Expression>,
    },
    Access {
        meta: Meta,
        var: VariableName,
        access: Vec<AccessType>,
    },
    Update {
        meta: Meta,
        var: VariableName,
        access: Vec<AccessType>,
        rhe: Box<Expression>,
    },
    Phi {
        meta: Meta,
        args: Vec<VariableName>,
    },
}

Variants

InfixOp

An infix operation of the form lhe * rhe.

Fields

meta: Meta

lhe: Box<Expression>

infix_op: ExpressionInfixOpcode

rhe: Box<Expression>

PrefixOp

A prefix operation of the form * rhe.

Fields

meta: Meta

prefix_op: ExpressionPrefixOpcode

rhe: Box<Expression>

SwitchOp

An inline switch operation (or inline if-then-else) of the form cond? if_true: if_false.

Fields

meta: Meta

cond: Box<Expression>

if_true: Box<Expression>

if_false: Box<Expression>

Variable

A local variable, signal, or component.

Fields

meta: Meta

name: VariableName

Number(Meta, BigInt)

A constant field element.

Call

A function call node.

Fields

meta: Meta

name: String

args: Vec<Expression>

InlineArray

An inline array on the form [value, ...].

Fields

meta: Meta

values: Vec<Expression>

Access

An Access node represents an array access of the form a[i]...[k].

Fields

meta: Meta

var: VariableName

access: Vec<AccessType>

Update

Updates of the form var[i]...[k] = rhe lift to IR statements of the form var = update(var, (i, ..., k), rhe). This is needed when we convert the CFG to SSA. Since arrays are versioned atomically, we need to track which version of the array that is updated to obtain the new version. (This is needed to track variable use, dead assignments, and data flow.)

Note: The type metadata in meta tracks the type of the variable var.

Fields

meta: Meta

var: VariableName

access: Vec<AccessType>

rhe: Box<Expression>

Phi

An SSA phi-expression.

Fields

meta: Meta

args: Vec<VariableName>

Implementations

impl Expression

pub fn meta(&self) -> &Meta

pub fn meta_mut(&mut self) -> &mut Meta

Trait Implementations

impl Clone for Expression

fn clone(&self) -> Expression

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expression

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

Formats the value using the given formatter.

impl DegreeMeta for Expression

fn propagate_degrees(&mut self, env: &DegreeEnvironment) -> bool

Compute expression degrees for this node and child nodes. Returns true if the node (or a child node) is updated.

fn degree(&self) -> Option<&DegreeRange>

Returns an inclusive range the degree of the node may take.

impl Display for Expression

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

Formats the value using the given formatter.

impl Hash for Expression

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Expression

Syntactic equality for expressions.

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl TypeMeta for Expression

fn propagate_types(&mut self, vars: &Declarations)

Propagate variable types to variable child nodes.

fn is_local(&self) -> bool

Returns true if the node is a local variable.

fn is_signal(&self) -> bool

Returns true if the node is a signal.

fn is_component(&self) -> bool

Returns true if the node is a component.

fn variable_type(&self) -> Option<&VariableType>

For declared variables, this returns the type. For undeclared variables and other expression nodes this returns None.

impl ValueMeta for Expression

fn propagate_values(&mut self, env: &mut ValueEnvironment) -> bool

Propagate variable values defined by the environment to each sub-node. The method returns true if the node (or a sub-node) was updated.

fn is_constant(&self) -> bool

Returns true if the node reduces to a constant value.

fn is_boolean(&self) -> bool

Returns true if the node reduces to a boolean value.

fn is_field_element(&self) -> bool

Returns true if the node reduces to a field element.

fn value(&self) -> Option<&ValueReduction>

Returns the value if the node reduces to a constant, and None otherwise.

impl VariableMeta for Expression

fn cache_variable_use(&mut self)

Compute variables read/written by the node. Must be called before either of the getters are called. To avoid interior mutability this needs to be called again whenever the node is mutated in a way that may invalidate the cached variable use.

fn locals_read(&self) -> &VariableUses

Get the set of variables read by the IR node.

fn locals_written(&self) -> &VariableUses

Get the set of variables written by the IR node.

fn signals_read(&self) -> &VariableUses

Get the set of signals read by the IR node. Note that this does not include signals belonging to sub-components.

fn signals_written(&self) -> &VariableUses

Get the set of signals written by the IR node. Note that this does not include signals belonging to sub-components.

fn components_read(&self) -> &VariableUses

Get the set of components read by the IR node. Note that a component read is typically a signal read for a signal exported by the component.

fn components_written(&self) -> &VariableUses

Get the set of components written by the IR node. Note that a component write may either be a component initialization, or a signal write for a signal exported by the component.

fn variables_read<'a>( &'a self, ) -> Box<dyn Iterator<Item = &'a VariableUse> + 'a>

Get the set of variables read by the IR node. Note that this is simply the union of all locals, signals, and components read by the node.

fn variables_written<'a>( &'a self, ) -> Box<dyn Iterator<Item = &'a VariableUse> + 'a>

Get the set of variables written by the IR node. Note that this is simply the union of all locals, signals, and components written.

fn variables_used<'a>( &'a self, ) -> Box<dyn Iterator<Item = &'a VariableUse> + 'a>

Get the set of variables either read or written by the IR node.

impl Eq for Expression