Enum Statement 

pub enum Statement {
    Let(Let),
    Expr(Expr),
    Enforce(ScalarExpr),
    EnforceIf(ScalarExpr, ScalarExpr),
    EnforceAll(ListComprehension),
    BusEnforce(ListComprehension),
}

Statements are top-level expressions in the body of evaluators, or in the boundary_constraints or integrity_constraints sections. These expressions are called statements because they do not evaluate to a value, instead they are evaluated sequentially.

Variants

Let(Let)

Binds an identifier to an expression in the following statements, e.g. let x = y * 2

A let statement contains all following statements in its containing block as the “body” of the let. In other words, it imposes a new lexical scope within the block in which the variable it binds is visible. Because of this, a let statement will always be the last statement in a block when one is present.

Furthermore, the parser guarantees that a let statement always has a body, which by induction guarantees that a let statement will always have a constraint in its body at some point, otherwise parsing would fail. This guarantee holds during all analyses and transformations.

Expr(Expr)

Represents a value expression in the tail position of a block

This is only used in pure function contexts, and during certain transformations. It is not valid in any position but the last statement of a block, and that block must be in an expression context (i.e. pure function body, let-bound expression that expands during inlining to a block of statements that are used to build up a value).

Enforce(ScalarExpr)

Declares a constraint to be enforced on a single value.

This variant accepts a ScalarExpr for simplicity in the parser, but is expected to always be either a call to an evaluator function, or a binary expression of the form lhs = rhs, i.e. an equality. This is validated by the semantic analyzer.

EnforceIf(ScalarExpr, ScalarExpr)

Declares a constraint to be conditionally enforced.

This has all the same semantics as Enforce, except it has a condition expression which determines if the constraint will be enforced.

This variant is only present in the AST after inlining is performed, even though the parser could produce it directly from the parse tree. This is because this variant is equivalent to a comprehension constraint with a single element, so we transform all syntax corresponding to EnforceIf into EnforceAll form so we can reuse all of the analyses/optimizations/transformations for both. However, when lowering to the IR, we perform inlining/unrolling of comprehensions, and at that time we need EnforceIf in order to represent unrolled constraints which have a selector that is only resolvable at runtime.

EnforceAll(ListComprehension)

Declares a constraint to be enforced over a vector of values produced by a comprehension.

Just like Enforce, except the constraint is contained in the body of a list comprehension, and must be enforced on every value produced by that comprehension.

BusEnforce(ListComprehension)

Declares a bus related constraint

Implementations

impl Statement

pub fn has_constraints(&self) -> bool

Checks this statement to see if it contains any constraints

This is primarily necessary because let statements have a body, which is also composed of statements, and so may be nested arbitrarily deep, containing one or more constraints in its body.

pub fn display(&self, indent: usize) -> DisplayStatement<'_>

Trait Implementations

impl Clone for Statement

fn clone(&self) -> Statement

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Statement

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

Formats the value using the given formatter.

impl From<Expr> for Statement

fn from(expr: Expr) -> Self

Converts to this type from the input type.

impl PartialEq for Statement

fn eq(&self, other: &Statement) -> 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 Spanned for Statement

fn span(&self) -> SourceSpan

impl TryFrom<ScalarExpr> for Statement

type Error = ()

The type returned in the event of a conversion error.

fn try_from(expr: ScalarExpr) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Statement> for Expr

type Error = InvalidExprError

The type returned in the event of a conversion error.

fn try_from(stmt: Statement) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Statement> for ScalarExpr

type Error = InvalidExprError

The type returned in the event of a conversion error.

fn try_from(stmt: Statement) -> Result<Self, Self::Error>

Performs the conversion.

impl Eq for Statement

impl StructuralPartialEq for Statement