Struct FlatteningVisitor

pub struct FlatteningVisitor<'a> {
    pub state: &'a mut CompilerState,
    pub condition_stack: Vec<Guard>,
    pub returns: Vec<(ReturnGuard, ReturnStatement)>,
    pub program: Symbol,
    pub is_async: bool,
}

Fields

state: &'a mut CompilerState

condition_stack: Vec<Guard>

A stack of condition Expressions visited up to the current point in the AST.

returns: Vec<(ReturnGuard, ReturnStatement)>

A list containing tuples of guards and expressions associated ReturnStatements. A guard is an expression that evaluates to true on the execution path of the ReturnStatement. Note that returns are inserted in the order they are encountered during a pre-order traversal of the AST. Note that type checking guarantees that there is at most one return in a basic block.

program: Symbol

The program name.

is_async: bool

Whether the function is an async function.

Implementations

impl FlatteningVisitor<'_>

pub fn construct_early_return_guard( &mut self, ) -> Option<(Identifier, Vec<Statement>)>

Construct an early return guard.

That is, an Identifier assigned to a boolean that is true iff some early return was taken.

pub fn construct_guard(&mut self) -> Option<(Identifier, Vec<Statement>)>

Construct a guard from the current state of the condition stack.

That is, a boolean expression which is true iff we’ve followed the branches that led to the current point in the Leo code.

pub fn fold_guards( &mut self, prefix: &str, guards: Vec<(Option<Expression>, Expression)>, ) -> (Expression, Vec<Statement>)

Fold guards and expressions into a single expression. Note that this function assumes that at least one guard is present.

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

A wrapper around assigner.unique_simple_definition that updates self.structs.

pub fn simple_definition( &mut self, lhs: Identifier, rhs: Expression, ) -> Statement

A wrapper around assigner.simple_definition that tracks the type of the lhs.

pub fn fold_returns( &mut self, block: &mut Block, returns: Vec<(Option<Expression>, ReturnStatement)>, )

Folds a list of return statements into a single return statement and adds the produced statements to the block.

fn make_array_access_definition( &mut self, i: usize, identifier: Identifier, array_type: &ArrayType, ) -> (Identifier, Statement)

pub fn ternary_array( &mut self, array: &ArrayType, condition: &Expression, first: &Identifier, second: &Identifier, ) -> (Expression, Vec<Statement>)

fn make_struct_access_definition( &mut self, inner: Identifier, name: Identifier, type_: Type, ) -> (Identifier, Statement)

pub fn ternary_struct( &mut self, struct_: &Composite, condition: &Expression, first: &Identifier, second: &Identifier, ) -> (Expression, Vec<Statement>)

pub fn ternary_tuple( &mut self, tuple_type: &TupleType, condition: &Expression, first: &Expression, second: &Expression, ) -> (Expression, Vec<Statement>)

Trait Implementations

impl AstReconstructor for FlatteningVisitor<'_>

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

Reconstructs a struct init expression, flattening any tuples in the expression.

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

Reconstructs ternary expressions over arrays, structs, and tuples, accumulating any statements that are generated. This is necessary because Aleo instructions does not support ternary expressions over composite data types. For example, the ternary expression cond ? (a, b) : (c, d) is flattened into the following:

let var$0 = cond ? a : c;
let var$1 = cond ? b : d;
(var$0, var$1)

For structs, the ternary expression cond ? a : b, where a and b are both structs Foo { bar: u8, baz: u8 }, is flattened into the following:

let var$0 = cond ? a.bar : b.bar;
let var$1 = cond ? a.baz : b.baz;
let var$2 = Foo { bar: var$0, baz: var$1 };
var$2

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

Rewrites an assert statement into a flattened form. Assert statements at the top level only have their arguments flattened. Assert statements inside a conditional statement are flattened to such that the check is conditional on the execution path being valid. For example, the following snippet:

if condition1 {
   if condition2 {
       assert(foo);
   }
}

is flattened to:

assert(!(condition1 && condition2) || foo);

which is equivalent to the logical formula (condition1 /\ condition2) ==> foo.

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

Flattens the statements inside a basic block. The resulting block does not contain any conditional statements.

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

Flatten a conditional statement into a list of statements.

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

Flattens a definition, if necessary. Marks variables as structs as necessary. Note that new statements are only produced if the right hand side is a ternary expression over structs. Otherwise, the statement is returned as is.

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

Transforms a return statement into an empty block statement. Stores the arguments to the return statement, which are later folded into a single return statement at the end of the function.

type AdditionalOutput = Vec<Statement>

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

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

fn reconstruct_type(&mut self, input: Type) -> (Type, Self::AdditionalOutput)

fn reconstruct_array_type( &mut self, input: ArrayType, ) -> (Type, Self::AdditionalOutput)

fn reconstruct_composite_type( &mut self, input: CompositeType, ) -> (Type, Self::AdditionalOutput)

fn reconstruct_future_type( &mut self, input: FutureType, ) -> (Type, Self::AdditionalOutput)

fn reconstruct_mapping_type( &mut self, input: MappingType, ) -> (Type, Self::AdditionalOutput)

fn reconstruct_tuple_type( &mut self, input: TupleType, ) -> (Type, Self::AdditionalOutput)

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

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

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

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

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

fn reconstruct_repeat( &mut self, input: RepeatExpression, ) -> (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_err( &mut self, _input: ErrExpression, ) -> (Expression, Self::AdditionalOutput)

fn reconstruct_identifier( &mut self, input: Identifier, ) -> (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_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)

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

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

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

impl ProgramReconstructor for FlatteningVisitor<'_>

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

Flattens a program scope.

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

Flattens a function’s body

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

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

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

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

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

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