Struct leo_passes::static_single_assignment::static_single_assigner::StaticSingleAssigner

pub struct StaticSingleAssigner<'a> {
    pub(crate) node_builder: &'a NodeBuilder,
    pub(crate) symbol_table: &'a SymbolTable,
    pub(crate) type_table: &'a TypeTable,
    pub(crate) rename_table: RenameTable,
    pub(crate) is_lhs: bool,
    pub(crate) assigner: &'a Assigner,
    pub(crate) program: Option<Symbol>,
}

Fields

node_builder: &'a NodeBuilder

A counter used to generate unique node IDs.

symbol_table: &'a SymbolTable

The SymbolTable of the program.

type_table: &'a TypeTable

A mapping from node IDs to their types.

rename_table: RenameTable

The RenameTable for the current basic block in the AST

is_lhs: bool

A flag to determine whether or not the traversal is on the left-hand side of a definition or an assignment.

assigner: &'a Assigner

A struct used to construct (unique) assignment statements.

program: Option<Symbol>

The main program name.

Implementations

impl<'a> StaticSingleAssigner<'a>

pub(crate) fn new( node_builder: &'a NodeBuilder, symbol_table: &'a SymbolTable, type_table: &'a TypeTable, assigner: &'a Assigner, ) -> Self

Initializes a new StaticSingleAssigner with an empty RenameTable.

pub(crate) fn push(&mut self)

Pushes a new scope, setting the current scope as the new scope’s parent.

pub(crate) fn pop(&mut self) -> RenameTable

If the RenameTable has a parent, then self.rename_table is set to the parent, otherwise it is set to a default RenameTable.

pub(crate) fn simple_assign_statement( &mut self, identifier: Identifier, rhs: Expression, ) -> Statement

pub(crate) fn unique_simple_assign_statement( &mut self, expr: Expression, ) -> (Identifier, Statement)

Constructs a simple assign statement for expr with a unique name. For example, expr is transformed into $var$0 = expr;. The lhs is guaranteed to be unique with respect to the Assigner.

Trait Implementations

impl ExpressionConsumer for StaticSingleAssigner<'_>

fn consume_access(&mut self, input: AccessExpression) -> Self::Output

Consumes an access expression, accumulating any statements that are generated.

fn consume_array(&mut self, input: ArrayExpression) -> Self::Output

Consumes an array expression, accumulating any statements that are generated.

fn consume_binary(&mut self, input: BinaryExpression) -> Self::Output

Consumes a binary expression, accumulating any statements that are generated.

fn consume_call(&mut self, input: CallExpression) -> Self::Output

Consumes a call expression without visiting the function name, accumulating any statements that are generated.

fn consume_cast(&mut self, input: CastExpression) -> Self::Output

Consumes a cast expression, accumulating any statements that are generated.

fn consume_struct_init(&mut self, input: StructExpression) -> Self::Output

Consumes a struct initialization expression with renamed variables, accumulating any statements that are generated.

fn consume_identifier(&mut self, identifier: Identifier) -> Self::Output

Produces a new Identifier with a unique name.

fn consume_literal(&mut self, input: Literal) -> Self::Output

Consumes and returns the literal without making any modifications.

fn consume_locator(&mut self, input: LocatorExpression) -> Self::Output

Consumes and returns the locator expression without making any modifciations

fn consume_ternary(&mut self, input: TernaryExpression) -> Self::Output

Consumes a ternary expression, accumulating any statements that are generated.

fn consume_tuple(&mut self, input: TupleExpression) -> Self::Output

Consumes a tuple expression, accumulating any statements that are generated

fn consume_unary(&mut self, input: UnaryExpression) -> Self::Output

Consumes a unary expression, accumulating any statements that are generated.

type Output = (Expression, Vec<Statement>)

fn consume_unit(&mut self, input: UnitExpression) -> Self::Output

fn consume_expression(&mut self, input: Expression) -> Self::Output

fn consume_err(&mut self, _input: ErrExpression) -> Self::Output

impl FunctionConsumer for StaticSingleAssigner<'_>

fn consume_function(&mut self, function: Function) -> Self::Output

Reconstructs the Functions in the Program, while allocating the appropriate RenameTables.

type Output = Function

impl<'a> Pass for StaticSingleAssigner<'a>

type Input = (Ast, &'a NodeBuilder, &'a Assigner, &'a SymbolTable, &'a TypeTable)

type Output = Result<Ast, LeoError>

fn do_pass( (ast, node_builder, assigner, symbol_table, type_table): Self::Input, ) -> Self::Output

Runs the compiler pass.

impl ProgramConsumer for StaticSingleAssigner<'_>

type Output = Program

fn consume_program(&mut self, input: Program) -> Self::Output

impl ProgramScopeConsumer for StaticSingleAssigner<'_>

type Output = ProgramScope

fn consume_program_scope(&mut self, input: ProgramScope) -> Self::Output

impl StatementConsumer for StaticSingleAssigner<'_>

fn consume_assert(&mut self, input: AssertStatement) -> Self::Output

Consumes the expressions in an AssertStatement, returning the list of simplified statements.

fn consume_assign(&mut self, assign: AssignStatement) -> Self::Output

Consume all AssignStatements, renaming as necessary.

fn consume_block(&mut self, block: Block) -> Self::Output

Consumes a Block, flattening its constituent ConditionalStatements.

fn consume_conditional( &mut self, conditional: ConditionalStatement, ) -> Self::Output

Consumes a ConditionalStatement, producing phi functions (assign statements) for variables written in the then-block and otherwise-block. For more information on phi functions, see https://en.wikipedia.org/wiki/Static_single_assignment_form. Furthermore a new AssignStatement is introduced for non-trivial expressions in the condition of ConditionalStatements. For example,

• if x > 0 { x = x + 1 } becomes let $cond$0 = x > 0; if $cond$0 { x = x + 1; }
• if true { x = x + 1 } remains the same.
• if b { x = x + 1 } remains the same.

fn consume_console(&mut self, _: ConsoleStatement) -> Self::Output

Parsing guarantees that console statements are not present in the program.

fn consume_definition( &mut self, definition: DefinitionStatement, ) -> Self::Output

Consumes the DefinitionStatement into an AssignStatement, renaming the left-hand-side as appropriate.

fn consume_expression_statement( &mut self, input: ExpressionStatement, ) -> Self::Output

Consumes the expressions associated with ExpressionStatement, returning the simplified ExpressionStatement.

fn consume_return(&mut self, input: ReturnStatement) -> Self::Output

Reconstructs the expression associated with the return statement, returning a simplified ReturnStatement. Note that type checking guarantees that there is at most one ReturnStatement in a block.

type Output = Vec<Statement>

fn consume_const(&mut self, _: ConstDeclaration) -> Self::Output

fn consume_iteration(&mut self, _input: IterationStatement) -> Self::Output

fn consume_statement(&mut self, input: Statement) -> Self::Output

impl StructConsumer for StaticSingleAssigner<'_>

fn consume_struct(&mut self, struct_: Composite) -> Self::Output

Reconstructs records in the program, ordering its fields such that owner and is the first field.

type Output = Composite