Struct leo_passes::loop_unrolling::unroller::Unroller

pub struct Unroller<'a> {
    pub(crate) constant_propagation_table: RefCell<ConstantPropagationTable>,
    pub(crate) symbol_table: RefCell<SymbolTable>,
    pub(crate) type_table: &'a TypeTable,
    pub(crate) scope_index: usize,
    pub(crate) handler: &'a Handler,
    pub(crate) node_builder: &'a NodeBuilder,
    pub(crate) is_unrolling: bool,
    pub(crate) current_program: Option<Symbol>,
}

Fields

constant_propagation_table: RefCell<ConstantPropagationTable>

A table of constant variables.

symbol_table: RefCell<SymbolTable>

The symbol table for the function being processed.

type_table: &'a TypeTable

A mapping from node IDs to their types.

scope_index: usize

The index of the current scope.

handler: &'a Handler

An error handler used for any errors found during unrolling.

node_builder: &'a NodeBuilder

A counter used to generate unique node IDs.

is_unrolling: bool

Are we in the midst of unrolling a loop?

current_program: Option<Symbol>

The current program name.

Implementations

impl<'a> Unroller<'a>

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

pub(crate) fn current_scope_index(&mut self) -> usize

Returns the index of the current scope. Note that if we are in the midst of unrolling an IterationStatement, a new scope is created.

pub(crate) fn enter_scope(&mut self, index: usize) -> usize

Enters a child scope.

pub(crate) fn exit_scope(&mut self, index: usize)

Exits the current block scope.

pub(crate) fn emit_err(&self, err: LoopUnrollerError)

Emits a Loop Unrolling Error

pub(crate) fn unroll_iteration_statement<I: LoopBound>( &mut self, input: IterationStatement, ) -> Statement

Unrolls an IterationStatement.

fn unroll_single_iteration<I: LoopBound>( &mut self, input: &IterationStatement, iteration_count: I, ) -> Statement

A helper function to unroll a single iteration an IterationStatement.

Trait Implementations

impl ExpressionReconstructor for Unroller<'_>

type AdditionalOutput = bool

fn reconstruct_array_access( &mut self, input: ArrayAccess, ) -> (Expression, Self::AdditionalOutput)

fn reconstruct_identifier( &mut self, input: Identifier, ) -> (Expression, Self::AdditionalOutput)

fn reconstruct_expression( &mut self, input: Expression, ) -> (Expression, Self::AdditionalOutput)

fn reconstruct_access( &mut self, input: AccessExpression, ) -> (Expression, Self::AdditionalOutput)

fn reconstruct_associated_constant( &mut self, input: AssociatedConstant, ) -> (Expression, Self::AdditionalOutput)

fn reconstruct_associated_function( &mut self, input: AssociatedFunction, ) -> (Expression, Self::AdditionalOutput)

fn reconstruct_member_access( &mut self, input: MemberAccess, ) -> (Expression, Self::AdditionalOutput)

fn reconstruct_tuple_access( &mut self, input: TupleAccess, ) -> (Expression, Self::AdditionalOutput)

fn reconstruct_array( &mut self, input: ArrayExpression, ) -> (Expression, Self::AdditionalOutput)

fn reconstruct_binary( &mut self, input: BinaryExpression, ) -> (Expression, Self::AdditionalOutput)

fn reconstruct_call( &mut self, input: CallExpression, ) -> (Expression, Self::AdditionalOutput)

fn reconstruct_cast( &mut self, input: CastExpression, ) -> (Expression, Self::AdditionalOutput)

fn reconstruct_struct_init( &mut self, input: StructExpression, ) -> (Expression, Self::AdditionalOutput)

fn reconstruct_err( &mut self, _input: ErrExpression, ) -> (Expression, Self::AdditionalOutput)

fn reconstruct_literal( &mut self, input: Literal, ) -> (Expression, Self::AdditionalOutput)

fn reconstruct_locator( &mut self, input: LocatorExpression, ) -> (Expression, Self::AdditionalOutput)

fn reconstruct_ternary( &mut self, input: TernaryExpression, ) -> (Expression, Self::AdditionalOutput)

fn reconstruct_tuple( &mut self, input: TupleExpression, ) -> (Expression, Self::AdditionalOutput)

fn reconstruct_unary( &mut self, input: UnaryExpression, ) -> (Expression, Self::AdditionalOutput)

fn reconstruct_unit( &mut self, input: UnitExpression, ) -> (Expression, Self::AdditionalOutput)

impl<'a> Pass for Unroller<'a>

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

type Output = Result<(Ast, SymbolTable), LeoError>

fn do_pass((ast, handler, node_builder, st, tt): Self::Input) -> Self::Output

Runs the compiler pass.

impl ProgramReconstructor for Unroller<'_>

fn reconstruct_stub(&mut self, input: Stub) -> Stub

fn reconstruct_program_scope(&mut self, input: ProgramScope) -> ProgramScope

fn reconstruct_function_stub(&mut self, input: FunctionStub) -> FunctionStub

fn reconstruct_function(&mut self, function: Function) -> Function

fn reconstruct_program(&mut self, input: Program) -> Program

fn reconstruct_struct(&mut self, input: Composite) -> Composite

fn reconstruct_import(&mut self, input: Program) -> Program

fn reconstruct_mapping(&mut self, input: Mapping) -> Mapping

impl StatementReconstructor for Unroller<'_>

fn reconstruct_block(&mut self, input: Block) -> (Block, Self::AdditionalOutput)

fn reconstruct_const( &mut self, input: ConstDeclaration, ) -> (Statement, Self::AdditionalOutput)

fn reconstruct_definition( &mut self, input: DefinitionStatement, ) -> (Statement, Self::AdditionalOutput)

fn reconstruct_iteration( &mut self, input: IterationStatement, ) -> (Statement, Self::AdditionalOutput)

fn reconstruct_statement( &mut self, input: Statement, ) -> (Statement, Self::AdditionalOutput)

fn reconstruct_assert( &mut self, input: AssertStatement, ) -> (Statement, Self::AdditionalOutput)

fn reconstruct_assign( &mut self, input: AssignStatement, ) -> (Statement, Self::AdditionalOutput)

fn reconstruct_conditional( &mut self, input: ConditionalStatement, ) -> (Statement, Self::AdditionalOutput)

fn reconstruct_console( &mut self, input: ConsoleStatement, ) -> (Statement, Self::AdditionalOutput)

fn reconstruct_expression_statement( &mut self, input: ExpressionStatement, ) -> (Statement, Self::AdditionalOutput)

fn reconstruct_return( &mut self, input: ReturnStatement, ) -> (Statement, Self::AdditionalOutput)