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

pub trait Visitor<'ast> {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

}
Expand description

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

// A visitor that logs every local assignment made
#[derive(Default)]
struct LocalVariableVisitor {
    names: Vec<String>,
}

impl<'ast> Visitor<'ast> for LocalVariableVisitor {
    fn visit_local_assignment(&mut self, local_assignment: &ast::LocalAssignment<'ast>) {
        self.names.extend(&mut local_assignment.names().iter().map(|name| name.token().to_string()));
    }
}

let mut visitor = LocalVariableVisitor::default();
visitor.visit_ast(&full_moon::parse("local x = 1; local y, z = 2, 3")?);
assert_eq!(visitor.names, vec!["x", "y", "z"]);

Provided methods

Visit the nodes of an Ast

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

Implementors