Struct SsaFormingVisitor

pub struct SsaFormingVisitor<'a> {
    pub state: &'a mut CompilerState,
    pub rename_table: RenameTable,
    pub program: Symbol,
    pub rename_defs: bool,
}

Fields

state: &'a mut CompilerState

rename_table: RenameTable

The RenameTable for the current basic block in the AST

program: Symbol

The main program name.

rename_defs: bool

Whether to rename places in definitions.

Implementations

impl SsaFormingVisitor<'_>

pub fn consume_expression_and_define( &mut self, input: Expression, ) -> (Expression, Vec<Statement>)

Consume this expression and assign it to a variable (unless it’s already an Identifier).

impl SsaFormingVisitor<'_>

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 rename_identifier(&mut self, identifier: Identifier) -> Identifier

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

pub(crate) fn unique_simple_definition( &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 SsaFormingVisitor<'_>

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

Retrieve the new name for this Identifier.

Note that this shouldn’t be used for Identifiers on the lhs of definitions or assignments.

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 modifications

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_array_access(&mut self, input: ArrayAccess) -> Self::Output

fn consume_member_access(&mut self, input: MemberAccess) -> Self::Output

fn consume_tuple_access(&mut self, input: TupleAccess) -> Self::Output

fn consume_repeat(&mut self, input: RepeatExpression) -> Self::Output

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

fn consume_associated_constant( &mut self, input: AssociatedConstantExpression, ) -> Self::Output

fn consume_associated_function( &mut self, input: AssociatedFunctionExpression, ) -> Self::Output

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

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

impl FunctionConsumer for SsaFormingVisitor<'_>

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

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

type Output = Function

impl ProgramConsumer for SsaFormingVisitor<'_>

type Output = Program

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

impl ProgramScopeConsumer for SsaFormingVisitor<'_>

type Output = ProgramScope

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

impl StatementConsumer for SsaFormingVisitor<'_>

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

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