Struct Replacer

pub struct Replacer<'a, F>
where
    F: Fn(&Expression) -> Expression,
{
    state: &'a mut CompilerState,
    refresh_expr_ids: bool,
    replace: F,
}

A Replacer traverses and reconstructs the AST, applying a user-defined replacement function to each Expression.

For example, this can be used to:

• Rename identifiers: to systematically rename identifiers throughout the AST.
• Expression interpolation: such as substituting arguments into function bodies.

During reconstruction, node IDs for blocks and loop bodies are regenerated using a NodeBuilder to ensure that the resulting scopes are different from the original. This avoids issues with stale or conflicting parent-child relationships between scopes.

The replacement function (replace) is applied early in expression reconstruction. If it produces a new expression (i.e., with a different node ID), it replaces the original; otherwise, the expression is recursively reconstructed as usual.

Note: Only Expression nodes are currently subject to replacement logic; all other AST nodes are reconstructed structurally.

TODO: Consider whether all nodes (not just scopes) should receive new IDs for consistency.

Fields

state: &'a mut CompilerState

refresh_expr_ids: bool

replace: F

Implementations

impl<'a, F> Replacer<'a, F>

where F: Fn(&Expression) -> Expression,

pub fn new( replace: F, refresh_expr_ids: bool, state: &'a mut CompilerState, ) -> Self

Trait Implementations

impl<F> AstReconstructor for Replacer<'_, F>

where F: Fn(&Expression) -> Expression,

type AdditionalOutput = ()

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

fn reconstruct_block(&mut self, input: Block) -> (Block, 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_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_async( &mut self, input: AsyncExpression, ) -> (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_struct_init( &mut self, input: StructExpression, ) -> (Expression, Self::AdditionalOutput)

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

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

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

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

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

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

fn reconstruct_const( &mut self, input: ConstDeclaration, ) -> (Statement, 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_return( &mut self, input: ReturnStatement, ) -> (Statement, Self::AdditionalOutput)

impl<F> ProgramReconstructor for Replacer<'_, F>

where F: Fn(&Expression) -> Expression,

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

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

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