Struct WriteTransformingVisitor

pub struct WriteTransformingVisitor<'a> {
    pub state: &'a mut CompilerState,
    pub struct_members: IndexMap<Symbol, IndexMap<Symbol, Identifier>>,
    pub array_members: IndexMap<Symbol, Vec<Identifier>>,
    pub program: Symbol,
}

This visitor associates a variable for each member of a struct or array that is written to. Whenever a member of the struct or array is written to, we change the assignment to access the variable instead. Whenever the struct or array itself is accessed, we first rebuild the struct or array from its variables.

Fields

state: &'a mut CompilerState

struct_members: IndexMap<Symbol, IndexMap<Symbol, Identifier>>

For any struct whose members are written to, a map of its field names to variables corresponding to the members.

array_members: IndexMap<Symbol, Vec<Identifier>>

For any array whose members are written to, a vec containing the variables for each index.

program: Symbol

Implementations

impl WriteTransformingVisitor<'_>

pub fn get_array_member( &self, array_name: Symbol, index: &Expression, ) -> Option<Identifier>

pub fn get_struct_member( &self, struct_name: Symbol, field_name: Symbol, ) -> Option<Identifier>

impl WriteTransformingVisitor<'_>

pub fn define_variable_members( &mut self, name: Identifier, accumulate: &mut Vec<Statement>, )

If name is a struct or array whose members are written to, make DefinitionStatements for each of its variables that will correspond to the members. Note that we create them for all members; unnecessary ones will be removed by DCE.

impl WriteTransformingVisitor<'_>

pub fn reconstruct_assign_place(&mut self, input: Expression) -> Identifier

If we’re assigning to a struct or array member, find the variable name we’re actually writing to, recursively if necessary. That is, if we have arr[0u32][1u32] = ..., we find the corresponding variable arr_0_1.

fn reconstruct_assign_recurse( &self, place: Identifier, value: Expression, accumulate: &mut Vec<Statement>, )

If we’re assigning to a struct or array, create assignments to the individual members, if applicable.

impl<'a> WriteTransformingVisitor<'a>

pub fn new(state: &'a mut CompilerState, program: &Program) -> Self

Trait Implementations

impl ExpressionReconstructor for WriteTransformingVisitor<'_>

type AdditionalOutput = Vec<Statement>

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

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

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

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

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

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

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

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

impl ProgramReconstructor for WriteTransformingVisitor<'_>

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

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

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

impl StatementReconstructor for WriteTransformingVisitor<'_>

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

This is the only reconstructing function where we do anything other than traverse and combine statements, by calling reconstruct_assign_place and reconstruct_assign_recurse.

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

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

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

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

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

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

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

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

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

impl TypeReconstructor for WriteTransformingVisitor<'_>

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

fn reconstruct_array_type( &mut self, input: ArrayType, ) -> (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)