Struct DestructuringVisitor 

pub struct DestructuringVisitor<'a> {
    pub state: &'a mut CompilerState,
    pub tuples: IndexMap<Symbol, Vec<Identifier>>,
    pub is_async: bool,
}

Fields

state: &'a mut CompilerState

tuples: IndexMap<Symbol, Vec<Identifier>>

A mapping between variables and tuple elements.

is_async: bool

Whether or not we are currently traversing an async function block.

Implementations

impl DestructuringVisitor<'_>

pub fn reconstruct_expression_tuple( &mut self, expression: Expression, ) -> (Expression, Vec<Statement>)

Similar to reconstruct_expression, except that if expression is of tuple type, returns it as a tuple literal (mem1, mem2, mem3, ...).

pub fn fold_with_op<I>(&mut self, op: BinaryOperation, pieces: I) -> Expression

where I: Iterator<Item = Expression>,

Folds an iterator of expressions into a left-associated chain using op.

Given expressions [e1, e2, e3], this produces ((e1 op e2) op e3). Each intermediate node is assigned a fresh ID and recorded as Boolean in the type table.

Panics if the iterator is empty.

pub fn assign_tuple( &mut self, expression: Expression, name: Symbol, ) -> Statement

Trait Implementations

impl AstReconstructor for DestructuringVisitor<'_>

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

Reconstructs a binary expression, expanding equality and inequality over tuples into elementwise comparisons. When both sides are tuples and the operator is == or !=, it generates per-element comparisons and folds them with AND/OR; otherwise the expression is rebuilt normally.

Example: (a, b) == (c, d) → (a == c) && (b == d) Example: (a, b, c) != (x, y, z) → (a != x) || (b != y) || (c != z)

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

Replaces a tuple access expression with the appropriate expression.

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

If this is a ternary expression on tuples of length n, we’ll need to change it into n ternary expressions on the members.

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

assert_eq and assert_neq comparing tuples should be expanded to as many asserts as the length of each tuple.

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

Modify assignments to tuples to become assignments to the corresponding variables.

There are two cases we handle:

1. An assignment to a tuple x, like x = rhs;. This we need to transform into individual assignments x_i = rhs_i; of the variables corresponding to members of x and rhs.
2. An assignment to a tuple member, like x.2[i].member = rhs;. This we need to change into x_2[i].member = rhs; where x_2 is the variable corresponding to x.2.

type AdditionalInput = ()

type AdditionalOutput = Vec<Statement>

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

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

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

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

fn reconstruct_return( &mut self, input: ReturnStatement, ) -> (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_optional_type( &mut self, input: OptionalType, ) -> (Type, Self::AdditionalOutput)

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

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

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

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

fn reconstruct_async( &mut self, input: AsyncExpression, _additional: &Self::AdditionalInput, ) -> (Expression, Self::AdditionalOutput)

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

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

fn reconstruct_intrinsic( &mut self, input: IntrinsicExpression, _additional: &Self::AdditionalInput, ) -> (Expression, Self::AdditionalOutput)

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

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

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

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

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

fn reconstruct_path( &mut self, input: Path, _additional: &Self::AdditionalInput, ) -> (Expression, Self::AdditionalOutput)

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

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

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

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

fn reconstruct_unit( &mut self, input: UnitExpression, _additional: &Self::AdditionalInput, ) -> (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 DestructuringVisitor<'_>

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

fn reconstruct_constructor(&mut self, input: Constructor) -> Constructor

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_module(&mut self, input: Module) -> Module

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

fn reconstruct_storage_variable( &mut self, input: StorageVariable, ) -> StorageVariable