Struct leo_passes::dead_code_elimination::dead_code_eliminator::DeadCodeEliminator

pub struct DeadCodeEliminator<'a> {
    pub(crate) node_builder: &'a NodeBuilder,
    pub(crate) used_variables: IndexSet<Symbol>,
    pub(crate) is_necessary: bool,
    pub(crate) is_async: bool,
}

Fields

node_builder: &'a NodeBuilder

A counter to generate unique node IDs.

used_variables: IndexSet<Symbol>

The set of used variables in the current function body.

is_necessary: bool

Whether or not the variables are necessary.

is_async: bool

Whether or not we are currently traversing an async function.

Implementations

impl<'a> DeadCodeEliminator<'a>

pub fn new(node_builder: &'a NodeBuilder) -> Self

Initializes a new DeadCodeEliminator.

Trait Implementations

impl ExpressionReconstructor for DeadCodeEliminator<'_>

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

Reconstructs the associated function access expression.

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

Reconstruct the components of the struct init expression. This is necessary since the reconstructor does not explicitly visit each component of the expression.

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

Marks identifiers as used. This is necessary to determine which statements can be eliminated from the program.

type AdditionalOutput = ()

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

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

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

fn reconstruct_associated_constant( &mut self, input: AssociatedConstant, ) -> (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_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 DeadCodeEliminator<'a>

type Input = (Ast, &'a NodeBuilder)

type Output = Result<Ast, LeoError>

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

Runs the compiler pass.

impl ProgramReconstructor for DeadCodeEliminator<'_>

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

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

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_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 DeadCodeEliminator<'_>

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

Reconstruct an assignment statement by eliminating any dead code.

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

Reconstructs the statements inside a basic block, eliminating any dead code.

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

Flattening removes conditional statements from the program.

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

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

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

Static single assignment replaces definition statements with assignment statements.

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

Reconstructs expression statements by eliminating any dead code.

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

Loop unrolling unrolls and removes iteration statements from the program.

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

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

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

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