Trait full_moon::visitors::VisitorMut[−][src]

pub trait VisitorMut<'ast> {

Show methods    fn visit_ast(&mut self, ast: Ast<'ast>) -> Ast<'ast>
    where
        Self: Sized,
    { ... }

    fn visit_anonymous_call(
        &mut self, 
        node: FunctionArgs<'ast>
    ) -> FunctionArgs<'ast> { ... }

    fn visit_anonymous_call_end(
        &mut self, 
        node: FunctionArgs<'ast>
    ) -> FunctionArgs<'ast> { ... }

    fn visit_assignment(&mut self, node: Assignment<'ast>) -> Assignment<'ast> { ... }

    fn visit_assignment_end(
        &mut self, 
        node: Assignment<'ast>
    ) -> Assignment<'ast> { ... }

    fn visit_block(&mut self, node: Block<'ast>) -> Block<'ast> { ... }

    fn visit_block_end(&mut self, node: Block<'ast>) -> Block<'ast> { ... }

    fn visit_call(&mut self, node: Call<'ast>) -> Call<'ast> { ... }

    fn visit_call_end(&mut self, node: Call<'ast>) -> Call<'ast> { ... }

    fn visit_contained_span(
        &mut self, 
        node: ContainedSpan<'ast>
    ) -> ContainedSpan<'ast> { ... }

    fn visit_contained_span_end(
        &mut self, 
        node: ContainedSpan<'ast>
    ) -> ContainedSpan<'ast> { ... }

    fn visit_do(&mut self, node: Do<'ast>) -> Do<'ast> { ... }

    fn visit_do_end(&mut self, node: Do<'ast>) -> Do<'ast> { ... }

    fn visit_else_if(&mut self, node: ElseIf<'ast>) -> ElseIf<'ast> { ... }

    fn visit_else_if_end(&mut self, node: ElseIf<'ast>) -> ElseIf<'ast> { ... }

    fn visit_eof(&mut self, node: TokenReference<'ast>) -> TokenReference<'ast> { ... }

    fn visit_eof_end(
        &mut self, 
        node: TokenReference<'ast>
    ) -> TokenReference<'ast> { ... }

    fn visit_expression(&mut self, node: Expression<'ast>) -> Expression<'ast> { ... }

    fn visit_expression_end(
        &mut self, 
        node: Expression<'ast>
    ) -> Expression<'ast> { ... }

    fn visit_field(&mut self, node: Field<'ast>) -> Field<'ast> { ... }

    fn visit_field_end(&mut self, node: Field<'ast>) -> Field<'ast> { ... }

    fn visit_function_args(
        &mut self, 
        node: FunctionArgs<'ast>
    ) -> FunctionArgs<'ast> { ... }

    fn visit_function_args_end(
        &mut self, 
        node: FunctionArgs<'ast>
    ) -> FunctionArgs<'ast> { ... }

    fn visit_function_body(
        &mut self, 
        node: FunctionBody<'ast>
    ) -> FunctionBody<'ast> { ... }

    fn visit_function_body_end(
        &mut self, 
        node: FunctionBody<'ast>
    ) -> FunctionBody<'ast> { ... }

    fn visit_function_call(
        &mut self, 
        node: FunctionCall<'ast>
    ) -> FunctionCall<'ast> { ... }

    fn visit_function_call_end(
        &mut self, 
        node: FunctionCall<'ast>
    ) -> FunctionCall<'ast> { ... }

    fn visit_function_declaration(
        &mut self, 
        node: FunctionDeclaration<'ast>
    ) -> FunctionDeclaration<'ast> { ... }

    fn visit_function_declaration_end(
        &mut self, 
        node: FunctionDeclaration<'ast>
    ) -> FunctionDeclaration<'ast> { ... }

    fn visit_function_name(
        &mut self, 
        node: FunctionName<'ast>
    ) -> FunctionName<'ast> { ... }

    fn visit_function_name_end(
        &mut self, 
        node: FunctionName<'ast>
    ) -> FunctionName<'ast> { ... }

    fn visit_generic_for(&mut self, node: GenericFor<'ast>) -> GenericFor<'ast> { ... }

    fn visit_generic_for_end(
        &mut self, 
        node: GenericFor<'ast>
    ) -> GenericFor<'ast> { ... }

    fn visit_if(&mut self, node: If<'ast>) -> If<'ast> { ... }

    fn visit_if_end(&mut self, node: If<'ast>) -> If<'ast> { ... }

    fn visit_index(&mut self, node: Index<'ast>) -> Index<'ast> { ... }

    fn visit_index_end(&mut self, node: Index<'ast>) -> Index<'ast> { ... }

    fn visit_local_assignment(
        &mut self, 
        node: LocalAssignment<'ast>
    ) -> LocalAssignment<'ast> { ... }

    fn visit_local_assignment_end(
        &mut self, 
        node: LocalAssignment<'ast>
    ) -> LocalAssignment<'ast> { ... }

    fn visit_local_function(
        &mut self, 
        node: LocalFunction<'ast>
    ) -> LocalFunction<'ast> { ... }

    fn visit_local_function_end(
        &mut self, 
        node: LocalFunction<'ast>
    ) -> LocalFunction<'ast> { ... }

    fn visit_last_stmt(&mut self, node: LastStmt<'ast>) -> LastStmt<'ast> { ... }

    fn visit_last_stmt_end(&mut self, node: LastStmt<'ast>) -> LastStmt<'ast> { ... }

    fn visit_method_call(&mut self, node: MethodCall<'ast>) -> MethodCall<'ast> { ... }

    fn visit_method_call_end(
        &mut self, 
        node: MethodCall<'ast>
    ) -> MethodCall<'ast> { ... }

    fn visit_numeric_for(&mut self, node: NumericFor<'ast>) -> NumericFor<'ast> { ... }

    fn visit_numeric_for_end(
        &mut self, 
        node: NumericFor<'ast>
    ) -> NumericFor<'ast> { ... }

    fn visit_parameter(&mut self, node: Parameter<'ast>) -> Parameter<'ast> { ... }

    fn visit_parameter_end(&mut self, node: Parameter<'ast>) -> Parameter<'ast> { ... }

    fn visit_prefix(&mut self, node: Prefix<'ast>) -> Prefix<'ast> { ... }

    fn visit_prefix_end(&mut self, node: Prefix<'ast>) -> Prefix<'ast> { ... }

    fn visit_return(&mut self, node: Return<'ast>) -> Return<'ast> { ... }

    fn visit_return_end(&mut self, node: Return<'ast>) -> Return<'ast> { ... }

    fn visit_repeat(&mut self, node: Repeat<'ast>) -> Repeat<'ast> { ... }

    fn visit_repeat_end(&mut self, node: Repeat<'ast>) -> Repeat<'ast> { ... }

    fn visit_stmt(&mut self, node: Stmt<'ast>) -> Stmt<'ast> { ... }

    fn visit_stmt_end(&mut self, node: Stmt<'ast>) -> Stmt<'ast> { ... }

    fn visit_suffix(&mut self, node: Suffix<'ast>) -> Suffix<'ast> { ... }

    fn visit_suffix_end(&mut self, node: Suffix<'ast>) -> Suffix<'ast> { ... }

    fn visit_table_constructor(
        &mut self, 
        node: TableConstructor<'ast>
    ) -> TableConstructor<'ast> { ... }

    fn visit_table_constructor_end(
        &mut self, 
        node: TableConstructor<'ast>
    ) -> TableConstructor<'ast> { ... }

    fn visit_token_reference(
        &mut self, 
        node: TokenReference<'ast>
    ) -> TokenReference<'ast> { ... }

    fn visit_token_reference_end(
        &mut self, 
        node: TokenReference<'ast>
    ) -> TokenReference<'ast> { ... }

    fn visit_un_op(&mut self, node: UnOp<'ast>) -> UnOp<'ast> { ... }

    fn visit_un_op_end(&mut self, node: UnOp<'ast>) -> UnOp<'ast> { ... }

    fn visit_value(&mut self, node: Value<'ast>) -> Value<'ast> { ... }

    fn visit_value_end(&mut self, node: Value<'ast>) -> Value<'ast> { ... }

    fn visit_var(&mut self, node: Var<'ast>) -> Var<'ast> { ... }

    fn visit_var_end(&mut self, node: Var<'ast>) -> Var<'ast> { ... }

    fn visit_var_expression(
        &mut self, 
        node: VarExpression<'ast>
    ) -> VarExpression<'ast> { ... }

    fn visit_var_expression_end(
        &mut self, 
        node: VarExpression<'ast>
    ) -> VarExpression<'ast> { ... }

    fn visit_while(&mut self, node: While<'ast>) -> While<'ast> { ... }

    fn visit_while_end(&mut self, node: While<'ast>) -> While<'ast> { ... }

    fn visit_compound_assignment(
        &mut self, 
        node: CompoundAssignment<'ast>
    ) -> CompoundAssignment<'ast> { ... }

    fn visit_compound_assignment_end(
        &mut self, 
        node: CompoundAssignment<'ast>
    ) -> CompoundAssignment<'ast> { ... }

    fn visit_compound_op(&mut self, node: CompoundOp<'ast>) -> CompoundOp<'ast> { ... }

    fn visit_compound_op_end(
        &mut self, 
        node: CompoundOp<'ast>
    ) -> CompoundOp<'ast> { ... }

    fn visit_exported_type_declaration(
        &mut self, 
        node: ExportedTypeDeclaration<'ast>
    ) -> ExportedTypeDeclaration<'ast> { ... }

    fn visit_exported_type_declaration_end(
        &mut self, 
        node: ExportedTypeDeclaration<'ast>
    ) -> ExportedTypeDeclaration<'ast> { ... }

    fn visit_generic_declaration(
        &mut self, 
        node: GenericDeclaration<'ast>
    ) -> GenericDeclaration<'ast> { ... }

    fn visit_generic_declaration_end(
        &mut self, 
        node: GenericDeclaration<'ast>
    ) -> GenericDeclaration<'ast> { ... }

    fn visit_indexed_type_info(
        &mut self, 
        node: IndexedTypeInfo<'ast>
    ) -> IndexedTypeInfo<'ast> { ... }

    fn visit_indexed_type_info_end(
        &mut self, 
        node: IndexedTypeInfo<'ast>
    ) -> IndexedTypeInfo<'ast> { ... }

    fn visit_type_argument(
        &mut self, 
        node: TypeArgument<'ast>
    ) -> TypeArgument<'ast> { ... }

    fn visit_type_argument_end(
        &mut self, 
        node: TypeArgument<'ast>
    ) -> TypeArgument<'ast> { ... }

    fn visit_type_assertion(
        &mut self, 
        node: TypeAssertion<'ast>
    ) -> TypeAssertion<'ast> { ... }

    fn visit_type_assertion_end(
        &mut self, 
        node: TypeAssertion<'ast>
    ) -> TypeAssertion<'ast> { ... }

    fn visit_type_declaration(
        &mut self, 
        node: TypeDeclaration<'ast>
    ) -> TypeDeclaration<'ast> { ... }

    fn visit_type_declaration_end(
        &mut self, 
        node: TypeDeclaration<'ast>
    ) -> TypeDeclaration<'ast> { ... }

    fn visit_type_field(&mut self, node: TypeField<'ast>) -> TypeField<'ast> { ... }

    fn visit_type_field_end(&mut self, node: TypeField<'ast>) -> TypeField<'ast> { ... }

    fn visit_type_field_key(
        &mut self, 
        node: TypeFieldKey<'ast>
    ) -> TypeFieldKey<'ast> { ... }

    fn visit_type_field_key_end(
        &mut self, 
        node: TypeFieldKey<'ast>
    ) -> TypeFieldKey<'ast> { ... }

    fn visit_type_info(&mut self, node: TypeInfo<'ast>) -> TypeInfo<'ast> { ... }

    fn visit_type_info_end(&mut self, node: TypeInfo<'ast>) -> TypeInfo<'ast> { ... }

    fn visit_type_specifier(
        &mut self, 
        node: TypeSpecifier<'ast>
    ) -> TypeSpecifier<'ast> { ... }

    fn visit_type_specifier_end(
        &mut self, 
        node: TypeSpecifier<'ast>
    ) -> TypeSpecifier<'ast> { ... }

    fn visit_goto(&mut self, node: Goto<'ast>) -> Goto<'ast> { ... }

    fn visit_goto_end(&mut self, node: Goto<'ast>) -> Goto<'ast> { ... }

    fn visit_label(&mut self, node: Label<'ast>) -> Label<'ast> { ... }

    fn visit_label_end(&mut self, node: Label<'ast>) -> Label<'ast> { ... }

    fn visit_identifier(&mut self, token: Token<'ast>) -> Token<'ast> { ... }

    fn visit_multi_line_comment(&mut self, token: Token<'ast>) -> Token<'ast> { ... }

    fn visit_number(&mut self, token: Token<'ast>) -> Token<'ast> { ... }

    fn visit_single_line_comment(&mut self, token: Token<'ast>) -> Token<'ast> { ... }

    fn visit_string_literal(&mut self, token: Token<'ast>) -> Token<'ast> { ... }

    fn visit_symbol(&mut self, token: Token<'ast>) -> Token<'ast> { ... }

    fn visit_token(&mut self, token: Token<'ast>) -> Token<'ast> { ... }

    fn visit_whitespace(&mut self, token: Token<'ast>) -> Token<'ast> { ... }

}
Expand description

A trait that implements functions to listen for specific nodes/tokens. Unlike Visitor, nodes/tokens passed are mutable.

Provided methods

Visit the nodes of an Ast

fn visit_function_body(
    &mut self,
    node: FunctionBody<'ast>
) -> FunctionBody<'ast>[src]
fn visit_function_body_end(
    &mut self,
    node: FunctionBody<'ast>
) -> FunctionBody<'ast>[src]

Implementors