Struct Replacer

pub struct Replacer<'a, F>
where
    F: Fn(&Identifier) -> Expression,
{
    node_builder: &'a NodeBuilder,
    replace: F,
}

A Replacer applies replacer to all Identifiers in an AST. Replacers are used to rename identifiers. Replacers are used to interpolate function arguments.

All scopes are given new node IDs to avoid stale parent/children relationship between nodes.

TODO: should we give new IDs to everything?

Fields

node_builder: &'a NodeBuilder

replace: F

Implementations

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

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

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

Trait Implementations

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

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

type AdditionalOutput = ()

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

fn reconstruct_expression( &mut self, input: Expression, ) -> (Expression, 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_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_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<F> ProgramReconstructor for Replacer<'_, F>

where F: Fn(&Identifier) -> 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_function(&mut self, input: Function) -> Function

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<F> StatementReconstructor for Replacer<'_, F>

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

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

fn reconstruct_iteration( &mut self, input: IterationStatement, ) -> (Statement, 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> TypeReconstructor for Replacer<'_, F>

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

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)