#[doc(hidden)]
#[macro_export]
macro_rules! __m2_syn_visit_methods {
() => {
fn visit_bng_eql(&mut self, node: &'ast Token![!=]) {
$crate::visit::visit_bng_eql(self, node);
}
fn visit_hsh(&mut self, node: &'ast Token![#]) {
$crate::visit::visit_hsh(self, node);
}
fn visit_hsh_qsm(&mut self, node: &'ast Token![#?]) {
$crate::visit::visit_hsh_qsm(self, node);
}
fn visit_mod(&mut self, node: &'ast Token![%]) {
$crate::visit::visit_mod(self, node);
}
fn visit_mod_eql(&mut self, node: &'ast Token![%=]) {
$crate::visit::visit_mod_eql(self, node);
}
fn visit_amp(&mut self, node: &'ast Token![&]) {
$crate::visit::visit_amp(self, node);
}
fn visit_amp_eql(&mut self, node: &'ast Token![&=]) {
$crate::visit::visit_amp_eql(self, node);
}
fn visit_mul(&mut self, node: &'ast Token![*]) {
$crate::visit::visit_mul(self, node);
}
fn visit_mul_eql(&mut self, node: &'ast Token![*=]) {
$crate::visit::visit_mul_eql(self, node);
}
fn visit_mul_mul(&mut self, node: &'ast Token![**]) {
$crate::visit::visit_mul_mul(self, node);
}
fn visit_mul_mul_eql(&mut self, node: &'ast Token![**=]) {
$crate::visit::visit_mul_mul_eql(self, node);
}
fn visit_add(&mut self, node: &'ast Token![+]) {
$crate::visit::visit_add(self, node);
}
fn visit_add_eql(&mut self, node: &'ast Token![+=]) {
$crate::visit::visit_add_eql(self, node);
}
fn visit_add_add(&mut self, node: &'ast Token![++]) {
$crate::visit::visit_add_add(self, node);
}
fn visit_add_add_eql(&mut self, node: &'ast Token![++=]) {
$crate::visit::visit_add_add_eql(self, node);
}
fn visit_sub(&mut self, node: &'ast Token![-]) {
$crate::visit::visit_sub(self, node);
}
fn visit_sub_eql(&mut self, node: &'ast Token![-=]) {
$crate::visit::visit_sub_eql(self, node);
}
fn visit_sub_gst(&mut self, node: &'ast Token![->]) {
$crate::visit::visit_sub_gst(self, node);
}
fn visit_dot(&mut self, node: &'ast Token![.]) {
$crate::visit::visit_dot(self, node);
}
fn visit_dot_dot(&mut self, node: &'ast Token![..]) {
$crate::visit::visit_dot_dot(self, node);
}
fn visit_dot_dot_eql(&mut self, node: &'ast Token![..=]) {
$crate::visit::visit_dot_dot_eql(self, node);
}
fn visit_dot_dot_lst(&mut self, node: &'ast Token![..<]) {
$crate::visit::visit_dot_dot_lst(self, node);
}
fn visit_dot_dot_lst_eql(&mut self, node: &'ast Token![..<=]) {
$crate::visit::visit_dot_dot_lst_eql(self, node);
}
fn visit_dot_qsm(&mut self, node: &'ast Token![.?]) {
$crate::visit::visit_dot_qsm(self, node);
}
fn visit_slh(&mut self, node: &'ast Token![/]) {
$crate::visit::visit_slh(self, node);
}
fn visit_slh_eql(&mut self, node: &'ast Token![/=]) {
$crate::visit::visit_slh_eql(self, node);
}
fn visit_slh_slh(&mut self, node: &'ast Token![/ /]) {
$crate::visit::visit_slh_slh(self, node);
}
fn visit_slh_slh_eql(&mut self, node: &'ast Token![/ /=]) {
$crate::visit::visit_slh_slh_eql(self, node);
}
fn visit_col(&mut self, node: &'ast Token![:]) {
$crate::visit::visit_col(self, node);
}
fn visit_col_eql(&mut self, node: &'ast Token![:=]) {
$crate::visit::visit_col_eql(self, node);
}
fn visit_lst(&mut self, node: &'ast Token![<]) {
$crate::visit::visit_lst(self, node);
}
fn visit_lst_sub(&mut self, node: &'ast Token![<-]) {
$crate::visit::visit_lst_sub(self, node);
}
fn visit_lst_lst(&mut self, node: &'ast Token![<<]) {
$crate::visit::visit_lst_lst(self, node);
}
fn visit_lst_lst_eql(&mut self, node: &'ast Token![<<=]) {
$crate::visit::visit_lst_lst_eql(self, node);
}
fn visit_lst_eql(&mut self, node: &'ast Token![<=]) {
$crate::visit::visit_lst_eql(self, node);
}
fn visit_lst_eql_eql(&mut self, node: &'ast Token![<==]) {
$crate::visit::visit_lst_eql_eql(self, node);
}
fn visit_lst_eql_eql_eql(&mut self, node: &'ast Token![<===]) {
$crate::visit::visit_lst_eql_eql_eql(self, node);
}
fn visit_lst_eql_eql_gst(&mut self, node: &'ast Token![<==>]) {
$crate::visit::visit_lst_eql_eql_gst(self, node);
}
fn visit_lst_eql_eql_gst_eql(&mut self, node: &'ast Token![<==>=]) {
$crate::visit::visit_lst_eql_eql_gst_eql(self, node);
}
fn visit_eql(&mut self, node: &'ast Token![=]) {
$crate::visit::visit_eql(self, node);
}
fn visit_eql_bng_eql(&mut self, node: &'ast Token![=!=]) {
$crate::visit::visit_eql_bng_eql(self, node);
}
fn visit_eql_eql(&mut self, node: &'ast Token![==]) {
$crate::visit::visit_eql_eql(self, node);
}
fn visit_eql_eql_eql(&mut self, node: &'ast Token![===]) {
$crate::visit::visit_eql_eql_eql(self, node);
}
fn visit_eql_eql_eql_gst(&mut self, node: &'ast Token![===>]) {
$crate::visit::visit_eql_eql_eql_gst(self, node);
}
fn visit_eql_eql_eql_gst_eql(&mut self, node: &'ast Token![===>=]) {
$crate::visit::visit_eql_eql_eql_gst_eql(self, node);
}
fn visit_eql_eql_gst(&mut self, node: &'ast Token![==>]) {
$crate::visit::visit_eql_eql_gst(self, node);
}
fn visit_eql_eql_gst_eql(&mut self, node: &'ast Token![==>=]) {
$crate::visit::visit_eql_eql_gst_eql(self, node);
}
fn visit_eql_gst(&mut self, node: &'ast Token![=>]) {
$crate::visit::visit_eql_gst(self, node);
}
fn visit_gst(&mut self, node: &'ast Token![>]) {
$crate::visit::visit_gst(self, node);
}
fn visit_gst_eql(&mut self, node: &'ast Token![>=]) {
$crate::visit::visit_gst_eql(self, node);
}
fn visit_gst_gst(&mut self, node: &'ast Token![>>]) {
$crate::visit::visit_gst_gst(self, node);
}
fn visit_gst_gst_eql(&mut self, node: &'ast Token![>>=]) {
$crate::visit::visit_gst_gst_eql(self, node);
}
fn visit_qsm(&mut self, node: &'ast Token![?]) {
$crate::visit::visit_qsm(self, node);
}
fn visit_qsm_qsm(&mut self, node: &'ast Token![??]) {
$crate::visit::visit_qsm_qsm(self, node);
}
fn visit_qsm_qsm_eql(&mut self, node: &'ast Token![??=]) {
$crate::visit::visit_qsm_qsm_eql(self, node);
}
fn visit_att(&mut self, node: &'ast Token![@]) {
$crate::visit::visit_att(self, node);
}
fn visit_att_eql(&mut self, node: &'ast Token![@=]) {
$crate::visit::visit_att_eql(self, node);
}
fn visit_att_att(&mut self, node: &'ast Token![@@]) {
$crate::visit::visit_att_att(self, node);
}
fn visit_att_att_eql(&mut self, node: &'ast Token![@@=]) {
$crate::visit::visit_att_att_eql(self, node);
}
fn visit_att_att_qsm(&mut self, node: &'ast Token![@@?]) {
$crate::visit::visit_att_att_qsm(self, node);
}
fn visit_att_att_qsm_eql(&mut self, node: &'ast Token![@@?=]) {
$crate::visit::visit_att_att_qsm_eql(self, node);
}
fn visit_bsl(&mut self, node: &'ast Token!["\\"]) {
$crate::visit::visit_bsl(self, node);
}
fn visit_bsl_eql(&mut self, node: &'ast Token!["\\="]) {
$crate::visit::visit_bsl_eql(self, node);
}
fn visit_bsl_bsl(&mut self, node: &'ast Token!["\\\\"]) {
$crate::visit::visit_bsl_bsl(self, node);
}
fn visit_bsl_bsl_eql(&mut self, node: &'ast Token!["\\\\="]) {
$crate::visit::visit_bsl_bsl_eql(self, node);
}
fn visit_crt(&mut self, node: &'ast Token![^]) {
$crate::visit::visit_crt(self, node);
}
fn visit_crt_eql(&mut self, node: &'ast Token![^=]) {
$crate::visit::visit_crt_eql(self, node);
}
fn visit_crt_mul_mul(&mut self, node: &'ast Token![^**]) {
$crate::visit::visit_crt_mul_mul(self, node);
}
fn visit_crt_mul_mul_eql(&mut self, node: &'ast Token![^**=]) {
$crate::visit::visit_crt_mul_mul_eql(self, node);
}
fn visit_crt_lst(&mut self, node: &'ast Token![^<]) {
$crate::visit::visit_crt_lst(self, node);
}
fn visit_crt_lst_eql(&mut self, node: &'ast Token![^<=]) {
$crate::visit::visit_crt_lst_eql(self, node);
}
fn visit_crt_gst(&mut self, node: &'ast Token![^>]) {
$crate::visit::visit_crt_gst(self, node);
}
fn visit_crt_gst_eql(&mut self, node: &'ast Token![^>=]) {
$crate::visit::visit_crt_gst_eql(self, node);
}
fn visit_crt_crt(&mut self, node: &'ast Token![^^]) {
$crate::visit::visit_crt_crt(self, node);
}
fn visit_crt_crt_eql(&mut self, node: &'ast Token![^^=]) {
$crate::visit::visit_crt_crt_eql(self, node);
}
fn visit_ubs(&mut self, node: &'ast Token![_]) {
$crate::visit::visit_ubs(self, node);
}
fn visit_ubs_eql(&mut self, node: &'ast Token![_=]) {
$crate::visit::visit_ubs_eql(self, node);
}
fn visit_ubs_lst(&mut self, node: &'ast Token![_<]) {
$crate::visit::visit_ubs_lst(self, node);
}
fn visit_ubs_lst_eql(&mut self, node: &'ast Token![_<=]) {
$crate::visit::visit_ubs_lst_eql(self, node);
}
fn visit_ubs_gst(&mut self, node: &'ast Token![_>]) {
$crate::visit::visit_ubs_gst(self, node);
}
fn visit_ubs_gst_eql(&mut self, node: &'ast Token![_>=]) {
$crate::visit::visit_ubs_gst_eql(self, node);
}
fn visit_pip(&mut self, node: &'ast Token![|]) {
$crate::visit::visit_pip(self, node);
}
fn visit_pip_eql(&mut self, node: &'ast Token![|=]) {
$crate::visit::visit_pip_eql(self, node);
}
fn visit_pip_sub(&mut self, node: &'ast Token![|-]) {
$crate::visit::visit_pip_sub(self, node);
}
fn visit_pip_sub_eql(&mut self, node: &'ast Token![|-=]) {
$crate::visit::visit_pip_sub_eql(self, node);
}
fn visit_pip_ubs(&mut self, node: &'ast Token![|_]) {
$crate::visit::visit_pip_ubs(self, node);
}
fn visit_pip_ubs_eql(&mut self, node: &'ast Token![|_=]) {
$crate::visit::visit_pip_ubs_eql(self, node);
}
fn visit_pip_pip(&mut self, node: &'ast Token![||]) {
$crate::visit::visit_pip_pip(self, node);
}
fn visit_pip_pip_eql(&mut self, node: &'ast Token![||=]) {
$crate::visit::visit_pip_pip_eql(self, node);
}
fn visit_tld(&mut self, node: &'ast Token![~]) {
$crate::visit::visit_tld(self, node);
}
fn visit_tld_eql(&mut self, node: &'ast Token![~=]) {
$crate::visit::visit_tld_eql(self, node);
}
fn visit_cdt(&mut self, node: &'ast Token!["·"]) {
$crate::visit::visit_cdt(self, node);
}
fn visit_cdt_eql(&mut self, node: &'ast Token!["·="]) {
$crate::visit::visit_cdt_eql(self, node);
}
fn visit_box(&mut self, node: &'ast Token!["⊠"]) {
$crate::visit::visit_box(self, node);
}
fn visit_box_eql(&mut self, node: &'ast Token!["⊠="]) {
$crate::visit::visit_box_eql(self, node);
}
fn visit_sfp(&mut self, node: &'ast Token!["⧢"]) {
$crate::visit::visit_sfp(self, node);
}
fn visit_sfp_eql(&mut self, node: &'ast Token!["⧢="]) {
$crate::visit::visit_sfp_eql(self, node);
}
fn visit_and(&mut self, node: &'ast Token![and]) {
$crate::visit::visit_and(self, node);
}
fn visit_or(&mut self, node: &'ast Token![or]) {
$crate::visit::visit_or(self, node);
}
fn visit_space(&mut self, node: &'ast Token![SPACE]) {
$crate::visit::visit_space(self, node);
}
fn visit_xor(&mut self, node: &'ast Token![xor]) {
$crate::visit::visit_xor(self, node);
}
fn visit_bng(&mut self, node: &'ast Token![!]) {
$crate::visit::visit_bng(self, node);
}
fn visit_graded(&mut self, node: &'ast Token![(*)]) {
$crate::visit::visit_graded(self, node);
}
fn visit_crt_bng(&mut self, node: &'ast Token![^!]) {
$crate::visit::visit_crt_bng(self, node);
}
fn visit_crt_mul(&mut self, node: &'ast Token![^*]) {
$crate::visit::visit_crt_mul(self, node);
}
fn visit_crt_tld(&mut self, node: &'ast Token![^~]) {
$crate::visit::visit_crt_tld(self, node);
}
fn visit_ubs_bng(&mut self, node: &'ast Token![_!]) {
$crate::visit::visit_ubs_bng(self, node);
}
fn visit_ubs_mul(&mut self, node: &'ast Token![_*]) {
$crate::visit::visit_ubs_mul(self, node);
}
fn visit_ubs_tld(&mut self, node: &'ast Token![_~]) {
$crate::visit::visit_ubs_tld(self, node);
}
fn visit_not(&mut self, node: &'ast Token![not]) {
$crate::visit::visit_not(self, node);
}
fn visit_break_keyword(&mut self, node: &'ast Token![break]) {
$crate::visit::visit_break_keyword(self, node);
}
fn visit_breakpoint_keyword(&mut self, node: &'ast Token![breakpoint]) {
$crate::visit::visit_breakpoint_keyword(self, node);
}
fn visit_catch_keyword(&mut self, node: &'ast Token![catch]) {
$crate::visit::visit_catch_keyword(self, node);
}
fn visit_continue_keyword(&mut self, node: &'ast Token![continue]) {
$crate::visit::visit_continue_keyword(self, node);
}
fn visit_do_keyword(&mut self, node: &'ast Token![do]) {
$crate::visit::visit_do_keyword(self, node);
}
fn visit_elapsed_time_keyword(&mut self, node: &'ast Token![elapsedTime]) {
$crate::visit::visit_elapsed_time_keyword(self, node);
}
fn visit_elapsed_timing_keyword(&mut self, node: &'ast Token![elapsedTiming]) {
$crate::visit::visit_elapsed_timing_keyword(self, node);
}
fn visit_else_keyword(&mut self, node: &'ast Token![else]) {
$crate::visit::visit_else_keyword(self, node);
}
fn visit_except_keyword(&mut self, node: &'ast Token![except]) {
$crate::visit::visit_except_keyword(self, node);
}
fn visit_finish_keyword(&mut self, node: &'ast Token![finish]) {
$crate::visit::visit_finish_keyword(self, node);
}
fn visit_for_keyword(&mut self, node: &'ast Token![for]) {
$crate::visit::visit_for_keyword(self, node);
}
fn visit_from_keyword(&mut self, node: &'ast Token![from]) {
$crate::visit::visit_from_keyword(self, node);
}
fn visit_global_keyword(&mut self, node: &'ast Token![global]) {
$crate::visit::visit_global_keyword(self, node);
}
fn visit_if_keyword(&mut self, node: &'ast Token![if]) {
$crate::visit::visit_if_keyword(self, node);
}
fn visit_in_keyword(&mut self, node: &'ast Token![in]) {
$crate::visit::visit_in_keyword(self, node);
}
fn visit_list_keyword(&mut self, node: &'ast Token![list]) {
$crate::visit::visit_list_keyword(self, node);
}
fn visit_local_keyword(&mut self, node: &'ast Token![local]) {
$crate::visit::visit_local_keyword(self, node);
}
fn visit_new_keyword(&mut self, node: &'ast Token![new]) {
$crate::visit::visit_new_keyword(self, node);
}
fn visit_of_keyword(&mut self, node: &'ast Token![of]) {
$crate::visit::visit_of_keyword(self, node);
}
fn visit_profile_keyword(&mut self, node: &'ast Token![profile]) {
$crate::visit::visit_profile_keyword(self, node);
}
fn visit_return_keyword(&mut self, node: &'ast Token![return]) {
$crate::visit::visit_return_keyword(self, node);
}
fn visit_shield_keyword(&mut self, node: &'ast Token![shield]) {
$crate::visit::visit_shield_keyword(self, node);
}
fn visit_step_keyword(&mut self, node: &'ast Token![step]) {
$crate::visit::visit_step_keyword(self, node);
}
fn visit_symbol_keyword(&mut self, node: &'ast Token![symbol]) {
$crate::visit::visit_symbol_keyword(self, node);
}
fn visit_test_keyword(&mut self, node: &'ast Token![TEST]) {
$crate::visit::visit_test_keyword(self, node);
}
fn visit_then_keyword(&mut self, node: &'ast Token![then]) {
$crate::visit::visit_then_keyword(self, node);
}
fn visit_thread_local_keyword(&mut self, node: &'ast Token![threadLocal]) {
$crate::visit::visit_thread_local_keyword(self, node);
}
fn visit_thread_variable_keyword(&mut self, node: &'ast Token![threadVariable]) {
$crate::visit::visit_thread_variable_keyword(self, node);
}
fn visit_throw_keyword(&mut self, node: &'ast Token![throw]) {
$crate::visit::visit_throw_keyword(self, node);
}
fn visit_time_keyword(&mut self, node: &'ast Token![time]) {
$crate::visit::visit_time_keyword(self, node);
}
fn visit_timing_keyword(&mut self, node: &'ast Token![timing]) {
$crate::visit::visit_timing_keyword(self, node);
}
fn visit_to_keyword(&mut self, node: &'ast Token![to]) {
$crate::visit::visit_to_keyword(self, node);
}
fn visit_trap_keyword(&mut self, node: &'ast Token![trap]) {
$crate::visit::visit_trap_keyword(self, node);
}
fn visit_try_keyword(&mut self, node: &'ast Token![try]) {
$crate::visit::visit_try_keyword(self, node);
}
fn visit_when_keyword(&mut self, node: &'ast Token![when]) {
$crate::visit::visit_when_keyword(self, node);
}
fn visit_while_keyword(&mut self, node: &'ast Token![while]) {
$crate::visit::visit_while_keyword(self, node);
}
fn visit_scl(&mut self, node: &'ast Token![;]) {
$crate::visit::visit_scl(self, node);
}
fn visit_cma(&mut self, node: &'ast Token![,]) {
$crate::visit::visit_cma(self, node);
}
fn visit_symbol(&mut self, node: &'ast Symbol) {
$crate::visit::visit_symbol(self, node);
}
fn visit_block_comment(&mut self, node: &'ast BlockComment) {
$crate::visit::visit_block_comment(self, node);
}
fn visit_line_comment(&mut self, node: &'ast LineComment) {
$crate::visit::visit_line_comment(self, node);
}
fn visit_empty_component(&mut self, node: &'ast EmptyComponent) {
$crate::visit::visit_empty_component(self, node);
}
fn visit_escape_sequence(&mut self, node: &'ast EscapeSequence) {
$crate::visit::visit_escape_sequence(self, node);
}
fn visit_float_literal(&mut self, node: &'ast FloatLiteral) {
$crate::visit::visit_float_literal(self, node);
}
fn visit_integer_literal(&mut self, node: &'ast IntegerLiteral) {
$crate::visit::visit_integer_literal(self, node);
}
fn visit_raw_string_content(&mut self, node: &'ast RawStringContent) {
$crate::visit::visit_raw_string_content(self, node);
}
fn visit_string_content(&mut self, node: &'ast StringContent) {
$crate::visit::visit_string_content(self, node);
}
fn visit_source_file(&mut self, node: &'ast SourceFile) {
$crate::visit::visit_source_file(self, node);
}
fn visit_expression_cell(&mut self, node: &'ast ExpressionCell) {
$crate::visit::visit_expression_cell(self, node);
}
fn visit_sequence_cell(&mut self, node: &'ast SequenceCell) {
$crate::visit::visit_sequence_cell(self, node);
}
fn visit_naked_sequence(&mut self, node: &'ast NakedSequence) {
$crate::visit::visit_naked_sequence(self, node);
}
fn visit_muted_cell(&mut self, node: &'ast MutedCell) {
$crate::visit::visit_muted_cell(self, node);
}
fn visit_muted_group(&mut self, node: &'ast MutedGroup) {
$crate::visit::visit_muted_group(self, node);
}
fn visit_array(&mut self, node: &'ast Array) {
$crate::visit::visit_array(self, node);
}
fn visit_list(&mut self, node: &'ast List) {
$crate::visit::visit_list(self, node);
}
fn visit_angle_bar_list(&mut self, node: &'ast AngleBarList) {
$crate::visit::visit_angle_bar_list(self, node);
}
fn visit_sequence(&mut self, node: &'ast Sequence) {
$crate::visit::visit_sequence(self, node);
}
fn visit_parenthesized_expression(&mut self, node: &'ast ParenthesizedExpression) {
$crate::visit::visit_parenthesized_expression(self, node);
}
fn visit_string_literal(&mut self, node: &'ast StringLiteral) {
$crate::visit::visit_string_literal(self, node);
}
fn visit_raw_string_literal(&mut self, node: &'ast RawStringLiteral) {
$crate::visit::visit_raw_string_literal(self, node);
}
fn visit_binary_expression(&mut self, node: &'ast BinaryExpression) {
$crate::visit::visit_binary_expression(self, node);
}
fn visit_adjacent_expression(&mut self, node: &'ast AdjacentExpression) {
$crate::visit::visit_adjacent_expression(self, node);
}
fn visit_prefix_expression(&mut self, node: &'ast PrefixExpression) {
$crate::visit::visit_prefix_expression(self, node);
}
fn visit_postfix_expression(&mut self, node: &'ast PostfixExpression) {
$crate::visit::visit_postfix_expression(self, node);
}
fn visit_lambda_expression(&mut self, node: &'ast LambdaExpression) {
$crate::visit::visit_lambda_expression(self, node);
}
fn visit_assignment(&mut self, node: &'ast Assignment) {
$crate::visit::visit_assignment(self, node);
}
fn visit_local_assignment(&mut self, node: &'ast LocalAssignment) {
$crate::visit::visit_local_assignment(self, node);
}
fn visit_binary_assignment(&mut self, node: &'ast BinaryAssignment) {
$crate::visit::visit_binary_assignment(self, node);
}
fn visit_binary_installation(&mut self, node: &'ast BinaryInstallation) {
$crate::visit::visit_binary_installation(self, node);
}
fn visit_prefix_assignment(&mut self, node: &'ast PrefixAssignment) {
$crate::visit::visit_prefix_assignment(self, node);
}
fn visit_prefix_installation(&mut self, node: &'ast PrefixInstallation) {
$crate::visit::visit_prefix_installation(self, node);
}
fn visit_postfix_assignment(&mut self, node: &'ast PostfixAssignment) {
$crate::visit::visit_postfix_assignment(self, node);
}
fn visit_postfix_installation(&mut self, node: &'ast PostfixInstallation) {
$crate::visit::visit_postfix_installation(self, node);
}
fn visit_structured_binding(&mut self, node: &'ast StructuredBinding) {
$crate::visit::visit_structured_binding(self, node);
}
fn visit_local_structured_binding(&mut self, node: &'ast LocalStructuredBinding) {
$crate::visit::visit_local_structured_binding(self, node);
}
fn visit_evaluated_assignment(&mut self, node: &'ast EvaluatedAssignment) {
$crate::visit::visit_evaluated_assignment(self, node);
}
fn visit_option_expression(&mut self, node: &'ast OptionExpression) {
$crate::visit::visit_option_expression(self, node);
}
fn visit_then_clause(&mut self, node: &'ast ThenClause) {
$crate::visit::visit_then_clause(self, node);
}
fn visit_else_clause(&mut self, node: &'ast ElseClause) {
$crate::visit::visit_else_clause(self, node);
}
fn visit_if_statement(&mut self, node: &'ast IfStatement) {
$crate::visit::visit_if_statement(self, node);
}
fn visit_loop_body(&mut self, node: &'ast LoopBody) {
$crate::visit::visit_loop_body(self, node);
}
fn visit_iteration_range(&mut self, node: &'ast IterationRange) {
$crate::visit::visit_iteration_range(self, node);
}
fn visit_for_loop(&mut self, node: &'ast ForLoop) {
$crate::visit::visit_for_loop(self, node);
}
fn visit_while_loop(&mut self, node: &'ast WhileLoop) {
$crate::visit::visit_while_loop(self, node);
}
fn visit_new_statement(&mut self, node: &'ast NewStatement) {
$crate::visit::visit_new_statement(self, node);
}
fn visit_debug_clause(&mut self, node: &'ast DebugClause) {
$crate::visit::visit_debug_clause(self, node);
}
fn visit_break_statement(&mut self, node: &'ast BreakStatement) {
$crate::visit::visit_break_statement(self, node);
}
fn visit_continue_statement(&mut self, node: &'ast ContinueStatement) {
$crate::visit::visit_continue_statement(self, node);
}
fn visit_return_statement(&mut self, node: &'ast ReturnStatement) {
$crate::visit::visit_return_statement(self, node);
}
fn visit_catch_statement(&mut self, node: &'ast CatchStatement) {
$crate::visit::visit_catch_statement(self, node);
}
fn visit_throw_statement(&mut self, node: &'ast ThrowStatement) {
$crate::visit::visit_throw_statement(self, node);
}
fn visit_trap_statement(&mut self, node: &'ast TrapStatement) {
$crate::visit::visit_trap_statement(self, node);
}
fn visit_except_clause(&mut self, node: &'ast ExceptClause) {
$crate::visit::visit_except_clause(self, node);
}
fn visit_try_statement(&mut self, node: &'ast TryStatement) {
$crate::visit::visit_try_statement(self, node);
}
fn visit_quote_expression(&mut self, node: &'ast QuoteExpression) {
$crate::visit::visit_quote_expression(self, node);
}
fn visit_prefix_operator(&mut self, node: &'ast PrefixOperator) {
$crate::visit::visit_prefix_operator(self, node);
}
fn visit_binary_operator(&mut self, node: &'ast BinaryOperator) {
$crate::visit::visit_binary_operator(self, node);
}
fn visit_postfix_operator(&mut self, node: &'ast PostfixOperator) {
$crate::visit::visit_postfix_operator(self, node);
}
fn visit_debug_keyword(&mut self, node: &'ast DebugKeyword) {
$crate::visit::visit_debug_keyword(self, node);
}
fn visit_try_fallback(&mut self, node: &'ast TryFallback) {
$crate::visit::visit_try_fallback(self, node);
}
fn visit_quote_specifier(&mut self, node: &'ast QuoteSpecifier) {
$crate::visit::visit_quote_specifier(self, node);
}
fn visit_any_cell(&mut self, node: &'ast AnyCell) {
$crate::visit::visit_any_cell(self, node);
}
fn visit_component(&mut self, node: &'ast Component) {
$crate::visit::visit_component(self, node);
}
fn visit_sequence_element(&mut self, node: &'ast SequenceElement) {
$crate::visit::visit_sequence_element(self, node);
}
fn visit_string_element(&mut self, node: &'ast StringElement) {
$crate::visit::visit_string_element(self, node);
}
fn visit_raw_string_element(&mut self, node: &'ast RawStringElement) {
$crate::visit::visit_raw_string_element(self, node);
}
fn visit_collection(&mut self, node: &'ast Collection) {
$crate::visit::visit_collection(self, node);
}
fn visit_binding_pack(&mut self, node: &'ast BindingPack) {
$crate::visit::visit_binding_pack(self, node);
}
fn visit_lambda_parameters(&mut self, node: &'ast LambdaParameters) {
$crate::visit::visit_lambda_parameters(self, node);
}
fn visit_operator_expr(&mut self, node: &'ast OperatorExpr) {
$crate::visit::visit_operator_expr(self, node);
}
fn visit_assignment_expr(&mut self, node: &'ast AssignmentExpr) {
$crate::visit::visit_assignment_expr(self, node);
}
fn visit_expr(&mut self, node: &'ast Expr) {
$crate::visit::visit_expr(self, node);
}
fn visit_syntax_node(&mut self, node: &'ast SyntaxNode) {
$crate::visit::visit_syntax_node(self, node);
}
};
}
#[doc(hidden)]
#[macro_export]
macro_rules! __m2_syn_visit_walkers {
() => {
pub fn visit_bng_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![!=])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_hsh<'ast, V>(_visitor: &mut V, _node: &'ast Token![#])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_hsh_qsm<'ast, V>(_visitor: &mut V, _node: &'ast Token![#?])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_mod<'ast, V>(_visitor: &mut V, _node: &'ast Token![%])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_mod_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![%=])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_amp<'ast, V>(_visitor: &mut V, _node: &'ast Token![&])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_amp_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![&=])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_mul<'ast, V>(_visitor: &mut V, _node: &'ast Token![*])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_mul_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![*=])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_mul_mul<'ast, V>(_visitor: &mut V, _node: &'ast Token![**])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_mul_mul_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![**=])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_add<'ast, V>(_visitor: &mut V, _node: &'ast Token![+])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_add_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![+=])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_add_add<'ast, V>(_visitor: &mut V, _node: &'ast Token![++])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_add_add_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![++=])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_sub<'ast, V>(_visitor: &mut V, _node: &'ast Token![-])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_sub_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![-=])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_sub_gst<'ast, V>(_visitor: &mut V, _node: &'ast Token![->])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_dot<'ast, V>(_visitor: &mut V, _node: &'ast Token![.])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_dot_dot<'ast, V>(_visitor: &mut V, _node: &'ast Token![..])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_dot_dot_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![..=])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_dot_dot_lst<'ast, V>(_visitor: &mut V, _node: &'ast Token![..<])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_dot_dot_lst_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![..<=])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_dot_qsm<'ast, V>(_visitor: &mut V, _node: &'ast Token![.?])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_slh<'ast, V>(_visitor: &mut V, _node: &'ast Token![/])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_slh_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![/=])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_slh_slh<'ast, V>(_visitor: &mut V, _node: &'ast Token![/ /])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_slh_slh_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![/ /=])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_col<'ast, V>(_visitor: &mut V, _node: &'ast Token![:])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_col_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![:=])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_lst<'ast, V>(_visitor: &mut V, _node: &'ast Token![<])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_lst_sub<'ast, V>(_visitor: &mut V, _node: &'ast Token![<-])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_lst_lst<'ast, V>(_visitor: &mut V, _node: &'ast Token![<<])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_lst_lst_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![<<=])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_lst_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![<=])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_lst_eql_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![<==])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_lst_eql_eql_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![<===])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_lst_eql_eql_gst<'ast, V>(_visitor: &mut V, _node: &'ast Token![<==>])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_lst_eql_eql_gst_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![<==>=])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![=])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_eql_bng_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![=!=])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_eql_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![==])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_eql_eql_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![===])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_eql_eql_eql_gst<'ast, V>(_visitor: &mut V, _node: &'ast Token![===>])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_eql_eql_eql_gst_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![===>=])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_eql_eql_gst<'ast, V>(_visitor: &mut V, _node: &'ast Token![==>])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_eql_eql_gst_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![==>=])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_eql_gst<'ast, V>(_visitor: &mut V, _node: &'ast Token![=>])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_gst<'ast, V>(_visitor: &mut V, _node: &'ast Token![>])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_gst_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![>=])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_gst_gst<'ast, V>(_visitor: &mut V, _node: &'ast Token![>>])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_gst_gst_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![>>=])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_qsm<'ast, V>(_visitor: &mut V, _node: &'ast Token![?])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_qsm_qsm<'ast, V>(_visitor: &mut V, _node: &'ast Token![??])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_qsm_qsm_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![??=])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_att<'ast, V>(_visitor: &mut V, _node: &'ast Token![@])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_att_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![@=])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_att_att<'ast, V>(_visitor: &mut V, _node: &'ast Token![@@])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_att_att_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![@@=])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_att_att_qsm<'ast, V>(_visitor: &mut V, _node: &'ast Token![@@?])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_att_att_qsm_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![@@?=])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_bsl<'ast, V>(_visitor: &mut V, _node: &'ast Token!["\\"])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_bsl_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token!["\\="])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_bsl_bsl<'ast, V>(_visitor: &mut V, _node: &'ast Token!["\\\\"])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_bsl_bsl_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token!["\\\\="])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_crt<'ast, V>(_visitor: &mut V, _node: &'ast Token![^])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_crt_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![^=])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_crt_mul_mul<'ast, V>(_visitor: &mut V, _node: &'ast Token![^**])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_crt_mul_mul_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![^**=])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_crt_lst<'ast, V>(_visitor: &mut V, _node: &'ast Token![^<])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_crt_lst_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![^<=])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_crt_gst<'ast, V>(_visitor: &mut V, _node: &'ast Token![^>])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_crt_gst_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![^>=])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_crt_crt<'ast, V>(_visitor: &mut V, _node: &'ast Token![^^])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_crt_crt_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![^^=])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_ubs<'ast, V>(_visitor: &mut V, _node: &'ast Token![_])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_ubs_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![_=])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_ubs_lst<'ast, V>(_visitor: &mut V, _node: &'ast Token![_<])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_ubs_lst_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![_<=])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_ubs_gst<'ast, V>(_visitor: &mut V, _node: &'ast Token![_>])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_ubs_gst_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![_>=])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_pip<'ast, V>(_visitor: &mut V, _node: &'ast Token![|])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_pip_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![|=])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_pip_sub<'ast, V>(_visitor: &mut V, _node: &'ast Token![|-])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_pip_sub_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![|-=])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_pip_ubs<'ast, V>(_visitor: &mut V, _node: &'ast Token![|_])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_pip_ubs_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![|_=])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_pip_pip<'ast, V>(_visitor: &mut V, _node: &'ast Token![||])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_pip_pip_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![||=])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_tld<'ast, V>(_visitor: &mut V, _node: &'ast Token![~])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_tld_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token![~=])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_cdt<'ast, V>(_visitor: &mut V, _node: &'ast Token!["·"])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_cdt_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token!["·="])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_box<'ast, V>(_visitor: &mut V, _node: &'ast Token!["⊠"])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_box_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token!["⊠="])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_sfp<'ast, V>(_visitor: &mut V, _node: &'ast Token!["⧢"])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_sfp_eql<'ast, V>(_visitor: &mut V, _node: &'ast Token!["⧢="])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_and<'ast, V>(_visitor: &mut V, _node: &'ast Token![and])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_or<'ast, V>(_visitor: &mut V, _node: &'ast Token![or])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_space<'ast, V>(_visitor: &mut V, _node: &'ast Token![SPACE])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_xor<'ast, V>(_visitor: &mut V, _node: &'ast Token![xor])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_bng<'ast, V>(_visitor: &mut V, _node: &'ast Token![!])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_graded<'ast, V>(_visitor: &mut V, _node: &'ast Token![(*)])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_crt_bng<'ast, V>(_visitor: &mut V, _node: &'ast Token![^!])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_crt_mul<'ast, V>(_visitor: &mut V, _node: &'ast Token![^*])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_crt_tld<'ast, V>(_visitor: &mut V, _node: &'ast Token![^~])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_ubs_bng<'ast, V>(_visitor: &mut V, _node: &'ast Token![_!])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_ubs_mul<'ast, V>(_visitor: &mut V, _node: &'ast Token![_*])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_ubs_tld<'ast, V>(_visitor: &mut V, _node: &'ast Token![_~])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_not<'ast, V>(_visitor: &mut V, _node: &'ast Token![not])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_break_keyword<'ast, V>(_visitor: &mut V, _node: &'ast Token![break])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_breakpoint_keyword<'ast, V>(_visitor: &mut V, _node: &'ast Token![breakpoint])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_catch_keyword<'ast, V>(_visitor: &mut V, _node: &'ast Token![catch])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_continue_keyword<'ast, V>(_visitor: &mut V, _node: &'ast Token![continue])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_do_keyword<'ast, V>(_visitor: &mut V, _node: &'ast Token![do])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_elapsed_time_keyword<'ast, V>(
_visitor: &mut V,
_node: &'ast Token![elapsedTime],
) where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_elapsed_timing_keyword<'ast, V>(
_visitor: &mut V,
_node: &'ast Token![elapsedTiming],
) where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_else_keyword<'ast, V>(_visitor: &mut V, _node: &'ast Token![else])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_except_keyword<'ast, V>(_visitor: &mut V, _node: &'ast Token![except])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_finish_keyword<'ast, V>(_visitor: &mut V, _node: &'ast Token![finish])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_for_keyword<'ast, V>(_visitor: &mut V, _node: &'ast Token![for])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_from_keyword<'ast, V>(_visitor: &mut V, _node: &'ast Token![from])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_global_keyword<'ast, V>(_visitor: &mut V, _node: &'ast Token![global])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_if_keyword<'ast, V>(_visitor: &mut V, _node: &'ast Token![if])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_in_keyword<'ast, V>(_visitor: &mut V, _node: &'ast Token![in])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_list_keyword<'ast, V>(_visitor: &mut V, _node: &'ast Token![list])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_local_keyword<'ast, V>(_visitor: &mut V, _node: &'ast Token![local])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_new_keyword<'ast, V>(_visitor: &mut V, _node: &'ast Token![new])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_of_keyword<'ast, V>(_visitor: &mut V, _node: &'ast Token![of])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_profile_keyword<'ast, V>(_visitor: &mut V, _node: &'ast Token![profile])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_return_keyword<'ast, V>(_visitor: &mut V, _node: &'ast Token![return])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_shield_keyword<'ast, V>(_visitor: &mut V, _node: &'ast Token![shield])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_step_keyword<'ast, V>(_visitor: &mut V, _node: &'ast Token![step])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_symbol_keyword<'ast, V>(_visitor: &mut V, _node: &'ast Token![symbol])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_test_keyword<'ast, V>(_visitor: &mut V, _node: &'ast Token![TEST])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_then_keyword<'ast, V>(_visitor: &mut V, _node: &'ast Token![then])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_thread_local_keyword<'ast, V>(
_visitor: &mut V,
_node: &'ast Token![threadLocal],
) where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_thread_variable_keyword<'ast, V>(
_visitor: &mut V,
_node: &'ast Token![threadVariable],
) where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_throw_keyword<'ast, V>(_visitor: &mut V, _node: &'ast Token![throw])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_time_keyword<'ast, V>(_visitor: &mut V, _node: &'ast Token![time])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_timing_keyword<'ast, V>(_visitor: &mut V, _node: &'ast Token![timing])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_to_keyword<'ast, V>(_visitor: &mut V, _node: &'ast Token![to])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_trap_keyword<'ast, V>(_visitor: &mut V, _node: &'ast Token![trap])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_try_keyword<'ast, V>(_visitor: &mut V, _node: &'ast Token![try])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_when_keyword<'ast, V>(_visitor: &mut V, _node: &'ast Token![when])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_while_keyword<'ast, V>(_visitor: &mut V, _node: &'ast Token![while])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_scl<'ast, V>(_visitor: &mut V, _node: &'ast Token![;])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_cma<'ast, V>(_visitor: &mut V, _node: &'ast Token![,])
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_symbol<'ast, V>(_visitor: &mut V, _node: &'ast Symbol)
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_block_comment<'ast, V>(_visitor: &mut V, _node: &'ast BlockComment)
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_line_comment<'ast, V>(_visitor: &mut V, _node: &'ast LineComment)
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_empty_component<'ast, V>(_visitor: &mut V, _node: &'ast EmptyComponent)
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_escape_sequence<'ast, V>(_visitor: &mut V, _node: &'ast EscapeSequence)
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_float_literal<'ast, V>(_visitor: &mut V, _node: &'ast FloatLiteral)
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_integer_literal<'ast, V>(_visitor: &mut V, _node: &'ast IntegerLiteral)
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_raw_string_content<'ast, V>(_visitor: &mut V, _node: &'ast RawStringContent)
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_string_content<'ast, V>(_visitor: &mut V, _node: &'ast StringContent)
where
V: Visit<'ast> + ?Sized,
{
}
pub fn visit_source_file<'ast, V>(visitor: &mut V, node: &'ast SourceFile)
where
V: Visit<'ast> + ?Sized,
{
for value in &node.elements {
visitor.visit_any_cell(value);
}
}
pub fn visit_expression_cell<'ast, V>(visitor: &mut V, node: &'ast ExpressionCell)
where
V: Visit<'ast> + ?Sized,
{
visitor.visit_expr((&node.value).as_ref());
}
pub fn visit_sequence_cell<'ast, V>(visitor: &mut V, node: &'ast SequenceCell)
where
V: Visit<'ast> + ?Sized,
{
visitor.visit_naked_sequence((&node.value).as_ref());
}
pub fn visit_naked_sequence<'ast, V>(visitor: &mut V, node: &'ast NakedSequence)
where
V: Visit<'ast> + ?Sized,
{
for value in &node.elements {
visitor.visit_component(value);
}
}
pub fn visit_muted_cell<'ast, V>(visitor: &mut V, node: &'ast MutedCell)
where
V: Visit<'ast> + ?Sized,
{
for value in &node.elements {
visitor.visit_component(value);
}
visitor.visit_scl(&node.semicolon);
}
pub fn visit_muted_group<'ast, V>(visitor: &mut V, node: &'ast MutedGroup)
where
V: Visit<'ast> + ?Sized,
{
for value in &node.elements {
visitor.visit_component(value);
}
visitor.visit_scl(&node.semicolon);
}
pub fn visit_array<'ast, V>(visitor: &mut V, node: &'ast Array)
where
V: Visit<'ast> + ?Sized,
{
for value in &node.muted {
visitor.visit_muted_group(value);
}
for value in &node.elements {
visitor.visit_component(value);
}
}
pub fn visit_list<'ast, V>(visitor: &mut V, node: &'ast List)
where
V: Visit<'ast> + ?Sized,
{
for value in &node.muted {
visitor.visit_muted_group(value);
}
for value in &node.elements {
visitor.visit_component(value);
}
}
pub fn visit_angle_bar_list<'ast, V>(visitor: &mut V, node: &'ast AngleBarList)
where
V: Visit<'ast> + ?Sized,
{
for value in &node.muted {
visitor.visit_muted_group(value);
}
for value in &node.elements {
visitor.visit_component(value);
}
}
pub fn visit_sequence<'ast, V>(visitor: &mut V, node: &'ast Sequence)
where
V: Visit<'ast> + ?Sized,
{
for value in &node.muted {
visitor.visit_muted_group(value);
}
for value in &node.elements {
visitor.visit_component(value);
}
}
pub fn visit_parenthesized_expression<'ast, V>(
visitor: &mut V,
node: &'ast ParenthesizedExpression,
) where
V: Visit<'ast> + ?Sized,
{
for value in &node.muted {
visitor.visit_muted_group(value);
}
if let Some(value) = (&node.value).as_ref() {
visitor.visit_expr((value).as_ref());
}
}
pub fn visit_string_literal<'ast, V>(visitor: &mut V, node: &'ast StringLiteral)
where
V: Visit<'ast> + ?Sized,
{
for value in &node.elements {
visitor.visit_string_element(value);
}
}
pub fn visit_raw_string_literal<'ast, V>(visitor: &mut V, node: &'ast RawStringLiteral)
where
V: Visit<'ast> + ?Sized,
{
for value in &node.elements {
visitor.visit_raw_string_element(value);
}
}
pub fn visit_binary_expression<'ast, V>(visitor: &mut V, node: &'ast BinaryExpression)
where
V: Visit<'ast> + ?Sized,
{
visitor.visit_expr((&node.left).as_ref());
visitor.visit_binary_operator(&node.operator);
visitor.visit_expr((&node.right).as_ref());
}
pub fn visit_adjacent_expression<'ast, V>(visitor: &mut V, node: &'ast AdjacentExpression)
where
V: Visit<'ast> + ?Sized,
{
visitor.visit_expr((&node.left).as_ref());
visitor.visit_expr((&node.right).as_ref());
}
pub fn visit_prefix_expression<'ast, V>(visitor: &mut V, node: &'ast PrefixExpression)
where
V: Visit<'ast> + ?Sized,
{
visitor.visit_prefix_operator(&node.operator);
visitor.visit_expr((&node.operand).as_ref());
}
pub fn visit_postfix_expression<'ast, V>(visitor: &mut V, node: &'ast PostfixExpression)
where
V: Visit<'ast> + ?Sized,
{
visitor.visit_expr((&node.operand).as_ref());
visitor.visit_postfix_operator(&node.operator);
}
pub fn visit_lambda_expression<'ast, V>(visitor: &mut V, node: &'ast LambdaExpression)
where
V: Visit<'ast> + ?Sized,
{
visitor.visit_lambda_parameters((&node.parameters).as_ref());
visitor.visit_sub_gst(&node.operator);
visitor.visit_expr((&node.body).as_ref());
}
pub fn visit_assignment<'ast, V>(visitor: &mut V, node: &'ast Assignment)
where
V: Visit<'ast> + ?Sized,
{
visitor.visit_symbol((&node.left).as_ref());
visitor.visit_eql(&node.operator);
visitor.visit_expr((&node.right).as_ref());
}
pub fn visit_local_assignment<'ast, V>(visitor: &mut V, node: &'ast LocalAssignment)
where
V: Visit<'ast> + ?Sized,
{
visitor.visit_symbol((&node.left).as_ref());
visitor.visit_col_eql(&node.operator);
visitor.visit_expr((&node.right).as_ref());
}
pub fn visit_binary_assignment<'ast, V>(visitor: &mut V, node: &'ast BinaryAssignment)
where
V: Visit<'ast> + ?Sized,
{
visitor.visit_binary_expression((&node.left).as_ref());
visitor.visit_eql(&node.operator);
visitor.visit_expr((&node.right).as_ref());
}
pub fn visit_binary_installation<'ast, V>(visitor: &mut V, node: &'ast BinaryInstallation)
where
V: Visit<'ast> + ?Sized,
{
visitor.visit_binary_expression((&node.left).as_ref());
visitor.visit_col_eql(&node.operator);
visitor.visit_expr((&node.right).as_ref());
}
pub fn visit_prefix_assignment<'ast, V>(visitor: &mut V, node: &'ast PrefixAssignment)
where
V: Visit<'ast> + ?Sized,
{
visitor.visit_prefix_expression((&node.left).as_ref());
visitor.visit_eql(&node.operator);
visitor.visit_expr((&node.right).as_ref());
}
pub fn visit_prefix_installation<'ast, V>(visitor: &mut V, node: &'ast PrefixInstallation)
where
V: Visit<'ast> + ?Sized,
{
visitor.visit_prefix_expression((&node.left).as_ref());
visitor.visit_col_eql(&node.operator);
visitor.visit_expr((&node.right).as_ref());
}
pub fn visit_postfix_assignment<'ast, V>(visitor: &mut V, node: &'ast PostfixAssignment)
where
V: Visit<'ast> + ?Sized,
{
visitor.visit_postfix_expression((&node.left).as_ref());
visitor.visit_eql(&node.operator);
visitor.visit_expr((&node.right).as_ref());
}
pub fn visit_postfix_installation<'ast, V>(visitor: &mut V, node: &'ast PostfixInstallation)
where
V: Visit<'ast> + ?Sized,
{
visitor.visit_postfix_expression((&node.left).as_ref());
visitor.visit_col_eql(&node.operator);
visitor.visit_expr((&node.right).as_ref());
}
pub fn visit_structured_binding<'ast, V>(visitor: &mut V, node: &'ast StructuredBinding)
where
V: Visit<'ast> + ?Sized,
{
visitor.visit_binding_pack((&node.binding_pack).as_ref());
visitor.visit_eql(&node.operator);
visitor.visit_expr((&node.right).as_ref());
}
pub fn visit_local_structured_binding<'ast, V>(
visitor: &mut V,
node: &'ast LocalStructuredBinding,
) where
V: Visit<'ast> + ?Sized,
{
visitor.visit_binding_pack((&node.binding_pack).as_ref());
visitor.visit_col_eql(&node.operator);
visitor.visit_expr((&node.right).as_ref());
}
pub fn visit_evaluated_assignment<'ast, V>(visitor: &mut V, node: &'ast EvaluatedAssignment)
where
V: Visit<'ast> + ?Sized,
{
visitor.visit_expr((&node.left).as_ref());
visitor.visit_lst_sub(&node.operator);
visitor.visit_expr((&node.right).as_ref());
}
pub fn visit_option_expression<'ast, V>(visitor: &mut V, node: &'ast OptionExpression)
where
V: Visit<'ast> + ?Sized,
{
visitor.visit_expr((&node.left).as_ref());
visitor.visit_eql_gst(&node.operator);
visitor.visit_expr((&node.right).as_ref());
}
pub fn visit_then_clause<'ast, V>(visitor: &mut V, node: &'ast ThenClause)
where
V: Visit<'ast> + ?Sized,
{
visitor.visit_then_keyword(&node.keyword);
visitor.visit_expr((&node.value).as_ref());
}
pub fn visit_else_clause<'ast, V>(visitor: &mut V, node: &'ast ElseClause)
where
V: Visit<'ast> + ?Sized,
{
visitor.visit_else_keyword(&node.keyword);
visitor.visit_expr((&node.value).as_ref());
}
pub fn visit_if_statement<'ast, V>(visitor: &mut V, node: &'ast IfStatement)
where
V: Visit<'ast> + ?Sized,
{
visitor.visit_if_keyword(&node.keyword);
visitor.visit_expr((&node.condition).as_ref());
visitor.visit_then_clause((&node.then_clause).as_ref());
if let Some(value) = (&node.else_clause).as_ref() {
visitor.visit_else_clause((value).as_ref());
}
}
pub fn visit_loop_body<'ast, V>(visitor: &mut V, node: &'ast LoopBody)
where
V: Visit<'ast> + ?Sized,
{
if let Some(value) = (&node.list_keyword).as_ref() {
visitor.visit_list_keyword(value);
}
if let Some(value) = (&node.listed_value).as_ref() {
visitor.visit_expr((value).as_ref());
}
if let Some(value) = (&node.do_keyword).as_ref() {
visitor.visit_do_keyword(value);
}
if let Some(value) = (&node.ignored_value).as_ref() {
visitor.visit_expr((value).as_ref());
}
}
pub fn visit_iteration_range<'ast, V>(visitor: &mut V, node: &'ast IterationRange)
where
V: Visit<'ast> + ?Sized,
{
if let Some(value) = (&node.in_keyword).as_ref() {
visitor.visit_in_keyword(value);
}
if let Some(value) = (&node.iterated_collection).as_ref() {
visitor.visit_expr((value).as_ref());
}
if let Some(value) = (&node.from_keyword).as_ref() {
visitor.visit_from_keyword(value);
}
if let Some(value) = (&node.range_start).as_ref() {
visitor.visit_expr((value).as_ref());
}
if let Some(value) = (&node.to_keyword).as_ref() {
visitor.visit_to_keyword(value);
}
if let Some(value) = (&node.range_end).as_ref() {
visitor.visit_expr((value).as_ref());
}
}
pub fn visit_for_loop<'ast, V>(visitor: &mut V, node: &'ast ForLoop)
where
V: Visit<'ast> + ?Sized,
{
visitor.visit_for_keyword(&node.keyword);
visitor.visit_symbol((&node.variable).as_ref());
if let Some(value) = (&node.range).as_ref() {
visitor.visit_iteration_range((value).as_ref());
}
if let Some(value) = (&node.when_keyword).as_ref() {
visitor.visit_when_keyword(value);
}
if let Some(value) = (&node.filter).as_ref() {
visitor.visit_expr((value).as_ref());
}
visitor.visit_loop_body((&node.body).as_ref());
}
pub fn visit_while_loop<'ast, V>(visitor: &mut V, node: &'ast WhileLoop)
where
V: Visit<'ast> + ?Sized,
{
visitor.visit_while_keyword(&node.keyword);
visitor.visit_expr((&node.condition).as_ref());
visitor.visit_loop_body((&node.body).as_ref());
}
pub fn visit_new_statement<'ast, V>(visitor: &mut V, node: &'ast NewStatement)
where
V: Visit<'ast> + ?Sized,
{
visitor.visit_new_keyword(&node.keyword);
visitor.visit_expr((&node.class).as_ref());
if let Some(value) = (&node.of_keyword).as_ref() {
visitor.visit_of_keyword(value);
}
if let Some(value) = (&node.parent).as_ref() {
visitor.visit_expr((value).as_ref());
}
if let Some(value) = (&node.from_keyword).as_ref() {
visitor.visit_from_keyword(value);
}
if let Some(value) = (&node.instance).as_ref() {
visitor.visit_expr((value).as_ref());
}
}
pub fn visit_debug_clause<'ast, V>(visitor: &mut V, node: &'ast DebugClause)
where
V: Visit<'ast> + ?Sized,
{
visitor.visit_debug_keyword(&node.keyword);
if let Some(value) = (&node.value).as_ref() {
visitor.visit_expr((value).as_ref());
}
}
pub fn visit_break_statement<'ast, V>(visitor: &mut V, node: &'ast BreakStatement)
where
V: Visit<'ast> + ?Sized,
{
visitor.visit_break_keyword(&node.keyword);
if let Some(value) = (&node.value).as_ref() {
visitor.visit_expr((value).as_ref());
}
}
pub fn visit_continue_statement<'ast, V>(visitor: &mut V, node: &'ast ContinueStatement)
where
V: Visit<'ast> + ?Sized,
{
visitor.visit_continue_keyword(&node.keyword);
if let Some(value) = (&node.value).as_ref() {
visitor.visit_expr((value).as_ref());
}
}
pub fn visit_return_statement<'ast, V>(visitor: &mut V, node: &'ast ReturnStatement)
where
V: Visit<'ast> + ?Sized,
{
visitor.visit_return_keyword(&node.keyword);
if let Some(value) = (&node.value).as_ref() {
visitor.visit_expr((value).as_ref());
}
}
pub fn visit_catch_statement<'ast, V>(visitor: &mut V, node: &'ast CatchStatement)
where
V: Visit<'ast> + ?Sized,
{
visitor.visit_catch_keyword(&node.keyword);
visitor.visit_expr((&node.value).as_ref());
}
pub fn visit_throw_statement<'ast, V>(visitor: &mut V, node: &'ast ThrowStatement)
where
V: Visit<'ast> + ?Sized,
{
visitor.visit_throw_keyword(&node.keyword);
visitor.visit_expr((&node.value).as_ref());
}
pub fn visit_trap_statement<'ast, V>(visitor: &mut V, node: &'ast TrapStatement)
where
V: Visit<'ast> + ?Sized,
{
visitor.visit_trap_keyword(&node.keyword);
visitor.visit_expr((&node.value).as_ref());
}
pub fn visit_except_clause<'ast, V>(visitor: &mut V, node: &'ast ExceptClause)
where
V: Visit<'ast> + ?Sized,
{
visitor.visit_except_keyword(&node.keyword);
visitor.visit_symbol((&node.exception).as_ref());
visitor.visit_do_keyword(&node.do_keyword);
visitor.visit_expr((&node.value).as_ref());
}
pub fn visit_try_statement<'ast, V>(visitor: &mut V, node: &'ast TryStatement)
where
V: Visit<'ast> + ?Sized,
{
visitor.visit_try_keyword(&node.keyword);
visitor.visit_expr((&node.value).as_ref());
if let Some(value) = (&node.then_clause).as_ref() {
visitor.visit_then_clause((value).as_ref());
}
if let Some(value) = (&node.fallback).as_ref() {
visitor.visit_try_fallback((value).as_ref());
}
}
pub fn visit_quote_expression<'ast, V>(visitor: &mut V, node: &'ast QuoteExpression)
where
V: Visit<'ast> + ?Sized,
{
visitor.visit_quote_specifier(&node.specifier);
visitor.visit_symbol((&node.token).as_ref());
}
pub fn visit_prefix_operator<'ast, V>(visitor: &mut V, node: &'ast PrefixOperator)
where
V: Visit<'ast> + ?Sized,
{
match node {
PrefixOperator::Hsh(node) => {
visitor.visit_hsh(node);
}
PrefixOperator::Mul(node) => {
visitor.visit_mul(node);
}
PrefixOperator::Add(node) => {
visitor.visit_add(node);
}
PrefixOperator::Sub(node) => {
visitor.visit_sub(node);
}
PrefixOperator::Lst(node) => {
visitor.visit_lst(node);
}
PrefixOperator::LstLst(node) => {
visitor.visit_lst_lst(node);
}
PrefixOperator::LstEql(node) => {
visitor.visit_lst_eql(node);
}
PrefixOperator::LstEqlEql(node) => {
visitor.visit_lst_eql_eql(node);
}
PrefixOperator::LstEqlEqlEql(node) => {
visitor.visit_lst_eql_eql_eql(node);
}
PrefixOperator::Gst(node) => {
visitor.visit_gst(node);
}
PrefixOperator::GstEql(node) => {
visitor.visit_gst_eql(node);
}
PrefixOperator::Qsm(node) => {
visitor.visit_qsm(node);
}
PrefixOperator::QsmQsm(node) => {
visitor.visit_qsm_qsm(node);
}
PrefixOperator::PipSub(node) => {
visitor.visit_pip_sub(node);
}
PrefixOperator::Tld(node) => {
visitor.visit_tld(node);
}
PrefixOperator::Not(node) => {
visitor.visit_not(node);
}
}
}
pub fn visit_binary_operator<'ast, V>(visitor: &mut V, node: &'ast BinaryOperator)
where
V: Visit<'ast> + ?Sized,
{
match node {
BinaryOperator::BngEql(node) => {
visitor.visit_bng_eql(node);
}
BinaryOperator::Hsh(node) => {
visitor.visit_hsh(node);
}
BinaryOperator::HshQsm(node) => {
visitor.visit_hsh_qsm(node);
}
BinaryOperator::Mod(node) => {
visitor.visit_mod(node);
}
BinaryOperator::ModEql(node) => {
visitor.visit_mod_eql(node);
}
BinaryOperator::Amp(node) => {
visitor.visit_amp(node);
}
BinaryOperator::AmpEql(node) => {
visitor.visit_amp_eql(node);
}
BinaryOperator::Mul(node) => {
visitor.visit_mul(node);
}
BinaryOperator::MulEql(node) => {
visitor.visit_mul_eql(node);
}
BinaryOperator::MulMul(node) => {
visitor.visit_mul_mul(node);
}
BinaryOperator::MulMulEql(node) => {
visitor.visit_mul_mul_eql(node);
}
BinaryOperator::Add(node) => {
visitor.visit_add(node);
}
BinaryOperator::AddEql(node) => {
visitor.visit_add_eql(node);
}
BinaryOperator::AddAdd(node) => {
visitor.visit_add_add(node);
}
BinaryOperator::AddAddEql(node) => {
visitor.visit_add_add_eql(node);
}
BinaryOperator::Sub(node) => {
visitor.visit_sub(node);
}
BinaryOperator::SubEql(node) => {
visitor.visit_sub_eql(node);
}
BinaryOperator::Dot(node) => {
visitor.visit_dot(node);
}
BinaryOperator::DotDot(node) => {
visitor.visit_dot_dot(node);
}
BinaryOperator::DotDotEql(node) => {
visitor.visit_dot_dot_eql(node);
}
BinaryOperator::DotDotLst(node) => {
visitor.visit_dot_dot_lst(node);
}
BinaryOperator::DotDotLstEql(node) => {
visitor.visit_dot_dot_lst_eql(node);
}
BinaryOperator::DotQsm(node) => {
visitor.visit_dot_qsm(node);
}
BinaryOperator::Slh(node) => {
visitor.visit_slh(node);
}
BinaryOperator::SlhEql(node) => {
visitor.visit_slh_eql(node);
}
BinaryOperator::SlhSlh(node) => {
visitor.visit_slh_slh(node);
}
BinaryOperator::SlhSlhEql(node) => {
visitor.visit_slh_slh_eql(node);
}
BinaryOperator::Col(node) => {
visitor.visit_col(node);
}
BinaryOperator::ColEql(node) => {
visitor.visit_col_eql(node);
}
BinaryOperator::Lst(node) => {
visitor.visit_lst(node);
}
BinaryOperator::LstLst(node) => {
visitor.visit_lst_lst(node);
}
BinaryOperator::LstLstEql(node) => {
visitor.visit_lst_lst_eql(node);
}
BinaryOperator::LstEql(node) => {
visitor.visit_lst_eql(node);
}
BinaryOperator::LstEqlEql(node) => {
visitor.visit_lst_eql_eql(node);
}
BinaryOperator::LstEqlEqlEql(node) => {
visitor.visit_lst_eql_eql_eql(node);
}
BinaryOperator::LstEqlEqlGst(node) => {
visitor.visit_lst_eql_eql_gst(node);
}
BinaryOperator::LstEqlEqlGstEql(node) => {
visitor.visit_lst_eql_eql_gst_eql(node);
}
BinaryOperator::EqlBngEql(node) => {
visitor.visit_eql_bng_eql(node);
}
BinaryOperator::EqlEql(node) => {
visitor.visit_eql_eql(node);
}
BinaryOperator::EqlEqlEql(node) => {
visitor.visit_eql_eql_eql(node);
}
BinaryOperator::EqlEqlEqlGst(node) => {
visitor.visit_eql_eql_eql_gst(node);
}
BinaryOperator::EqlEqlEqlGstEql(node) => {
visitor.visit_eql_eql_eql_gst_eql(node);
}
BinaryOperator::EqlEqlGst(node) => {
visitor.visit_eql_eql_gst(node);
}
BinaryOperator::EqlEqlGstEql(node) => {
visitor.visit_eql_eql_gst_eql(node);
}
BinaryOperator::Gst(node) => {
visitor.visit_gst(node);
}
BinaryOperator::GstEql(node) => {
visitor.visit_gst_eql(node);
}
BinaryOperator::GstGst(node) => {
visitor.visit_gst_gst(node);
}
BinaryOperator::GstGstEql(node) => {
visitor.visit_gst_gst_eql(node);
}
BinaryOperator::Qsm(node) => {
visitor.visit_qsm(node);
}
BinaryOperator::QsmQsm(node) => {
visitor.visit_qsm_qsm(node);
}
BinaryOperator::QsmQsmEql(node) => {
visitor.visit_qsm_qsm_eql(node);
}
BinaryOperator::Att(node) => {
visitor.visit_att(node);
}
BinaryOperator::AttEql(node) => {
visitor.visit_att_eql(node);
}
BinaryOperator::AttAtt(node) => {
visitor.visit_att_att(node);
}
BinaryOperator::AttAttEql(node) => {
visitor.visit_att_att_eql(node);
}
BinaryOperator::AttAttQsm(node) => {
visitor.visit_att_att_qsm(node);
}
BinaryOperator::AttAttQsmEql(node) => {
visitor.visit_att_att_qsm_eql(node);
}
BinaryOperator::Bsl(node) => {
visitor.visit_bsl(node);
}
BinaryOperator::BslEql(node) => {
visitor.visit_bsl_eql(node);
}
BinaryOperator::BslBsl(node) => {
visitor.visit_bsl_bsl(node);
}
BinaryOperator::BslBslEql(node) => {
visitor.visit_bsl_bsl_eql(node);
}
BinaryOperator::Crt(node) => {
visitor.visit_crt(node);
}
BinaryOperator::CrtEql(node) => {
visitor.visit_crt_eql(node);
}
BinaryOperator::CrtMulMul(node) => {
visitor.visit_crt_mul_mul(node);
}
BinaryOperator::CrtMulMulEql(node) => {
visitor.visit_crt_mul_mul_eql(node);
}
BinaryOperator::CrtLst(node) => {
visitor.visit_crt_lst(node);
}
BinaryOperator::CrtLstEql(node) => {
visitor.visit_crt_lst_eql(node);
}
BinaryOperator::CrtGst(node) => {
visitor.visit_crt_gst(node);
}
BinaryOperator::CrtGstEql(node) => {
visitor.visit_crt_gst_eql(node);
}
BinaryOperator::CrtCrt(node) => {
visitor.visit_crt_crt(node);
}
BinaryOperator::CrtCrtEql(node) => {
visitor.visit_crt_crt_eql(node);
}
BinaryOperator::Ubs(node) => {
visitor.visit_ubs(node);
}
BinaryOperator::UbsEql(node) => {
visitor.visit_ubs_eql(node);
}
BinaryOperator::UbsLst(node) => {
visitor.visit_ubs_lst(node);
}
BinaryOperator::UbsLstEql(node) => {
visitor.visit_ubs_lst_eql(node);
}
BinaryOperator::UbsGst(node) => {
visitor.visit_ubs_gst(node);
}
BinaryOperator::UbsGstEql(node) => {
visitor.visit_ubs_gst_eql(node);
}
BinaryOperator::Pip(node) => {
visitor.visit_pip(node);
}
BinaryOperator::PipEql(node) => {
visitor.visit_pip_eql(node);
}
BinaryOperator::PipSub(node) => {
visitor.visit_pip_sub(node);
}
BinaryOperator::PipSubEql(node) => {
visitor.visit_pip_sub_eql(node);
}
BinaryOperator::PipUbs(node) => {
visitor.visit_pip_ubs(node);
}
BinaryOperator::PipUbsEql(node) => {
visitor.visit_pip_ubs_eql(node);
}
BinaryOperator::PipPip(node) => {
visitor.visit_pip_pip(node);
}
BinaryOperator::PipPipEql(node) => {
visitor.visit_pip_pip_eql(node);
}
BinaryOperator::Tld(node) => {
visitor.visit_tld(node);
}
BinaryOperator::TldEql(node) => {
visitor.visit_tld_eql(node);
}
BinaryOperator::Cdt(node) => {
visitor.visit_cdt(node);
}
BinaryOperator::CdtEql(node) => {
visitor.visit_cdt_eql(node);
}
BinaryOperator::Box(node) => {
visitor.visit_box(node);
}
BinaryOperator::BoxEql(node) => {
visitor.visit_box_eql(node);
}
BinaryOperator::Sfp(node) => {
visitor.visit_sfp(node);
}
BinaryOperator::SfpEql(node) => {
visitor.visit_sfp_eql(node);
}
BinaryOperator::And(node) => {
visitor.visit_and(node);
}
BinaryOperator::Or(node) => {
visitor.visit_or(node);
}
BinaryOperator::Space(node) => {
visitor.visit_space(node);
}
BinaryOperator::Xor(node) => {
visitor.visit_xor(node);
}
}
}
pub fn visit_postfix_operator<'ast, V>(visitor: &mut V, node: &'ast PostfixOperator)
where
V: Visit<'ast> + ?Sized,
{
match node {
PostfixOperator::Bng(node) => {
visitor.visit_bng(node);
}
PostfixOperator::Graded(node) => {
visitor.visit_graded(node);
}
PostfixOperator::CrtBng(node) => {
visitor.visit_crt_bng(node);
}
PostfixOperator::CrtMul(node) => {
visitor.visit_crt_mul(node);
}
PostfixOperator::CrtTld(node) => {
visitor.visit_crt_tld(node);
}
PostfixOperator::UbsBng(node) => {
visitor.visit_ubs_bng(node);
}
PostfixOperator::UbsMul(node) => {
visitor.visit_ubs_mul(node);
}
PostfixOperator::UbsTld(node) => {
visitor.visit_ubs_tld(node);
}
}
}
pub fn visit_debug_keyword<'ast, V>(visitor: &mut V, node: &'ast DebugKeyword)
where
V: Visit<'ast> + ?Sized,
{
match node {
DebugKeyword::Step(node) => {
visitor.visit_step_keyword(node);
}
DebugKeyword::Finish(node) => {
visitor.visit_finish_keyword(node);
}
DebugKeyword::Shield(node) => {
visitor.visit_shield_keyword(node);
}
DebugKeyword::Test(node) => {
visitor.visit_test_keyword(node);
}
DebugKeyword::Time(node) => {
visitor.visit_time_keyword(node);
}
DebugKeyword::Timing(node) => {
visitor.visit_timing_keyword(node);
}
DebugKeyword::Breakpoint(node) => {
visitor.visit_breakpoint_keyword(node);
}
DebugKeyword::ElapsedTime(node) => {
visitor.visit_elapsed_time_keyword(node);
}
DebugKeyword::ElapsedTiming(node) => {
visitor.visit_elapsed_timing_keyword(node);
}
DebugKeyword::Profile(node) => {
visitor.visit_profile_keyword(node);
}
}
}
pub fn visit_try_fallback<'ast, V>(visitor: &mut V, node: &'ast TryFallback)
where
V: Visit<'ast> + ?Sized,
{
match node {
TryFallback::ExceptClause(node) => {
visitor.visit_except_clause(node);
}
TryFallback::ElseClause(node) => {
visitor.visit_else_clause(node);
}
}
}
pub fn visit_quote_specifier<'ast, V>(visitor: &mut V, node: &'ast QuoteSpecifier)
where
V: Visit<'ast> + ?Sized,
{
match node {
QuoteSpecifier::Symbol(node) => {
visitor.visit_symbol_keyword(node);
}
QuoteSpecifier::Local(node) => {
visitor.visit_local_keyword(node);
}
QuoteSpecifier::Global(node) => {
visitor.visit_global_keyword(node);
}
QuoteSpecifier::ThreadVariable(node) => {
visitor.visit_thread_variable_keyword(node);
}
QuoteSpecifier::ThreadLocal(node) => {
visitor.visit_thread_local_keyword(node);
}
}
}
pub fn visit_any_cell<'ast, V>(visitor: &mut V, node: &'ast AnyCell)
where
V: Visit<'ast> + ?Sized,
{
match node {
AnyCell::ExpressionCell(node) => {
visitor.visit_expression_cell(node);
}
AnyCell::SequenceCell(node) => {
visitor.visit_sequence_cell(node);
}
AnyCell::MutedCell(node) => {
visitor.visit_muted_cell(node);
}
}
}
pub fn visit_component<'ast, V>(visitor: &mut V, node: &'ast Component)
where
V: Visit<'ast> + ?Sized,
{
match node {
Component::EmptyComponent(node) => {
visitor.visit_empty_component(node);
}
Component::Expr(node) => {
visitor.visit_expr(node);
}
}
}
pub fn visit_sequence_element<'ast, V>(visitor: &mut V, node: &'ast SequenceElement)
where
V: Visit<'ast> + ?Sized,
{
match node {
SequenceElement::Component(node) => {
visitor.visit_component(node);
}
SequenceElement::MutedGroup(node) => {
visitor.visit_muted_group(node);
}
}
}
pub fn visit_string_element<'ast, V>(visitor: &mut V, node: &'ast StringElement)
where
V: Visit<'ast> + ?Sized,
{
match node {
StringElement::EscapeSequence(node) => {
visitor.visit_escape_sequence(node);
}
StringElement::StringContent(node) => {
visitor.visit_string_content(node);
}
}
}
pub fn visit_raw_string_element<'ast, V>(visitor: &mut V, node: &'ast RawStringElement)
where
V: Visit<'ast> + ?Sized,
{
match node {
RawStringElement::EscapeSequence(node) => {
visitor.visit_escape_sequence(node);
}
RawStringElement::RawStringContent(node) => {
visitor.visit_raw_string_content(node);
}
}
}
pub fn visit_collection<'ast, V>(visitor: &mut V, node: &'ast Collection)
where
V: Visit<'ast> + ?Sized,
{
match node {
Collection::ParenthesizedExpression(node) => {
visitor.visit_parenthesized_expression(node);
}
Collection::Sequence(node) => {
visitor.visit_sequence(node);
}
Collection::List(node) => {
visitor.visit_list(node);
}
Collection::Array(node) => {
visitor.visit_array(node);
}
Collection::AngleBarList(node) => {
visitor.visit_angle_bar_list(node);
}
}
}
pub fn visit_binding_pack<'ast, V>(visitor: &mut V, node: &'ast BindingPack)
where
V: Visit<'ast> + ?Sized,
{
match node {
BindingPack::ParenthesizedExpression(node) => {
visitor.visit_parenthesized_expression(node);
}
BindingPack::Sequence(node) => {
visitor.visit_sequence(node);
}
BindingPack::List(node) => {
visitor.visit_list(node);
}
BindingPack::Array(node) => {
visitor.visit_array(node);
}
BindingPack::AngleBarList(node) => {
visitor.visit_angle_bar_list(node);
}
}
}
pub fn visit_lambda_parameters<'ast, V>(visitor: &mut V, node: &'ast LambdaParameters)
where
V: Visit<'ast> + ?Sized,
{
match node {
LambdaParameters::Symbol(node) => {
visitor.visit_symbol(node);
}
LambdaParameters::ParenthesizedExpression(node) => {
visitor.visit_parenthesized_expression(node);
}
LambdaParameters::Sequence(node) => {
visitor.visit_sequence(node);
}
LambdaParameters::List(node) => {
visitor.visit_list(node);
}
LambdaParameters::Array(node) => {
visitor.visit_array(node);
}
LambdaParameters::AngleBarList(node) => {
visitor.visit_angle_bar_list(node);
}
}
}
pub fn visit_operator_expr<'ast, V>(visitor: &mut V, node: &'ast OperatorExpr)
where
V: Visit<'ast> + ?Sized,
{
match node {
OperatorExpr::AdjacentExpression(node) => {
visitor.visit_adjacent_expression(node);
}
OperatorExpr::BinaryExpression(node) => {
visitor.visit_binary_expression(node);
}
OperatorExpr::PrefixExpression(node) => {
visitor.visit_prefix_expression(node);
}
OperatorExpr::PostfixExpression(node) => {
visitor.visit_postfix_expression(node);
}
}
}
pub fn visit_assignment_expr<'ast, V>(visitor: &mut V, node: &'ast AssignmentExpr)
where
V: Visit<'ast> + ?Sized,
{
match node {
AssignmentExpr::Assignment(node) => {
visitor.visit_assignment(node);
}
AssignmentExpr::LocalAssignment(node) => {
visitor.visit_local_assignment(node);
}
AssignmentExpr::BinaryAssignment(node) => {
visitor.visit_binary_assignment(node);
}
AssignmentExpr::BinaryInstallation(node) => {
visitor.visit_binary_installation(node);
}
AssignmentExpr::PrefixAssignment(node) => {
visitor.visit_prefix_assignment(node);
}
AssignmentExpr::PrefixInstallation(node) => {
visitor.visit_prefix_installation(node);
}
AssignmentExpr::PostfixAssignment(node) => {
visitor.visit_postfix_assignment(node);
}
AssignmentExpr::PostfixInstallation(node) => {
visitor.visit_postfix_installation(node);
}
AssignmentExpr::StructuredBinding(node) => {
visitor.visit_structured_binding(node);
}
AssignmentExpr::LocalStructuredBinding(node) => {
visitor.visit_local_structured_binding(node);
}
AssignmentExpr::EvaluatedAssignment(node) => {
visitor.visit_evaluated_assignment(node);
}
}
}
pub fn visit_expr<'ast, V>(visitor: &mut V, node: &'ast Expr)
where
V: Visit<'ast> + ?Sized,
{
match node {
Expr::Collection(node) => {
visitor.visit_collection(node);
}
Expr::OperatorExpr(node) => {
visitor.visit_operator_expr(node);
}
Expr::AssignmentExpr(node) => {
visitor.visit_assignment_expr(node);
}
Expr::OptionExpression(node) => {
visitor.visit_option_expression(node);
}
Expr::LambdaExpression(node) => {
visitor.visit_lambda_expression(node);
}
Expr::IfStatement(node) => {
visitor.visit_if_statement(node);
}
Expr::ForLoop(node) => {
visitor.visit_for_loop(node);
}
Expr::WhileLoop(node) => {
visitor.visit_while_loop(node);
}
Expr::TryStatement(node) => {
visitor.visit_try_statement(node);
}
Expr::QuoteExpression(node) => {
visitor.visit_quote_expression(node);
}
Expr::NewStatement(node) => {
visitor.visit_new_statement(node);
}
Expr::BreakStatement(node) => {
visitor.visit_break_statement(node);
}
Expr::ContinueStatement(node) => {
visitor.visit_continue_statement(node);
}
Expr::ReturnStatement(node) => {
visitor.visit_return_statement(node);
}
Expr::CatchStatement(node) => {
visitor.visit_catch_statement(node);
}
Expr::ThrowStatement(node) => {
visitor.visit_throw_statement(node);
}
Expr::TrapStatement(node) => {
visitor.visit_trap_statement(node);
}
Expr::DebugClause(node) => {
visitor.visit_debug_clause(node);
}
Expr::FloatLiteral(node) => {
visitor.visit_float_literal(node);
}
Expr::IntegerLiteral(node) => {
visitor.visit_integer_literal(node);
}
Expr::RawStringLiteral(node) => {
visitor.visit_raw_string_literal(node);
}
Expr::StringLiteral(node) => {
visitor.visit_string_literal(node);
}
Expr::Symbol(node) => {
visitor.visit_symbol(node);
}
}
}
pub fn visit_syntax_node<'ast, V>(visitor: &mut V, node: &'ast SyntaxNode)
where
V: Visit<'ast> + ?Sized,
{
match node {
SyntaxNode::SourceFile(node) => {
visitor.visit_source_file(node);
}
SyntaxNode::AnyCell(node) => {
visitor.visit_any_cell(node);
}
SyntaxNode::Expr(node) => {
visitor.visit_expr(node);
}
}
}
};
}