[−][src]Trait lib_ruby_parser::traverse::Visitor

pub trait Visitor<T: Default = ()> {
    pub fn visit_all(&mut self, nodes: &[Node]) -> T { ... }
    pub fn maybe_visit(&mut self, node: &Option<Box<Node>>) -> T { ... }
    pub fn on_alias(&mut self, node: &Alias) -> T { ... }
    pub fn on_and(&mut self, node: &And) -> T { ... }
    pub fn on_and_asgn(&mut self, node: &AndAsgn) -> T { ... }
    pub fn on_arg(&mut self, node: &Arg) -> T { ... }
    pub fn on_args(&mut self, node: &Args) -> T { ... }
    pub fn on_array(&mut self, node: &Array) -> T { ... }
    pub fn on_array_pattern(&mut self, node: &ArrayPattern) -> T { ... }
    pub fn on_array_pattern_with_tail(
        &mut self, 
        node: &ArrayPatternWithTail
    ) -> T { ... }
    pub fn on_back_ref(&mut self, node: &BackRef) -> T { ... }
    pub fn on_begin(&mut self, node: &Begin) -> T { ... }
    pub fn on_block(&mut self, node: &Block) -> T { ... }
    pub fn on_blockarg(&mut self, node: &Blockarg) -> T { ... }
    pub fn on_block_pass(&mut self, node: &BlockPass) -> T { ... }
    pub fn on_break(&mut self, node: &Break) -> T { ... }
    pub fn on_case(&mut self, node: &Case) -> T { ... }
    pub fn on_case_match(&mut self, node: &CaseMatch) -> T { ... }
    pub fn on_casgn(&mut self, node: &Casgn) -> T { ... }
    pub fn on_cbase(&mut self, node: &Cbase) -> T { ... }
    pub fn on_class(&mut self, node: &Class) -> T { ... }
    pub fn on_complex(&mut self, node: &Complex) -> T { ... }
    pub fn on_const(&mut self, node: &Const) -> T { ... }
    pub fn on_const_pattern(&mut self, node: &ConstPattern) -> T { ... }
    pub fn on_csend(&mut self, node: &CSend) -> T { ... }
    pub fn on_cvar(&mut self, node: &Cvar) -> T { ... }
    pub fn on_cvasgn(&mut self, node: &Cvasgn) -> T { ... }
    pub fn on_def(&mut self, node: &Def) -> T { ... }
    pub fn on_defined(&mut self, node: &Defined) -> T { ... }
    pub fn on_defs(&mut self, node: &Defs) -> T { ... }
    pub fn on_dstr(&mut self, node: &Dstr) -> T { ... }
    pub fn on_dsym(&mut self, node: &Dsym) -> T { ... }
    pub fn on_eflipflop(&mut self, node: &EFlipFlop) -> T { ... }
    pub fn on_empty_else(&mut self, node: &EmptyElse) -> T { ... }
    pub fn on_encoding(&mut self, node: &Encoding) -> T { ... }
    pub fn on_ensure(&mut self, node: &Ensure) -> T { ... }
    pub fn on_erange(&mut self, node: &Erange) -> T { ... }
    pub fn on_false(&mut self, node: &False) -> T { ... }
    pub fn on_file(&mut self, node: &File) -> T { ... }
    pub fn on_find_pattern(&mut self, node: &FindPattern) -> T { ... }
    pub fn on_float(&mut self, node: &Float) -> T { ... }
    pub fn on_for(&mut self, node: &For) -> T { ... }
    pub fn on_forward_arg(&mut self, node: &ForwardArg) -> T { ... }
    pub fn on_forwarded_args(&mut self, node: &ForwardedArgs) -> T { ... }
    pub fn on_gvar(&mut self, node: &Gvar) -> T { ... }
    pub fn on_gvasgn(&mut self, node: &Gvasgn) -> T { ... }
    pub fn on_hash(&mut self, node: &Hash) -> T { ... }
    pub fn on_hash_pattern(&mut self, node: &HashPattern) -> T { ... }
    pub fn on_heredoc(&mut self, node: &Heredoc) -> T { ... }
    pub fn on_if(&mut self, node: &If) -> T { ... }
    pub fn on_if_guard(&mut self, node: &IfGuard) -> T { ... }
    pub fn on_iflipflop(&mut self, node: &IFlipFlop) -> T { ... }
    pub fn on_if_mod(&mut self, node: &IfMod) -> T { ... }
    pub fn on_if_ternary(&mut self, node: &IfTernary) -> T { ... }
    pub fn on_index(&mut self, node: &Index) -> T { ... }
    pub fn on_index_asgn(&mut self, node: &IndexAsgn) -> T { ... }
    pub fn on_in_match(&mut self, node: &InMatch) -> T { ... }
    pub fn on_in_pattern(&mut self, node: &InPattern) -> T { ... }
    pub fn on_int(&mut self, node: &Int) -> T { ... }
    pub fn on_irange(&mut self, node: &Irange) -> T { ... }
    pub fn on_ivar(&mut self, node: &Ivar) -> T { ... }
    pub fn on_ivasgn(&mut self, node: &Ivasgn) -> T { ... }
    pub fn on_kwarg(&mut self, node: &Kwarg) -> T { ... }
    pub fn on_kwbegin(&mut self, node: &KwBegin) -> T { ... }
    pub fn on_kwnilarg(&mut self, node: &Kwnilarg) -> T { ... }
    pub fn on_kwoptarg(&mut self, node: &Kwoptarg) -> T { ... }
    pub fn on_kwrestarg(&mut self, node: &Kwrestarg) -> T { ... }
    pub fn on_kwsplat(&mut self, node: &Kwsplat) -> T { ... }
    pub fn on_lambda(&mut self, node: &Lambda) -> T { ... }
    pub fn on_line(&mut self, node: &Line) -> T { ... }
    pub fn on_lvar(&mut self, node: &Lvar) -> T { ... }
    pub fn on_lvasgn(&mut self, node: &Lvasgn) -> T { ... }
    pub fn on_masgn(&mut self, node: &Masgn) -> T { ... }
    pub fn on_match_alt(&mut self, node: &MatchAlt) -> T { ... }
    pub fn on_match_as(&mut self, node: &MatchAs) -> T { ... }
    pub fn on_match_current_line(&mut self, node: &MatchCurrentLine) -> T { ... }
    pub fn on_match_nil_pattern(&mut self, node: &MatchNilPattern) -> T { ... }
    pub fn on_match_rest(&mut self, node: &MatchRest) -> T { ... }
    pub fn on_match_var(&mut self, node: &MatchVar) -> T { ... }
    pub fn on_match_with_lvasgn(&mut self, node: &MatchWithLvasgn) -> T { ... }
    pub fn on_mlhs(&mut self, node: &Mlhs) -> T { ... }
    pub fn on_module(&mut self, node: &Module) -> T { ... }
    pub fn on_next(&mut self, node: &Next) -> T { ... }
    pub fn on_nil(&mut self, node: &Nil) -> T { ... }
    pub fn on_nth_ref(&mut self, node: &NthRef) -> T { ... }
    pub fn on_numblock(&mut self, node: &Numblock) -> T { ... }
    pub fn on_op_asgn(&mut self, node: &OpAsgn) -> T { ... }
    pub fn on_optarg(&mut self, node: &Optarg) -> T { ... }
    pub fn on_or(&mut self, node: &Or) -> T { ... }
    pub fn on_or_asgn(&mut self, node: &OrAsgn) -> T { ... }
    pub fn on_pair(&mut self, node: &Pair) -> T { ... }
    pub fn on_pin(&mut self, node: &Pin) -> T { ... }
    pub fn on_postexe(&mut self, node: &Postexe) -> T { ... }
    pub fn on_preexe(&mut self, node: &Preexe) -> T { ... }
    pub fn on_procarg0(&mut self, node: &Procarg0) -> T { ... }
    pub fn on_rational(&mut self, node: &Rational) -> T { ... }
    pub fn on_redo(&mut self, node: &Redo) -> T { ... }
    pub fn on_regexp(&mut self, node: &Regexp) -> T { ... }
    pub fn on_regopt(&mut self, node: &RegOpt) -> T { ... }
    pub fn on_rescue(&mut self, node: &Rescue) -> T { ... }
    pub fn on_rescue_body(&mut self, node: &RescueBody) -> T { ... }
    pub fn on_restarg(&mut self, node: &Restarg) -> T { ... }
    pub fn on_retry(&mut self, node: &Retry) -> T { ... }
    pub fn on_return(&mut self, node: &Return) -> T { ... }
    pub fn on_sclass(&mut self, node: &SClass) -> T { ... }
    pub fn on_self_(&mut self, node: &Self_) -> T { ... }
    pub fn on_send(&mut self, node: &Send) -> T { ... }
    pub fn on_shadowarg(&mut self, node: &Shadowarg) -> T { ... }
    pub fn on_splat(&mut self, node: &Splat) -> T { ... }
    pub fn on_str(&mut self, node: &Str) -> T { ... }
    pub fn on_super(&mut self, node: &Super) -> T { ... }
    pub fn on_sym(&mut self, node: &Sym) -> T { ... }
    pub fn on_true(&mut self, node: &True) -> T { ... }
    pub fn on_undef(&mut self, node: &Undef) -> T { ... }
    pub fn on_unless_guard(&mut self, node: &UnlessGuard) -> T { ... }
    pub fn on_until(&mut self, node: &Until) -> T { ... }
    pub fn on_until_post(&mut self, node: &UntilPost) -> T { ... }
    pub fn on_when(&mut self, node: &When) -> T { ... }
    pub fn on_while(&mut self, node: &While) -> T { ... }
    pub fn on_while_post(&mut self, node: &WhilePost) -> T { ... }
    pub fn on_xheredoc(&mut self, node: &XHeredoc) -> T { ... }
    pub fn on_xstr(&mut self, node: &Xstr) -> T { ... }
    pub fn on_yield(&mut self, node: &Yield) -> T { ... }
    pub fn on_zsuper(&mut self, node: &ZSuper) -> T { ... }
    pub fn visit(&mut self, node: &Node) -> T { ... }
}