#[doc(hidden)]
#[macro_export]
macro_rules! __m2_syn_visit_mut_methods {
() => {
fn visit_bng_eql_mut(&mut self, node: &mut Token![!=]) {
$crate::visit_mut::visit_bng_eql_mut(self, node);
}
fn visit_hsh_mut(&mut self, node: &mut Token![#]) {
$crate::visit_mut::visit_hsh_mut(self, node);
}
fn visit_hsh_qsm_mut(&mut self, node: &mut Token![#?]) {
$crate::visit_mut::visit_hsh_qsm_mut(self, node);
}
fn visit_mod_mut(&mut self, node: &mut Token![%]) {
$crate::visit_mut::visit_mod_mut(self, node);
}
fn visit_mod_eql_mut(&mut self, node: &mut Token![%=]) {
$crate::visit_mut::visit_mod_eql_mut(self, node);
}
fn visit_amp_mut(&mut self, node: &mut Token![&]) {
$crate::visit_mut::visit_amp_mut(self, node);
}
fn visit_amp_eql_mut(&mut self, node: &mut Token![&=]) {
$crate::visit_mut::visit_amp_eql_mut(self, node);
}
fn visit_mul_mut(&mut self, node: &mut Token![*]) {
$crate::visit_mut::visit_mul_mut(self, node);
}
fn visit_mul_eql_mut(&mut self, node: &mut Token![*=]) {
$crate::visit_mut::visit_mul_eql_mut(self, node);
}
fn visit_mul_mul_mut(&mut self, node: &mut Token![**]) {
$crate::visit_mut::visit_mul_mul_mut(self, node);
}
fn visit_mul_mul_eql_mut(&mut self, node: &mut Token![**=]) {
$crate::visit_mut::visit_mul_mul_eql_mut(self, node);
}
fn visit_add_mut(&mut self, node: &mut Token![+]) {
$crate::visit_mut::visit_add_mut(self, node);
}
fn visit_add_eql_mut(&mut self, node: &mut Token![+=]) {
$crate::visit_mut::visit_add_eql_mut(self, node);
}
fn visit_add_add_mut(&mut self, node: &mut Token![++]) {
$crate::visit_mut::visit_add_add_mut(self, node);
}
fn visit_add_add_eql_mut(&mut self, node: &mut Token![++=]) {
$crate::visit_mut::visit_add_add_eql_mut(self, node);
}
fn visit_sub_mut(&mut self, node: &mut Token![-]) {
$crate::visit_mut::visit_sub_mut(self, node);
}
fn visit_sub_eql_mut(&mut self, node: &mut Token![-=]) {
$crate::visit_mut::visit_sub_eql_mut(self, node);
}
fn visit_sub_gst_mut(&mut self, node: &mut Token![->]) {
$crate::visit_mut::visit_sub_gst_mut(self, node);
}
fn visit_dot_mut(&mut self, node: &mut Token![.]) {
$crate::visit_mut::visit_dot_mut(self, node);
}
fn visit_dot_dot_mut(&mut self, node: &mut Token![..]) {
$crate::visit_mut::visit_dot_dot_mut(self, node);
}
fn visit_dot_dot_eql_mut(&mut self, node: &mut Token![..=]) {
$crate::visit_mut::visit_dot_dot_eql_mut(self, node);
}
fn visit_dot_dot_lst_mut(&mut self, node: &mut Token![..<]) {
$crate::visit_mut::visit_dot_dot_lst_mut(self, node);
}
fn visit_dot_dot_lst_eql_mut(&mut self, node: &mut Token![..<=]) {
$crate::visit_mut::visit_dot_dot_lst_eql_mut(self, node);
}
fn visit_dot_qsm_mut(&mut self, node: &mut Token![.?]) {
$crate::visit_mut::visit_dot_qsm_mut(self, node);
}
fn visit_slh_mut(&mut self, node: &mut Token![/]) {
$crate::visit_mut::visit_slh_mut(self, node);
}
fn visit_slh_eql_mut(&mut self, node: &mut Token![/=]) {
$crate::visit_mut::visit_slh_eql_mut(self, node);
}
fn visit_slh_slh_mut(&mut self, node: &mut Token![/ /]) {
$crate::visit_mut::visit_slh_slh_mut(self, node);
}
fn visit_slh_slh_eql_mut(&mut self, node: &mut Token![/ /=]) {
$crate::visit_mut::visit_slh_slh_eql_mut(self, node);
}
fn visit_col_mut(&mut self, node: &mut Token![:]) {
$crate::visit_mut::visit_col_mut(self, node);
}
fn visit_col_eql_mut(&mut self, node: &mut Token![:=]) {
$crate::visit_mut::visit_col_eql_mut(self, node);
}
fn visit_lst_mut(&mut self, node: &mut Token![<]) {
$crate::visit_mut::visit_lst_mut(self, node);
}
fn visit_lst_sub_mut(&mut self, node: &mut Token![<-]) {
$crate::visit_mut::visit_lst_sub_mut(self, node);
}
fn visit_lst_lst_mut(&mut self, node: &mut Token![<<]) {
$crate::visit_mut::visit_lst_lst_mut(self, node);
}
fn visit_lst_lst_eql_mut(&mut self, node: &mut Token![<<=]) {
$crate::visit_mut::visit_lst_lst_eql_mut(self, node);
}
fn visit_lst_eql_mut(&mut self, node: &mut Token![<=]) {
$crate::visit_mut::visit_lst_eql_mut(self, node);
}
fn visit_lst_eql_eql_mut(&mut self, node: &mut Token![<==]) {
$crate::visit_mut::visit_lst_eql_eql_mut(self, node);
}
fn visit_lst_eql_eql_eql_mut(&mut self, node: &mut Token![<===]) {
$crate::visit_mut::visit_lst_eql_eql_eql_mut(self, node);
}
fn visit_lst_eql_eql_gst_mut(&mut self, node: &mut Token![<==>]) {
$crate::visit_mut::visit_lst_eql_eql_gst_mut(self, node);
}
fn visit_lst_eql_eql_gst_eql_mut(&mut self, node: &mut Token![<==>=]) {
$crate::visit_mut::visit_lst_eql_eql_gst_eql_mut(self, node);
}
fn visit_eql_mut(&mut self, node: &mut Token![=]) {
$crate::visit_mut::visit_eql_mut(self, node);
}
fn visit_eql_bng_eql_mut(&mut self, node: &mut Token![=!=]) {
$crate::visit_mut::visit_eql_bng_eql_mut(self, node);
}
fn visit_eql_eql_mut(&mut self, node: &mut Token![==]) {
$crate::visit_mut::visit_eql_eql_mut(self, node);
}
fn visit_eql_eql_eql_mut(&mut self, node: &mut Token![===]) {
$crate::visit_mut::visit_eql_eql_eql_mut(self, node);
}
fn visit_eql_eql_eql_gst_mut(&mut self, node: &mut Token![===>]) {
$crate::visit_mut::visit_eql_eql_eql_gst_mut(self, node);
}
fn visit_eql_eql_eql_gst_eql_mut(&mut self, node: &mut Token![===>=]) {
$crate::visit_mut::visit_eql_eql_eql_gst_eql_mut(self, node);
}
fn visit_eql_eql_gst_mut(&mut self, node: &mut Token![==>]) {
$crate::visit_mut::visit_eql_eql_gst_mut(self, node);
}
fn visit_eql_eql_gst_eql_mut(&mut self, node: &mut Token![==>=]) {
$crate::visit_mut::visit_eql_eql_gst_eql_mut(self, node);
}
fn visit_eql_gst_mut(&mut self, node: &mut Token![=>]) {
$crate::visit_mut::visit_eql_gst_mut(self, node);
}
fn visit_gst_mut(&mut self, node: &mut Token![>]) {
$crate::visit_mut::visit_gst_mut(self, node);
}
fn visit_gst_eql_mut(&mut self, node: &mut Token![>=]) {
$crate::visit_mut::visit_gst_eql_mut(self, node);
}
fn visit_gst_gst_mut(&mut self, node: &mut Token![>>]) {
$crate::visit_mut::visit_gst_gst_mut(self, node);
}
fn visit_gst_gst_eql_mut(&mut self, node: &mut Token![>>=]) {
$crate::visit_mut::visit_gst_gst_eql_mut(self, node);
}
fn visit_qsm_mut(&mut self, node: &mut Token![?]) {
$crate::visit_mut::visit_qsm_mut(self, node);
}
fn visit_qsm_qsm_mut(&mut self, node: &mut Token![??]) {
$crate::visit_mut::visit_qsm_qsm_mut(self, node);
}
fn visit_qsm_qsm_eql_mut(&mut self, node: &mut Token![??=]) {
$crate::visit_mut::visit_qsm_qsm_eql_mut(self, node);
}
fn visit_att_mut(&mut self, node: &mut Token![@]) {
$crate::visit_mut::visit_att_mut(self, node);
}
fn visit_att_eql_mut(&mut self, node: &mut Token![@=]) {
$crate::visit_mut::visit_att_eql_mut(self, node);
}
fn visit_att_att_mut(&mut self, node: &mut Token![@@]) {
$crate::visit_mut::visit_att_att_mut(self, node);
}
fn visit_att_att_eql_mut(&mut self, node: &mut Token![@@=]) {
$crate::visit_mut::visit_att_att_eql_mut(self, node);
}
fn visit_att_att_qsm_mut(&mut self, node: &mut Token![@@?]) {
$crate::visit_mut::visit_att_att_qsm_mut(self, node);
}
fn visit_att_att_qsm_eql_mut(&mut self, node: &mut Token![@@?=]) {
$crate::visit_mut::visit_att_att_qsm_eql_mut(self, node);
}
fn visit_bsl_mut(&mut self, node: &mut Token!["\\"]) {
$crate::visit_mut::visit_bsl_mut(self, node);
}
fn visit_bsl_eql_mut(&mut self, node: &mut Token!["\\="]) {
$crate::visit_mut::visit_bsl_eql_mut(self, node);
}
fn visit_bsl_bsl_mut(&mut self, node: &mut Token!["\\\\"]) {
$crate::visit_mut::visit_bsl_bsl_mut(self, node);
}
fn visit_bsl_bsl_eql_mut(&mut self, node: &mut Token!["\\\\="]) {
$crate::visit_mut::visit_bsl_bsl_eql_mut(self, node);
}
fn visit_crt_mut(&mut self, node: &mut Token![^]) {
$crate::visit_mut::visit_crt_mut(self, node);
}
fn visit_crt_eql_mut(&mut self, node: &mut Token![^=]) {
$crate::visit_mut::visit_crt_eql_mut(self, node);
}
fn visit_crt_mul_mul_mut(&mut self, node: &mut Token![^**]) {
$crate::visit_mut::visit_crt_mul_mul_mut(self, node);
}
fn visit_crt_mul_mul_eql_mut(&mut self, node: &mut Token![^**=]) {
$crate::visit_mut::visit_crt_mul_mul_eql_mut(self, node);
}
fn visit_crt_lst_mut(&mut self, node: &mut Token![^<]) {
$crate::visit_mut::visit_crt_lst_mut(self, node);
}
fn visit_crt_lst_eql_mut(&mut self, node: &mut Token![^<=]) {
$crate::visit_mut::visit_crt_lst_eql_mut(self, node);
}
fn visit_crt_gst_mut(&mut self, node: &mut Token![^>]) {
$crate::visit_mut::visit_crt_gst_mut(self, node);
}
fn visit_crt_gst_eql_mut(&mut self, node: &mut Token![^>=]) {
$crate::visit_mut::visit_crt_gst_eql_mut(self, node);
}
fn visit_crt_crt_mut(&mut self, node: &mut Token![^^]) {
$crate::visit_mut::visit_crt_crt_mut(self, node);
}
fn visit_crt_crt_eql_mut(&mut self, node: &mut Token![^^=]) {
$crate::visit_mut::visit_crt_crt_eql_mut(self, node);
}
fn visit_ubs_mut(&mut self, node: &mut Token![_]) {
$crate::visit_mut::visit_ubs_mut(self, node);
}
fn visit_ubs_eql_mut(&mut self, node: &mut Token![_=]) {
$crate::visit_mut::visit_ubs_eql_mut(self, node);
}
fn visit_ubs_lst_mut(&mut self, node: &mut Token![_<]) {
$crate::visit_mut::visit_ubs_lst_mut(self, node);
}
fn visit_ubs_lst_eql_mut(&mut self, node: &mut Token![_<=]) {
$crate::visit_mut::visit_ubs_lst_eql_mut(self, node);
}
fn visit_ubs_gst_mut(&mut self, node: &mut Token![_>]) {
$crate::visit_mut::visit_ubs_gst_mut(self, node);
}
fn visit_ubs_gst_eql_mut(&mut self, node: &mut Token![_>=]) {
$crate::visit_mut::visit_ubs_gst_eql_mut(self, node);
}
fn visit_pip_mut(&mut self, node: &mut Token![|]) {
$crate::visit_mut::visit_pip_mut(self, node);
}
fn visit_pip_eql_mut(&mut self, node: &mut Token![|=]) {
$crate::visit_mut::visit_pip_eql_mut(self, node);
}
fn visit_pip_sub_mut(&mut self, node: &mut Token![|-]) {
$crate::visit_mut::visit_pip_sub_mut(self, node);
}
fn visit_pip_sub_eql_mut(&mut self, node: &mut Token![|-=]) {
$crate::visit_mut::visit_pip_sub_eql_mut(self, node);
}
fn visit_pip_ubs_mut(&mut self, node: &mut Token![|_]) {
$crate::visit_mut::visit_pip_ubs_mut(self, node);
}
fn visit_pip_ubs_eql_mut(&mut self, node: &mut Token![|_=]) {
$crate::visit_mut::visit_pip_ubs_eql_mut(self, node);
}
fn visit_pip_pip_mut(&mut self, node: &mut Token![||]) {
$crate::visit_mut::visit_pip_pip_mut(self, node);
}
fn visit_pip_pip_eql_mut(&mut self, node: &mut Token![||=]) {
$crate::visit_mut::visit_pip_pip_eql_mut(self, node);
}
fn visit_tld_mut(&mut self, node: &mut Token![~]) {
$crate::visit_mut::visit_tld_mut(self, node);
}
fn visit_tld_eql_mut(&mut self, node: &mut Token![~=]) {
$crate::visit_mut::visit_tld_eql_mut(self, node);
}
fn visit_cdt_mut(&mut self, node: &mut Token!["·"]) {
$crate::visit_mut::visit_cdt_mut(self, node);
}
fn visit_cdt_eql_mut(&mut self, node: &mut Token!["·="]) {
$crate::visit_mut::visit_cdt_eql_mut(self, node);
}
fn visit_box_mut(&mut self, node: &mut Token!["⊠"]) {
$crate::visit_mut::visit_box_mut(self, node);
}
fn visit_box_eql_mut(&mut self, node: &mut Token!["⊠="]) {
$crate::visit_mut::visit_box_eql_mut(self, node);
}
fn visit_sfp_mut(&mut self, node: &mut Token!["⧢"]) {
$crate::visit_mut::visit_sfp_mut(self, node);
}
fn visit_sfp_eql_mut(&mut self, node: &mut Token!["⧢="]) {
$crate::visit_mut::visit_sfp_eql_mut(self, node);
}
fn visit_and_mut(&mut self, node: &mut Token![and]) {
$crate::visit_mut::visit_and_mut(self, node);
}
fn visit_or_mut(&mut self, node: &mut Token![or]) {
$crate::visit_mut::visit_or_mut(self, node);
}
fn visit_space_mut(&mut self, node: &mut Token![SPACE]) {
$crate::visit_mut::visit_space_mut(self, node);
}
fn visit_xor_mut(&mut self, node: &mut Token![xor]) {
$crate::visit_mut::visit_xor_mut(self, node);
}
fn visit_bng_mut(&mut self, node: &mut Token![!]) {
$crate::visit_mut::visit_bng_mut(self, node);
}
fn visit_graded_mut(&mut self, node: &mut Token![(*)]) {
$crate::visit_mut::visit_graded_mut(self, node);
}
fn visit_crt_bng_mut(&mut self, node: &mut Token![^!]) {
$crate::visit_mut::visit_crt_bng_mut(self, node);
}
fn visit_crt_mul_mut(&mut self, node: &mut Token![^*]) {
$crate::visit_mut::visit_crt_mul_mut(self, node);
}
fn visit_crt_tld_mut(&mut self, node: &mut Token![^~]) {
$crate::visit_mut::visit_crt_tld_mut(self, node);
}
fn visit_ubs_bng_mut(&mut self, node: &mut Token![_!]) {
$crate::visit_mut::visit_ubs_bng_mut(self, node);
}
fn visit_ubs_mul_mut(&mut self, node: &mut Token![_*]) {
$crate::visit_mut::visit_ubs_mul_mut(self, node);
}
fn visit_ubs_tld_mut(&mut self, node: &mut Token![_~]) {
$crate::visit_mut::visit_ubs_tld_mut(self, node);
}
fn visit_not_mut(&mut self, node: &mut Token![not]) {
$crate::visit_mut::visit_not_mut(self, node);
}
fn visit_break_keyword_mut(&mut self, node: &mut Token![break]) {
$crate::visit_mut::visit_break_keyword_mut(self, node);
}
fn visit_breakpoint_keyword_mut(&mut self, node: &mut Token![breakpoint]) {
$crate::visit_mut::visit_breakpoint_keyword_mut(self, node);
}
fn visit_catch_keyword_mut(&mut self, node: &mut Token![catch]) {
$crate::visit_mut::visit_catch_keyword_mut(self, node);
}
fn visit_continue_keyword_mut(&mut self, node: &mut Token![continue]) {
$crate::visit_mut::visit_continue_keyword_mut(self, node);
}
fn visit_do_keyword_mut(&mut self, node: &mut Token![do]) {
$crate::visit_mut::visit_do_keyword_mut(self, node);
}
fn visit_elapsed_time_keyword_mut(&mut self, node: &mut Token![elapsedTime]) {
$crate::visit_mut::visit_elapsed_time_keyword_mut(self, node);
}
fn visit_elapsed_timing_keyword_mut(&mut self, node: &mut Token![elapsedTiming]) {
$crate::visit_mut::visit_elapsed_timing_keyword_mut(self, node);
}
fn visit_else_keyword_mut(&mut self, node: &mut Token![else]) {
$crate::visit_mut::visit_else_keyword_mut(self, node);
}
fn visit_except_keyword_mut(&mut self, node: &mut Token![except]) {
$crate::visit_mut::visit_except_keyword_mut(self, node);
}
fn visit_finish_keyword_mut(&mut self, node: &mut Token![finish]) {
$crate::visit_mut::visit_finish_keyword_mut(self, node);
}
fn visit_for_keyword_mut(&mut self, node: &mut Token![for]) {
$crate::visit_mut::visit_for_keyword_mut(self, node);
}
fn visit_from_keyword_mut(&mut self, node: &mut Token![from]) {
$crate::visit_mut::visit_from_keyword_mut(self, node);
}
fn visit_global_keyword_mut(&mut self, node: &mut Token![global]) {
$crate::visit_mut::visit_global_keyword_mut(self, node);
}
fn visit_if_keyword_mut(&mut self, node: &mut Token![if]) {
$crate::visit_mut::visit_if_keyword_mut(self, node);
}
fn visit_in_keyword_mut(&mut self, node: &mut Token![in]) {
$crate::visit_mut::visit_in_keyword_mut(self, node);
}
fn visit_list_keyword_mut(&mut self, node: &mut Token![list]) {
$crate::visit_mut::visit_list_keyword_mut(self, node);
}
fn visit_local_keyword_mut(&mut self, node: &mut Token![local]) {
$crate::visit_mut::visit_local_keyword_mut(self, node);
}
fn visit_new_keyword_mut(&mut self, node: &mut Token![new]) {
$crate::visit_mut::visit_new_keyword_mut(self, node);
}
fn visit_of_keyword_mut(&mut self, node: &mut Token![of]) {
$crate::visit_mut::visit_of_keyword_mut(self, node);
}
fn visit_profile_keyword_mut(&mut self, node: &mut Token![profile]) {
$crate::visit_mut::visit_profile_keyword_mut(self, node);
}
fn visit_return_keyword_mut(&mut self, node: &mut Token![return]) {
$crate::visit_mut::visit_return_keyword_mut(self, node);
}
fn visit_shield_keyword_mut(&mut self, node: &mut Token![shield]) {
$crate::visit_mut::visit_shield_keyword_mut(self, node);
}
fn visit_step_keyword_mut(&mut self, node: &mut Token![step]) {
$crate::visit_mut::visit_step_keyword_mut(self, node);
}
fn visit_symbol_keyword_mut(&mut self, node: &mut Token![symbol]) {
$crate::visit_mut::visit_symbol_keyword_mut(self, node);
}
fn visit_test_keyword_mut(&mut self, node: &mut Token![TEST]) {
$crate::visit_mut::visit_test_keyword_mut(self, node);
}
fn visit_then_keyword_mut(&mut self, node: &mut Token![then]) {
$crate::visit_mut::visit_then_keyword_mut(self, node);
}
fn visit_thread_local_keyword_mut(&mut self, node: &mut Token![threadLocal]) {
$crate::visit_mut::visit_thread_local_keyword_mut(self, node);
}
fn visit_thread_variable_keyword_mut(&mut self, node: &mut Token![threadVariable]) {
$crate::visit_mut::visit_thread_variable_keyword_mut(self, node);
}
fn visit_throw_keyword_mut(&mut self, node: &mut Token![throw]) {
$crate::visit_mut::visit_throw_keyword_mut(self, node);
}
fn visit_time_keyword_mut(&mut self, node: &mut Token![time]) {
$crate::visit_mut::visit_time_keyword_mut(self, node);
}
fn visit_timing_keyword_mut(&mut self, node: &mut Token![timing]) {
$crate::visit_mut::visit_timing_keyword_mut(self, node);
}
fn visit_to_keyword_mut(&mut self, node: &mut Token![to]) {
$crate::visit_mut::visit_to_keyword_mut(self, node);
}
fn visit_trap_keyword_mut(&mut self, node: &mut Token![trap]) {
$crate::visit_mut::visit_trap_keyword_mut(self, node);
}
fn visit_try_keyword_mut(&mut self, node: &mut Token![try]) {
$crate::visit_mut::visit_try_keyword_mut(self, node);
}
fn visit_when_keyword_mut(&mut self, node: &mut Token![when]) {
$crate::visit_mut::visit_when_keyword_mut(self, node);
}
fn visit_while_keyword_mut(&mut self, node: &mut Token![while]) {
$crate::visit_mut::visit_while_keyword_mut(self, node);
}
fn visit_scl_mut(&mut self, node: &mut Token![;]) {
$crate::visit_mut::visit_scl_mut(self, node);
}
fn visit_cma_mut(&mut self, node: &mut Token![,]) {
$crate::visit_mut::visit_cma_mut(self, node);
}
fn visit_symbol_mut(&mut self, node: &mut Symbol) {
$crate::visit_mut::visit_symbol_mut(self, node);
}
fn visit_block_comment_mut(&mut self, node: &mut BlockComment) {
$crate::visit_mut::visit_block_comment_mut(self, node);
}
fn visit_line_comment_mut(&mut self, node: &mut LineComment) {
$crate::visit_mut::visit_line_comment_mut(self, node);
}
fn visit_empty_component_mut(&mut self, node: &mut EmptyComponent) {
$crate::visit_mut::visit_empty_component_mut(self, node);
}
fn visit_escape_sequence_mut(&mut self, node: &mut EscapeSequence) {
$crate::visit_mut::visit_escape_sequence_mut(self, node);
}
fn visit_float_literal_mut(&mut self, node: &mut FloatLiteral) {
$crate::visit_mut::visit_float_literal_mut(self, node);
}
fn visit_integer_literal_mut(&mut self, node: &mut IntegerLiteral) {
$crate::visit_mut::visit_integer_literal_mut(self, node);
}
fn visit_raw_string_content_mut(&mut self, node: &mut RawStringContent) {
$crate::visit_mut::visit_raw_string_content_mut(self, node);
}
fn visit_string_content_mut(&mut self, node: &mut StringContent) {
$crate::visit_mut::visit_string_content_mut(self, node);
}
fn visit_source_file_mut(&mut self, node: &mut SourceFile) {
$crate::visit_mut::visit_source_file_mut(self, node);
}
fn visit_expression_cell_mut(&mut self, node: &mut ExpressionCell) {
$crate::visit_mut::visit_expression_cell_mut(self, node);
}
fn visit_sequence_cell_mut(&mut self, node: &mut SequenceCell) {
$crate::visit_mut::visit_sequence_cell_mut(self, node);
}
fn visit_naked_sequence_mut(&mut self, node: &mut NakedSequence) {
$crate::visit_mut::visit_naked_sequence_mut(self, node);
}
fn visit_muted_cell_mut(&mut self, node: &mut MutedCell) {
$crate::visit_mut::visit_muted_cell_mut(self, node);
}
fn visit_muted_group_mut(&mut self, node: &mut MutedGroup) {
$crate::visit_mut::visit_muted_group_mut(self, node);
}
fn visit_array_mut(&mut self, node: &mut Array) {
$crate::visit_mut::visit_array_mut(self, node);
}
fn visit_list_mut(&mut self, node: &mut List) {
$crate::visit_mut::visit_list_mut(self, node);
}
fn visit_angle_bar_list_mut(&mut self, node: &mut AngleBarList) {
$crate::visit_mut::visit_angle_bar_list_mut(self, node);
}
fn visit_sequence_mut(&mut self, node: &mut Sequence) {
$crate::visit_mut::visit_sequence_mut(self, node);
}
fn visit_parenthesized_expression_mut(&mut self, node: &mut ParenthesizedExpression) {
$crate::visit_mut::visit_parenthesized_expression_mut(self, node);
}
fn visit_string_literal_mut(&mut self, node: &mut StringLiteral) {
$crate::visit_mut::visit_string_literal_mut(self, node);
}
fn visit_raw_string_literal_mut(&mut self, node: &mut RawStringLiteral) {
$crate::visit_mut::visit_raw_string_literal_mut(self, node);
}
fn visit_binary_expression_mut(&mut self, node: &mut BinaryExpression) {
$crate::visit_mut::visit_binary_expression_mut(self, node);
}
fn visit_adjacent_expression_mut(&mut self, node: &mut AdjacentExpression) {
$crate::visit_mut::visit_adjacent_expression_mut(self, node);
}
fn visit_prefix_expression_mut(&mut self, node: &mut PrefixExpression) {
$crate::visit_mut::visit_prefix_expression_mut(self, node);
}
fn visit_postfix_expression_mut(&mut self, node: &mut PostfixExpression) {
$crate::visit_mut::visit_postfix_expression_mut(self, node);
}
fn visit_lambda_expression_mut(&mut self, node: &mut LambdaExpression) {
$crate::visit_mut::visit_lambda_expression_mut(self, node);
}
fn visit_assignment_mut(&mut self, node: &mut Assignment) {
$crate::visit_mut::visit_assignment_mut(self, node);
}
fn visit_local_assignment_mut(&mut self, node: &mut LocalAssignment) {
$crate::visit_mut::visit_local_assignment_mut(self, node);
}
fn visit_binary_assignment_mut(&mut self, node: &mut BinaryAssignment) {
$crate::visit_mut::visit_binary_assignment_mut(self, node);
}
fn visit_binary_installation_mut(&mut self, node: &mut BinaryInstallation) {
$crate::visit_mut::visit_binary_installation_mut(self, node);
}
fn visit_prefix_assignment_mut(&mut self, node: &mut PrefixAssignment) {
$crate::visit_mut::visit_prefix_assignment_mut(self, node);
}
fn visit_prefix_installation_mut(&mut self, node: &mut PrefixInstallation) {
$crate::visit_mut::visit_prefix_installation_mut(self, node);
}
fn visit_postfix_assignment_mut(&mut self, node: &mut PostfixAssignment) {
$crate::visit_mut::visit_postfix_assignment_mut(self, node);
}
fn visit_postfix_installation_mut(&mut self, node: &mut PostfixInstallation) {
$crate::visit_mut::visit_postfix_installation_mut(self, node);
}
fn visit_structured_binding_mut(&mut self, node: &mut StructuredBinding) {
$crate::visit_mut::visit_structured_binding_mut(self, node);
}
fn visit_local_structured_binding_mut(&mut self, node: &mut LocalStructuredBinding) {
$crate::visit_mut::visit_local_structured_binding_mut(self, node);
}
fn visit_evaluated_assignment_mut(&mut self, node: &mut EvaluatedAssignment) {
$crate::visit_mut::visit_evaluated_assignment_mut(self, node);
}
fn visit_option_expression_mut(&mut self, node: &mut OptionExpression) {
$crate::visit_mut::visit_option_expression_mut(self, node);
}
fn visit_then_clause_mut(&mut self, node: &mut ThenClause) {
$crate::visit_mut::visit_then_clause_mut(self, node);
}
fn visit_else_clause_mut(&mut self, node: &mut ElseClause) {
$crate::visit_mut::visit_else_clause_mut(self, node);
}
fn visit_if_statement_mut(&mut self, node: &mut IfStatement) {
$crate::visit_mut::visit_if_statement_mut(self, node);
}
fn visit_loop_body_mut(&mut self, node: &mut LoopBody) {
$crate::visit_mut::visit_loop_body_mut(self, node);
}
fn visit_iteration_range_mut(&mut self, node: &mut IterationRange) {
$crate::visit_mut::visit_iteration_range_mut(self, node);
}
fn visit_for_loop_mut(&mut self, node: &mut ForLoop) {
$crate::visit_mut::visit_for_loop_mut(self, node);
}
fn visit_while_loop_mut(&mut self, node: &mut WhileLoop) {
$crate::visit_mut::visit_while_loop_mut(self, node);
}
fn visit_new_statement_mut(&mut self, node: &mut NewStatement) {
$crate::visit_mut::visit_new_statement_mut(self, node);
}
fn visit_debug_clause_mut(&mut self, node: &mut DebugClause) {
$crate::visit_mut::visit_debug_clause_mut(self, node);
}
fn visit_break_statement_mut(&mut self, node: &mut BreakStatement) {
$crate::visit_mut::visit_break_statement_mut(self, node);
}
fn visit_continue_statement_mut(&mut self, node: &mut ContinueStatement) {
$crate::visit_mut::visit_continue_statement_mut(self, node);
}
fn visit_return_statement_mut(&mut self, node: &mut ReturnStatement) {
$crate::visit_mut::visit_return_statement_mut(self, node);
}
fn visit_catch_statement_mut(&mut self, node: &mut CatchStatement) {
$crate::visit_mut::visit_catch_statement_mut(self, node);
}
fn visit_throw_statement_mut(&mut self, node: &mut ThrowStatement) {
$crate::visit_mut::visit_throw_statement_mut(self, node);
}
fn visit_trap_statement_mut(&mut self, node: &mut TrapStatement) {
$crate::visit_mut::visit_trap_statement_mut(self, node);
}
fn visit_except_clause_mut(&mut self, node: &mut ExceptClause) {
$crate::visit_mut::visit_except_clause_mut(self, node);
}
fn visit_try_statement_mut(&mut self, node: &mut TryStatement) {
$crate::visit_mut::visit_try_statement_mut(self, node);
}
fn visit_quote_expression_mut(&mut self, node: &mut QuoteExpression) {
$crate::visit_mut::visit_quote_expression_mut(self, node);
}
fn visit_prefix_operator_mut(&mut self, node: &mut PrefixOperator) {
$crate::visit_mut::visit_prefix_operator_mut(self, node);
}
fn visit_binary_operator_mut(&mut self, node: &mut BinaryOperator) {
$crate::visit_mut::visit_binary_operator_mut(self, node);
}
fn visit_postfix_operator_mut(&mut self, node: &mut PostfixOperator) {
$crate::visit_mut::visit_postfix_operator_mut(self, node);
}
fn visit_debug_keyword_mut(&mut self, node: &mut DebugKeyword) {
$crate::visit_mut::visit_debug_keyword_mut(self, node);
}
fn visit_try_fallback_mut(&mut self, node: &mut TryFallback) {
$crate::visit_mut::visit_try_fallback_mut(self, node);
}
fn visit_quote_specifier_mut(&mut self, node: &mut QuoteSpecifier) {
$crate::visit_mut::visit_quote_specifier_mut(self, node);
}
fn visit_any_cell_mut(&mut self, node: &mut AnyCell) {
$crate::visit_mut::visit_any_cell_mut(self, node);
}
fn visit_component_mut(&mut self, node: &mut Component) {
$crate::visit_mut::visit_component_mut(self, node);
}
fn visit_sequence_element_mut(&mut self, node: &mut SequenceElement) {
$crate::visit_mut::visit_sequence_element_mut(self, node);
}
fn visit_string_element_mut(&mut self, node: &mut StringElement) {
$crate::visit_mut::visit_string_element_mut(self, node);
}
fn visit_raw_string_element_mut(&mut self, node: &mut RawStringElement) {
$crate::visit_mut::visit_raw_string_element_mut(self, node);
}
fn visit_collection_mut(&mut self, node: &mut Collection) {
$crate::visit_mut::visit_collection_mut(self, node);
}
fn visit_binding_pack_mut(&mut self, node: &mut BindingPack) {
$crate::visit_mut::visit_binding_pack_mut(self, node);
}
fn visit_lambda_parameters_mut(&mut self, node: &mut LambdaParameters) {
$crate::visit_mut::visit_lambda_parameters_mut(self, node);
}
fn visit_operator_expr_mut(&mut self, node: &mut OperatorExpr) {
$crate::visit_mut::visit_operator_expr_mut(self, node);
}
fn visit_assignment_expr_mut(&mut self, node: &mut AssignmentExpr) {
$crate::visit_mut::visit_assignment_expr_mut(self, node);
}
fn visit_expr_mut(&mut self, node: &mut Expr) {
$crate::visit_mut::visit_expr_mut(self, node);
}
fn visit_syntax_node_mut(&mut self, node: &mut SyntaxNode) {
$crate::visit_mut::visit_syntax_node_mut(self, node);
}
};
}
#[doc(hidden)]
#[macro_export]
macro_rules! __m2_syn_visit_mut_walkers {
() => {
pub fn visit_bng_eql_mut<V>(_visitor: &mut V, _node: &mut Token![!=])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_hsh_mut<V>(_visitor: &mut V, _node: &mut Token![#])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_hsh_qsm_mut<V>(_visitor: &mut V, _node: &mut Token![#?])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_mod_mut<V>(_visitor: &mut V, _node: &mut Token![%])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_mod_eql_mut<V>(_visitor: &mut V, _node: &mut Token![%=])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_amp_mut<V>(_visitor: &mut V, _node: &mut Token![&])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_amp_eql_mut<V>(_visitor: &mut V, _node: &mut Token![&=])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_mul_mut<V>(_visitor: &mut V, _node: &mut Token![*])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_mul_eql_mut<V>(_visitor: &mut V, _node: &mut Token![*=])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_mul_mul_mut<V>(_visitor: &mut V, _node: &mut Token![**])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_mul_mul_eql_mut<V>(_visitor: &mut V, _node: &mut Token![**=])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_add_mut<V>(_visitor: &mut V, _node: &mut Token![+])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_add_eql_mut<V>(_visitor: &mut V, _node: &mut Token![+=])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_add_add_mut<V>(_visitor: &mut V, _node: &mut Token![++])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_add_add_eql_mut<V>(_visitor: &mut V, _node: &mut Token![++=])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_sub_mut<V>(_visitor: &mut V, _node: &mut Token![-])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_sub_eql_mut<V>(_visitor: &mut V, _node: &mut Token![-=])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_sub_gst_mut<V>(_visitor: &mut V, _node: &mut Token![->])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_dot_mut<V>(_visitor: &mut V, _node: &mut Token![.])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_dot_dot_mut<V>(_visitor: &mut V, _node: &mut Token![..])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_dot_dot_eql_mut<V>(_visitor: &mut V, _node: &mut Token![..=])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_dot_dot_lst_mut<V>(_visitor: &mut V, _node: &mut Token![..<])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_dot_dot_lst_eql_mut<V>(_visitor: &mut V, _node: &mut Token![..<=])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_dot_qsm_mut<V>(_visitor: &mut V, _node: &mut Token![.?])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_slh_mut<V>(_visitor: &mut V, _node: &mut Token![/])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_slh_eql_mut<V>(_visitor: &mut V, _node: &mut Token![/=])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_slh_slh_mut<V>(_visitor: &mut V, _node: &mut Token![/ /])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_slh_slh_eql_mut<V>(_visitor: &mut V, _node: &mut Token![/ /=])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_col_mut<V>(_visitor: &mut V, _node: &mut Token![:])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_col_eql_mut<V>(_visitor: &mut V, _node: &mut Token![:=])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_lst_mut<V>(_visitor: &mut V, _node: &mut Token![<])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_lst_sub_mut<V>(_visitor: &mut V, _node: &mut Token![<-])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_lst_lst_mut<V>(_visitor: &mut V, _node: &mut Token![<<])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_lst_lst_eql_mut<V>(_visitor: &mut V, _node: &mut Token![<<=])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_lst_eql_mut<V>(_visitor: &mut V, _node: &mut Token![<=])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_lst_eql_eql_mut<V>(_visitor: &mut V, _node: &mut Token![<==])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_lst_eql_eql_eql_mut<V>(_visitor: &mut V, _node: &mut Token![<===])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_lst_eql_eql_gst_mut<V>(_visitor: &mut V, _node: &mut Token![<==>])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_lst_eql_eql_gst_eql_mut<V>(_visitor: &mut V, _node: &mut Token![<==>=])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_eql_mut<V>(_visitor: &mut V, _node: &mut Token![=])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_eql_bng_eql_mut<V>(_visitor: &mut V, _node: &mut Token![=!=])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_eql_eql_mut<V>(_visitor: &mut V, _node: &mut Token![==])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_eql_eql_eql_mut<V>(_visitor: &mut V, _node: &mut Token![===])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_eql_eql_eql_gst_mut<V>(_visitor: &mut V, _node: &mut Token![===>])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_eql_eql_eql_gst_eql_mut<V>(_visitor: &mut V, _node: &mut Token![===>=])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_eql_eql_gst_mut<V>(_visitor: &mut V, _node: &mut Token![==>])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_eql_eql_gst_eql_mut<V>(_visitor: &mut V, _node: &mut Token![==>=])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_eql_gst_mut<V>(_visitor: &mut V, _node: &mut Token![=>])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_gst_mut<V>(_visitor: &mut V, _node: &mut Token![>])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_gst_eql_mut<V>(_visitor: &mut V, _node: &mut Token![>=])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_gst_gst_mut<V>(_visitor: &mut V, _node: &mut Token![>>])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_gst_gst_eql_mut<V>(_visitor: &mut V, _node: &mut Token![>>=])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_qsm_mut<V>(_visitor: &mut V, _node: &mut Token![?])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_qsm_qsm_mut<V>(_visitor: &mut V, _node: &mut Token![??])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_qsm_qsm_eql_mut<V>(_visitor: &mut V, _node: &mut Token![??=])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_att_mut<V>(_visitor: &mut V, _node: &mut Token![@])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_att_eql_mut<V>(_visitor: &mut V, _node: &mut Token![@=])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_att_att_mut<V>(_visitor: &mut V, _node: &mut Token![@@])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_att_att_eql_mut<V>(_visitor: &mut V, _node: &mut Token![@@=])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_att_att_qsm_mut<V>(_visitor: &mut V, _node: &mut Token![@@?])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_att_att_qsm_eql_mut<V>(_visitor: &mut V, _node: &mut Token![@@?=])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_bsl_mut<V>(_visitor: &mut V, _node: &mut Token!["\\"])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_bsl_eql_mut<V>(_visitor: &mut V, _node: &mut Token!["\\="])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_bsl_bsl_mut<V>(_visitor: &mut V, _node: &mut Token!["\\\\"])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_bsl_bsl_eql_mut<V>(_visitor: &mut V, _node: &mut Token!["\\\\="])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_crt_mut<V>(_visitor: &mut V, _node: &mut Token![^])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_crt_eql_mut<V>(_visitor: &mut V, _node: &mut Token![^=])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_crt_mul_mul_mut<V>(_visitor: &mut V, _node: &mut Token![^**])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_crt_mul_mul_eql_mut<V>(_visitor: &mut V, _node: &mut Token![^**=])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_crt_lst_mut<V>(_visitor: &mut V, _node: &mut Token![^<])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_crt_lst_eql_mut<V>(_visitor: &mut V, _node: &mut Token![^<=])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_crt_gst_mut<V>(_visitor: &mut V, _node: &mut Token![^>])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_crt_gst_eql_mut<V>(_visitor: &mut V, _node: &mut Token![^>=])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_crt_crt_mut<V>(_visitor: &mut V, _node: &mut Token![^^])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_crt_crt_eql_mut<V>(_visitor: &mut V, _node: &mut Token![^^=])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_ubs_mut<V>(_visitor: &mut V, _node: &mut Token![_])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_ubs_eql_mut<V>(_visitor: &mut V, _node: &mut Token![_=])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_ubs_lst_mut<V>(_visitor: &mut V, _node: &mut Token![_<])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_ubs_lst_eql_mut<V>(_visitor: &mut V, _node: &mut Token![_<=])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_ubs_gst_mut<V>(_visitor: &mut V, _node: &mut Token![_>])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_ubs_gst_eql_mut<V>(_visitor: &mut V, _node: &mut Token![_>=])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_pip_mut<V>(_visitor: &mut V, _node: &mut Token![|])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_pip_eql_mut<V>(_visitor: &mut V, _node: &mut Token![|=])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_pip_sub_mut<V>(_visitor: &mut V, _node: &mut Token![|-])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_pip_sub_eql_mut<V>(_visitor: &mut V, _node: &mut Token![|-=])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_pip_ubs_mut<V>(_visitor: &mut V, _node: &mut Token![|_])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_pip_ubs_eql_mut<V>(_visitor: &mut V, _node: &mut Token![|_=])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_pip_pip_mut<V>(_visitor: &mut V, _node: &mut Token![||])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_pip_pip_eql_mut<V>(_visitor: &mut V, _node: &mut Token![||=])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_tld_mut<V>(_visitor: &mut V, _node: &mut Token![~])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_tld_eql_mut<V>(_visitor: &mut V, _node: &mut Token![~=])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_cdt_mut<V>(_visitor: &mut V, _node: &mut Token!["·"])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_cdt_eql_mut<V>(_visitor: &mut V, _node: &mut Token!["·="])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_box_mut<V>(_visitor: &mut V, _node: &mut Token!["⊠"])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_box_eql_mut<V>(_visitor: &mut V, _node: &mut Token!["⊠="])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_sfp_mut<V>(_visitor: &mut V, _node: &mut Token!["⧢"])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_sfp_eql_mut<V>(_visitor: &mut V, _node: &mut Token!["⧢="])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_and_mut<V>(_visitor: &mut V, _node: &mut Token![and])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_or_mut<V>(_visitor: &mut V, _node: &mut Token![or])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_space_mut<V>(_visitor: &mut V, _node: &mut Token![SPACE])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_xor_mut<V>(_visitor: &mut V, _node: &mut Token![xor])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_bng_mut<V>(_visitor: &mut V, _node: &mut Token![!])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_graded_mut<V>(_visitor: &mut V, _node: &mut Token![(*)])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_crt_bng_mut<V>(_visitor: &mut V, _node: &mut Token![^!])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_crt_mul_mut<V>(_visitor: &mut V, _node: &mut Token![^*])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_crt_tld_mut<V>(_visitor: &mut V, _node: &mut Token![^~])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_ubs_bng_mut<V>(_visitor: &mut V, _node: &mut Token![_!])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_ubs_mul_mut<V>(_visitor: &mut V, _node: &mut Token![_*])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_ubs_tld_mut<V>(_visitor: &mut V, _node: &mut Token![_~])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_not_mut<V>(_visitor: &mut V, _node: &mut Token![not])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_break_keyword_mut<V>(_visitor: &mut V, _node: &mut Token![break])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_breakpoint_keyword_mut<V>(_visitor: &mut V, _node: &mut Token![breakpoint])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_catch_keyword_mut<V>(_visitor: &mut V, _node: &mut Token![catch])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_continue_keyword_mut<V>(_visitor: &mut V, _node: &mut Token![continue])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_do_keyword_mut<V>(_visitor: &mut V, _node: &mut Token![do])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_elapsed_time_keyword_mut<V>(_visitor: &mut V, _node: &mut Token![elapsedTime])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_elapsed_timing_keyword_mut<V>(
_visitor: &mut V,
_node: &mut Token![elapsedTiming],
) where
V: VisitMut + ?Sized,
{
}
pub fn visit_else_keyword_mut<V>(_visitor: &mut V, _node: &mut Token![else])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_except_keyword_mut<V>(_visitor: &mut V, _node: &mut Token![except])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_finish_keyword_mut<V>(_visitor: &mut V, _node: &mut Token![finish])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_for_keyword_mut<V>(_visitor: &mut V, _node: &mut Token![for])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_from_keyword_mut<V>(_visitor: &mut V, _node: &mut Token![from])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_global_keyword_mut<V>(_visitor: &mut V, _node: &mut Token![global])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_if_keyword_mut<V>(_visitor: &mut V, _node: &mut Token![if])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_in_keyword_mut<V>(_visitor: &mut V, _node: &mut Token![in])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_list_keyword_mut<V>(_visitor: &mut V, _node: &mut Token![list])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_local_keyword_mut<V>(_visitor: &mut V, _node: &mut Token![local])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_new_keyword_mut<V>(_visitor: &mut V, _node: &mut Token![new])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_of_keyword_mut<V>(_visitor: &mut V, _node: &mut Token![of])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_profile_keyword_mut<V>(_visitor: &mut V, _node: &mut Token![profile])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_return_keyword_mut<V>(_visitor: &mut V, _node: &mut Token![return])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_shield_keyword_mut<V>(_visitor: &mut V, _node: &mut Token![shield])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_step_keyword_mut<V>(_visitor: &mut V, _node: &mut Token![step])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_symbol_keyword_mut<V>(_visitor: &mut V, _node: &mut Token![symbol])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_test_keyword_mut<V>(_visitor: &mut V, _node: &mut Token![TEST])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_then_keyword_mut<V>(_visitor: &mut V, _node: &mut Token![then])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_thread_local_keyword_mut<V>(_visitor: &mut V, _node: &mut Token![threadLocal])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_thread_variable_keyword_mut<V>(
_visitor: &mut V,
_node: &mut Token![threadVariable],
) where
V: VisitMut + ?Sized,
{
}
pub fn visit_throw_keyword_mut<V>(_visitor: &mut V, _node: &mut Token![throw])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_time_keyword_mut<V>(_visitor: &mut V, _node: &mut Token![time])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_timing_keyword_mut<V>(_visitor: &mut V, _node: &mut Token![timing])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_to_keyword_mut<V>(_visitor: &mut V, _node: &mut Token![to])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_trap_keyword_mut<V>(_visitor: &mut V, _node: &mut Token![trap])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_try_keyword_mut<V>(_visitor: &mut V, _node: &mut Token![try])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_when_keyword_mut<V>(_visitor: &mut V, _node: &mut Token![when])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_while_keyword_mut<V>(_visitor: &mut V, _node: &mut Token![while])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_scl_mut<V>(_visitor: &mut V, _node: &mut Token![;])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_cma_mut<V>(_visitor: &mut V, _node: &mut Token![,])
where
V: VisitMut + ?Sized,
{
}
pub fn visit_symbol_mut<V>(_visitor: &mut V, _node: &mut Symbol)
where
V: VisitMut + ?Sized,
{
}
pub fn visit_block_comment_mut<V>(_visitor: &mut V, _node: &mut BlockComment)
where
V: VisitMut + ?Sized,
{
}
pub fn visit_line_comment_mut<V>(_visitor: &mut V, _node: &mut LineComment)
where
V: VisitMut + ?Sized,
{
}
pub fn visit_empty_component_mut<V>(_visitor: &mut V, _node: &mut EmptyComponent)
where
V: VisitMut + ?Sized,
{
}
pub fn visit_escape_sequence_mut<V>(_visitor: &mut V, _node: &mut EscapeSequence)
where
V: VisitMut + ?Sized,
{
}
pub fn visit_float_literal_mut<V>(_visitor: &mut V, _node: &mut FloatLiteral)
where
V: VisitMut + ?Sized,
{
}
pub fn visit_integer_literal_mut<V>(_visitor: &mut V, _node: &mut IntegerLiteral)
where
V: VisitMut + ?Sized,
{
}
pub fn visit_raw_string_content_mut<V>(_visitor: &mut V, _node: &mut RawStringContent)
where
V: VisitMut + ?Sized,
{
}
pub fn visit_string_content_mut<V>(_visitor: &mut V, _node: &mut StringContent)
where
V: VisitMut + ?Sized,
{
}
pub fn visit_source_file_mut<V>(visitor: &mut V, node: &mut SourceFile)
where
V: VisitMut + ?Sized,
{
for value in &mut node.elements {
visitor.visit_any_cell_mut(value);
}
}
pub fn visit_expression_cell_mut<V>(visitor: &mut V, node: &mut ExpressionCell)
where
V: VisitMut + ?Sized,
{
visitor.visit_expr_mut((&mut node.value).as_mut());
}
pub fn visit_sequence_cell_mut<V>(visitor: &mut V, node: &mut SequenceCell)
where
V: VisitMut + ?Sized,
{
visitor.visit_naked_sequence_mut((&mut node.value).as_mut());
}
pub fn visit_naked_sequence_mut<V>(visitor: &mut V, node: &mut NakedSequence)
where
V: VisitMut + ?Sized,
{
for value in &mut node.elements {
visitor.visit_component_mut(value);
}
}
pub fn visit_muted_cell_mut<V>(visitor: &mut V, node: &mut MutedCell)
where
V: VisitMut + ?Sized,
{
for value in &mut node.elements {
visitor.visit_component_mut(value);
}
visitor.visit_scl_mut(&mut node.semicolon);
}
pub fn visit_muted_group_mut<V>(visitor: &mut V, node: &mut MutedGroup)
where
V: VisitMut + ?Sized,
{
for value in &mut node.elements {
visitor.visit_component_mut(value);
}
visitor.visit_scl_mut(&mut node.semicolon);
}
pub fn visit_array_mut<V>(visitor: &mut V, node: &mut Array)
where
V: VisitMut + ?Sized,
{
for value in &mut node.muted {
visitor.visit_muted_group_mut(value);
}
for value in &mut node.elements {
visitor.visit_component_mut(value);
}
}
pub fn visit_list_mut<V>(visitor: &mut V, node: &mut List)
where
V: VisitMut + ?Sized,
{
for value in &mut node.muted {
visitor.visit_muted_group_mut(value);
}
for value in &mut node.elements {
visitor.visit_component_mut(value);
}
}
pub fn visit_angle_bar_list_mut<V>(visitor: &mut V, node: &mut AngleBarList)
where
V: VisitMut + ?Sized,
{
for value in &mut node.muted {
visitor.visit_muted_group_mut(value);
}
for value in &mut node.elements {
visitor.visit_component_mut(value);
}
}
pub fn visit_sequence_mut<V>(visitor: &mut V, node: &mut Sequence)
where
V: VisitMut + ?Sized,
{
for value in &mut node.muted {
visitor.visit_muted_group_mut(value);
}
for value in &mut node.elements {
visitor.visit_component_mut(value);
}
}
pub fn visit_parenthesized_expression_mut<V>(
visitor: &mut V,
node: &mut ParenthesizedExpression,
) where
V: VisitMut + ?Sized,
{
for value in &mut node.muted {
visitor.visit_muted_group_mut(value);
}
if let Some(value) = (&mut node.value).as_mut() {
visitor.visit_expr_mut((value).as_mut());
}
}
pub fn visit_string_literal_mut<V>(visitor: &mut V, node: &mut StringLiteral)
where
V: VisitMut + ?Sized,
{
for value in &mut node.elements {
visitor.visit_string_element_mut(value);
}
}
pub fn visit_raw_string_literal_mut<V>(visitor: &mut V, node: &mut RawStringLiteral)
where
V: VisitMut + ?Sized,
{
for value in &mut node.elements {
visitor.visit_raw_string_element_mut(value);
}
}
pub fn visit_binary_expression_mut<V>(visitor: &mut V, node: &mut BinaryExpression)
where
V: VisitMut + ?Sized,
{
visitor.visit_expr_mut((&mut node.left).as_mut());
visitor.visit_binary_operator_mut(&mut node.operator);
visitor.visit_expr_mut((&mut node.right).as_mut());
}
pub fn visit_adjacent_expression_mut<V>(visitor: &mut V, node: &mut AdjacentExpression)
where
V: VisitMut + ?Sized,
{
visitor.visit_expr_mut((&mut node.left).as_mut());
visitor.visit_expr_mut((&mut node.right).as_mut());
}
pub fn visit_prefix_expression_mut<V>(visitor: &mut V, node: &mut PrefixExpression)
where
V: VisitMut + ?Sized,
{
visitor.visit_prefix_operator_mut(&mut node.operator);
visitor.visit_expr_mut((&mut node.operand).as_mut());
}
pub fn visit_postfix_expression_mut<V>(visitor: &mut V, node: &mut PostfixExpression)
where
V: VisitMut + ?Sized,
{
visitor.visit_expr_mut((&mut node.operand).as_mut());
visitor.visit_postfix_operator_mut(&mut node.operator);
}
pub fn visit_lambda_expression_mut<V>(visitor: &mut V, node: &mut LambdaExpression)
where
V: VisitMut + ?Sized,
{
visitor.visit_lambda_parameters_mut((&mut node.parameters).as_mut());
visitor.visit_sub_gst_mut(&mut node.operator);
visitor.visit_expr_mut((&mut node.body).as_mut());
}
pub fn visit_assignment_mut<V>(visitor: &mut V, node: &mut Assignment)
where
V: VisitMut + ?Sized,
{
visitor.visit_symbol_mut((&mut node.left).as_mut());
visitor.visit_eql_mut(&mut node.operator);
visitor.visit_expr_mut((&mut node.right).as_mut());
}
pub fn visit_local_assignment_mut<V>(visitor: &mut V, node: &mut LocalAssignment)
where
V: VisitMut + ?Sized,
{
visitor.visit_symbol_mut((&mut node.left).as_mut());
visitor.visit_col_eql_mut(&mut node.operator);
visitor.visit_expr_mut((&mut node.right).as_mut());
}
pub fn visit_binary_assignment_mut<V>(visitor: &mut V, node: &mut BinaryAssignment)
where
V: VisitMut + ?Sized,
{
visitor.visit_binary_expression_mut((&mut node.left).as_mut());
visitor.visit_eql_mut(&mut node.operator);
visitor.visit_expr_mut((&mut node.right).as_mut());
}
pub fn visit_binary_installation_mut<V>(visitor: &mut V, node: &mut BinaryInstallation)
where
V: VisitMut + ?Sized,
{
visitor.visit_binary_expression_mut((&mut node.left).as_mut());
visitor.visit_col_eql_mut(&mut node.operator);
visitor.visit_expr_mut((&mut node.right).as_mut());
}
pub fn visit_prefix_assignment_mut<V>(visitor: &mut V, node: &mut PrefixAssignment)
where
V: VisitMut + ?Sized,
{
visitor.visit_prefix_expression_mut((&mut node.left).as_mut());
visitor.visit_eql_mut(&mut node.operator);
visitor.visit_expr_mut((&mut node.right).as_mut());
}
pub fn visit_prefix_installation_mut<V>(visitor: &mut V, node: &mut PrefixInstallation)
where
V: VisitMut + ?Sized,
{
visitor.visit_prefix_expression_mut((&mut node.left).as_mut());
visitor.visit_col_eql_mut(&mut node.operator);
visitor.visit_expr_mut((&mut node.right).as_mut());
}
pub fn visit_postfix_assignment_mut<V>(visitor: &mut V, node: &mut PostfixAssignment)
where
V: VisitMut + ?Sized,
{
visitor.visit_postfix_expression_mut((&mut node.left).as_mut());
visitor.visit_eql_mut(&mut node.operator);
visitor.visit_expr_mut((&mut node.right).as_mut());
}
pub fn visit_postfix_installation_mut<V>(visitor: &mut V, node: &mut PostfixInstallation)
where
V: VisitMut + ?Sized,
{
visitor.visit_postfix_expression_mut((&mut node.left).as_mut());
visitor.visit_col_eql_mut(&mut node.operator);
visitor.visit_expr_mut((&mut node.right).as_mut());
}
pub fn visit_structured_binding_mut<V>(visitor: &mut V, node: &mut StructuredBinding)
where
V: VisitMut + ?Sized,
{
visitor.visit_binding_pack_mut((&mut node.binding_pack).as_mut());
visitor.visit_eql_mut(&mut node.operator);
visitor.visit_expr_mut((&mut node.right).as_mut());
}
pub fn visit_local_structured_binding_mut<V>(
visitor: &mut V,
node: &mut LocalStructuredBinding,
) where
V: VisitMut + ?Sized,
{
visitor.visit_binding_pack_mut((&mut node.binding_pack).as_mut());
visitor.visit_col_eql_mut(&mut node.operator);
visitor.visit_expr_mut((&mut node.right).as_mut());
}
pub fn visit_evaluated_assignment_mut<V>(visitor: &mut V, node: &mut EvaluatedAssignment)
where
V: VisitMut + ?Sized,
{
visitor.visit_expr_mut((&mut node.left).as_mut());
visitor.visit_lst_sub_mut(&mut node.operator);
visitor.visit_expr_mut((&mut node.right).as_mut());
}
pub fn visit_option_expression_mut<V>(visitor: &mut V, node: &mut OptionExpression)
where
V: VisitMut + ?Sized,
{
visitor.visit_expr_mut((&mut node.left).as_mut());
visitor.visit_eql_gst_mut(&mut node.operator);
visitor.visit_expr_mut((&mut node.right).as_mut());
}
pub fn visit_then_clause_mut<V>(visitor: &mut V, node: &mut ThenClause)
where
V: VisitMut + ?Sized,
{
visitor.visit_then_keyword_mut(&mut node.keyword);
visitor.visit_expr_mut((&mut node.value).as_mut());
}
pub fn visit_else_clause_mut<V>(visitor: &mut V, node: &mut ElseClause)
where
V: VisitMut + ?Sized,
{
visitor.visit_else_keyword_mut(&mut node.keyword);
visitor.visit_expr_mut((&mut node.value).as_mut());
}
pub fn visit_if_statement_mut<V>(visitor: &mut V, node: &mut IfStatement)
where
V: VisitMut + ?Sized,
{
visitor.visit_if_keyword_mut(&mut node.keyword);
visitor.visit_expr_mut((&mut node.condition).as_mut());
visitor.visit_then_clause_mut((&mut node.then_clause).as_mut());
if let Some(value) = (&mut node.else_clause).as_mut() {
visitor.visit_else_clause_mut((value).as_mut());
}
}
pub fn visit_loop_body_mut<V>(visitor: &mut V, node: &mut LoopBody)
where
V: VisitMut + ?Sized,
{
if let Some(value) = (&mut node.list_keyword).as_mut() {
visitor.visit_list_keyword_mut(value);
}
if let Some(value) = (&mut node.listed_value).as_mut() {
visitor.visit_expr_mut((value).as_mut());
}
if let Some(value) = (&mut node.do_keyword).as_mut() {
visitor.visit_do_keyword_mut(value);
}
if let Some(value) = (&mut node.ignored_value).as_mut() {
visitor.visit_expr_mut((value).as_mut());
}
}
pub fn visit_iteration_range_mut<V>(visitor: &mut V, node: &mut IterationRange)
where
V: VisitMut + ?Sized,
{
if let Some(value) = (&mut node.in_keyword).as_mut() {
visitor.visit_in_keyword_mut(value);
}
if let Some(value) = (&mut node.iterated_collection).as_mut() {
visitor.visit_expr_mut((value).as_mut());
}
if let Some(value) = (&mut node.from_keyword).as_mut() {
visitor.visit_from_keyword_mut(value);
}
if let Some(value) = (&mut node.range_start).as_mut() {
visitor.visit_expr_mut((value).as_mut());
}
if let Some(value) = (&mut node.to_keyword).as_mut() {
visitor.visit_to_keyword_mut(value);
}
if let Some(value) = (&mut node.range_end).as_mut() {
visitor.visit_expr_mut((value).as_mut());
}
}
pub fn visit_for_loop_mut<V>(visitor: &mut V, node: &mut ForLoop)
where
V: VisitMut + ?Sized,
{
visitor.visit_for_keyword_mut(&mut node.keyword);
visitor.visit_symbol_mut((&mut node.variable).as_mut());
if let Some(value) = (&mut node.range).as_mut() {
visitor.visit_iteration_range_mut((value).as_mut());
}
if let Some(value) = (&mut node.when_keyword).as_mut() {
visitor.visit_when_keyword_mut(value);
}
if let Some(value) = (&mut node.filter).as_mut() {
visitor.visit_expr_mut((value).as_mut());
}
visitor.visit_loop_body_mut((&mut node.body).as_mut());
}
pub fn visit_while_loop_mut<V>(visitor: &mut V, node: &mut WhileLoop)
where
V: VisitMut + ?Sized,
{
visitor.visit_while_keyword_mut(&mut node.keyword);
visitor.visit_expr_mut((&mut node.condition).as_mut());
visitor.visit_loop_body_mut((&mut node.body).as_mut());
}
pub fn visit_new_statement_mut<V>(visitor: &mut V, node: &mut NewStatement)
where
V: VisitMut + ?Sized,
{
visitor.visit_new_keyword_mut(&mut node.keyword);
visitor.visit_expr_mut((&mut node.class).as_mut());
if let Some(value) = (&mut node.of_keyword).as_mut() {
visitor.visit_of_keyword_mut(value);
}
if let Some(value) = (&mut node.parent).as_mut() {
visitor.visit_expr_mut((value).as_mut());
}
if let Some(value) = (&mut node.from_keyword).as_mut() {
visitor.visit_from_keyword_mut(value);
}
if let Some(value) = (&mut node.instance).as_mut() {
visitor.visit_expr_mut((value).as_mut());
}
}
pub fn visit_debug_clause_mut<V>(visitor: &mut V, node: &mut DebugClause)
where
V: VisitMut + ?Sized,
{
visitor.visit_debug_keyword_mut(&mut node.keyword);
if let Some(value) = (&mut node.value).as_mut() {
visitor.visit_expr_mut((value).as_mut());
}
}
pub fn visit_break_statement_mut<V>(visitor: &mut V, node: &mut BreakStatement)
where
V: VisitMut + ?Sized,
{
visitor.visit_break_keyword_mut(&mut node.keyword);
if let Some(value) = (&mut node.value).as_mut() {
visitor.visit_expr_mut((value).as_mut());
}
}
pub fn visit_continue_statement_mut<V>(visitor: &mut V, node: &mut ContinueStatement)
where
V: VisitMut + ?Sized,
{
visitor.visit_continue_keyword_mut(&mut node.keyword);
if let Some(value) = (&mut node.value).as_mut() {
visitor.visit_expr_mut((value).as_mut());
}
}
pub fn visit_return_statement_mut<V>(visitor: &mut V, node: &mut ReturnStatement)
where
V: VisitMut + ?Sized,
{
visitor.visit_return_keyword_mut(&mut node.keyword);
if let Some(value) = (&mut node.value).as_mut() {
visitor.visit_expr_mut((value).as_mut());
}
}
pub fn visit_catch_statement_mut<V>(visitor: &mut V, node: &mut CatchStatement)
where
V: VisitMut + ?Sized,
{
visitor.visit_catch_keyword_mut(&mut node.keyword);
visitor.visit_expr_mut((&mut node.value).as_mut());
}
pub fn visit_throw_statement_mut<V>(visitor: &mut V, node: &mut ThrowStatement)
where
V: VisitMut + ?Sized,
{
visitor.visit_throw_keyword_mut(&mut node.keyword);
visitor.visit_expr_mut((&mut node.value).as_mut());
}
pub fn visit_trap_statement_mut<V>(visitor: &mut V, node: &mut TrapStatement)
where
V: VisitMut + ?Sized,
{
visitor.visit_trap_keyword_mut(&mut node.keyword);
visitor.visit_expr_mut((&mut node.value).as_mut());
}
pub fn visit_except_clause_mut<V>(visitor: &mut V, node: &mut ExceptClause)
where
V: VisitMut + ?Sized,
{
visitor.visit_except_keyword_mut(&mut node.keyword);
visitor.visit_symbol_mut((&mut node.exception).as_mut());
visitor.visit_do_keyword_mut(&mut node.do_keyword);
visitor.visit_expr_mut((&mut node.value).as_mut());
}
pub fn visit_try_statement_mut<V>(visitor: &mut V, node: &mut TryStatement)
where
V: VisitMut + ?Sized,
{
visitor.visit_try_keyword_mut(&mut node.keyword);
visitor.visit_expr_mut((&mut node.value).as_mut());
if let Some(value) = (&mut node.then_clause).as_mut() {
visitor.visit_then_clause_mut((value).as_mut());
}
if let Some(value) = (&mut node.fallback).as_mut() {
visitor.visit_try_fallback_mut((value).as_mut());
}
}
pub fn visit_quote_expression_mut<V>(visitor: &mut V, node: &mut QuoteExpression)
where
V: VisitMut + ?Sized,
{
visitor.visit_quote_specifier_mut(&mut node.specifier);
visitor.visit_symbol_mut((&mut node.token).as_mut());
}
pub fn visit_prefix_operator_mut<V>(visitor: &mut V, node: &mut PrefixOperator)
where
V: VisitMut + ?Sized,
{
match node {
PrefixOperator::Hsh(node) => {
visitor.visit_hsh_mut(node);
}
PrefixOperator::Mul(node) => {
visitor.visit_mul_mut(node);
}
PrefixOperator::Add(node) => {
visitor.visit_add_mut(node);
}
PrefixOperator::Sub(node) => {
visitor.visit_sub_mut(node);
}
PrefixOperator::Lst(node) => {
visitor.visit_lst_mut(node);
}
PrefixOperator::LstLst(node) => {
visitor.visit_lst_lst_mut(node);
}
PrefixOperator::LstEql(node) => {
visitor.visit_lst_eql_mut(node);
}
PrefixOperator::LstEqlEql(node) => {
visitor.visit_lst_eql_eql_mut(node);
}
PrefixOperator::LstEqlEqlEql(node) => {
visitor.visit_lst_eql_eql_eql_mut(node);
}
PrefixOperator::Gst(node) => {
visitor.visit_gst_mut(node);
}
PrefixOperator::GstEql(node) => {
visitor.visit_gst_eql_mut(node);
}
PrefixOperator::Qsm(node) => {
visitor.visit_qsm_mut(node);
}
PrefixOperator::QsmQsm(node) => {
visitor.visit_qsm_qsm_mut(node);
}
PrefixOperator::PipSub(node) => {
visitor.visit_pip_sub_mut(node);
}
PrefixOperator::Tld(node) => {
visitor.visit_tld_mut(node);
}
PrefixOperator::Not(node) => {
visitor.visit_not_mut(node);
}
}
}
pub fn visit_binary_operator_mut<V>(visitor: &mut V, node: &mut BinaryOperator)
where
V: VisitMut + ?Sized,
{
match node {
BinaryOperator::BngEql(node) => {
visitor.visit_bng_eql_mut(node);
}
BinaryOperator::Hsh(node) => {
visitor.visit_hsh_mut(node);
}
BinaryOperator::HshQsm(node) => {
visitor.visit_hsh_qsm_mut(node);
}
BinaryOperator::Mod(node) => {
visitor.visit_mod_mut(node);
}
BinaryOperator::ModEql(node) => {
visitor.visit_mod_eql_mut(node);
}
BinaryOperator::Amp(node) => {
visitor.visit_amp_mut(node);
}
BinaryOperator::AmpEql(node) => {
visitor.visit_amp_eql_mut(node);
}
BinaryOperator::Mul(node) => {
visitor.visit_mul_mut(node);
}
BinaryOperator::MulEql(node) => {
visitor.visit_mul_eql_mut(node);
}
BinaryOperator::MulMul(node) => {
visitor.visit_mul_mul_mut(node);
}
BinaryOperator::MulMulEql(node) => {
visitor.visit_mul_mul_eql_mut(node);
}
BinaryOperator::Add(node) => {
visitor.visit_add_mut(node);
}
BinaryOperator::AddEql(node) => {
visitor.visit_add_eql_mut(node);
}
BinaryOperator::AddAdd(node) => {
visitor.visit_add_add_mut(node);
}
BinaryOperator::AddAddEql(node) => {
visitor.visit_add_add_eql_mut(node);
}
BinaryOperator::Sub(node) => {
visitor.visit_sub_mut(node);
}
BinaryOperator::SubEql(node) => {
visitor.visit_sub_eql_mut(node);
}
BinaryOperator::Dot(node) => {
visitor.visit_dot_mut(node);
}
BinaryOperator::DotDot(node) => {
visitor.visit_dot_dot_mut(node);
}
BinaryOperator::DotDotEql(node) => {
visitor.visit_dot_dot_eql_mut(node);
}
BinaryOperator::DotDotLst(node) => {
visitor.visit_dot_dot_lst_mut(node);
}
BinaryOperator::DotDotLstEql(node) => {
visitor.visit_dot_dot_lst_eql_mut(node);
}
BinaryOperator::DotQsm(node) => {
visitor.visit_dot_qsm_mut(node);
}
BinaryOperator::Slh(node) => {
visitor.visit_slh_mut(node);
}
BinaryOperator::SlhEql(node) => {
visitor.visit_slh_eql_mut(node);
}
BinaryOperator::SlhSlh(node) => {
visitor.visit_slh_slh_mut(node);
}
BinaryOperator::SlhSlhEql(node) => {
visitor.visit_slh_slh_eql_mut(node);
}
BinaryOperator::Col(node) => {
visitor.visit_col_mut(node);
}
BinaryOperator::ColEql(node) => {
visitor.visit_col_eql_mut(node);
}
BinaryOperator::Lst(node) => {
visitor.visit_lst_mut(node);
}
BinaryOperator::LstLst(node) => {
visitor.visit_lst_lst_mut(node);
}
BinaryOperator::LstLstEql(node) => {
visitor.visit_lst_lst_eql_mut(node);
}
BinaryOperator::LstEql(node) => {
visitor.visit_lst_eql_mut(node);
}
BinaryOperator::LstEqlEql(node) => {
visitor.visit_lst_eql_eql_mut(node);
}
BinaryOperator::LstEqlEqlEql(node) => {
visitor.visit_lst_eql_eql_eql_mut(node);
}
BinaryOperator::LstEqlEqlGst(node) => {
visitor.visit_lst_eql_eql_gst_mut(node);
}
BinaryOperator::LstEqlEqlGstEql(node) => {
visitor.visit_lst_eql_eql_gst_eql_mut(node);
}
BinaryOperator::EqlBngEql(node) => {
visitor.visit_eql_bng_eql_mut(node);
}
BinaryOperator::EqlEql(node) => {
visitor.visit_eql_eql_mut(node);
}
BinaryOperator::EqlEqlEql(node) => {
visitor.visit_eql_eql_eql_mut(node);
}
BinaryOperator::EqlEqlEqlGst(node) => {
visitor.visit_eql_eql_eql_gst_mut(node);
}
BinaryOperator::EqlEqlEqlGstEql(node) => {
visitor.visit_eql_eql_eql_gst_eql_mut(node);
}
BinaryOperator::EqlEqlGst(node) => {
visitor.visit_eql_eql_gst_mut(node);
}
BinaryOperator::EqlEqlGstEql(node) => {
visitor.visit_eql_eql_gst_eql_mut(node);
}
BinaryOperator::Gst(node) => {
visitor.visit_gst_mut(node);
}
BinaryOperator::GstEql(node) => {
visitor.visit_gst_eql_mut(node);
}
BinaryOperator::GstGst(node) => {
visitor.visit_gst_gst_mut(node);
}
BinaryOperator::GstGstEql(node) => {
visitor.visit_gst_gst_eql_mut(node);
}
BinaryOperator::Qsm(node) => {
visitor.visit_qsm_mut(node);
}
BinaryOperator::QsmQsm(node) => {
visitor.visit_qsm_qsm_mut(node);
}
BinaryOperator::QsmQsmEql(node) => {
visitor.visit_qsm_qsm_eql_mut(node);
}
BinaryOperator::Att(node) => {
visitor.visit_att_mut(node);
}
BinaryOperator::AttEql(node) => {
visitor.visit_att_eql_mut(node);
}
BinaryOperator::AttAtt(node) => {
visitor.visit_att_att_mut(node);
}
BinaryOperator::AttAttEql(node) => {
visitor.visit_att_att_eql_mut(node);
}
BinaryOperator::AttAttQsm(node) => {
visitor.visit_att_att_qsm_mut(node);
}
BinaryOperator::AttAttQsmEql(node) => {
visitor.visit_att_att_qsm_eql_mut(node);
}
BinaryOperator::Bsl(node) => {
visitor.visit_bsl_mut(node);
}
BinaryOperator::BslEql(node) => {
visitor.visit_bsl_eql_mut(node);
}
BinaryOperator::BslBsl(node) => {
visitor.visit_bsl_bsl_mut(node);
}
BinaryOperator::BslBslEql(node) => {
visitor.visit_bsl_bsl_eql_mut(node);
}
BinaryOperator::Crt(node) => {
visitor.visit_crt_mut(node);
}
BinaryOperator::CrtEql(node) => {
visitor.visit_crt_eql_mut(node);
}
BinaryOperator::CrtMulMul(node) => {
visitor.visit_crt_mul_mul_mut(node);
}
BinaryOperator::CrtMulMulEql(node) => {
visitor.visit_crt_mul_mul_eql_mut(node);
}
BinaryOperator::CrtLst(node) => {
visitor.visit_crt_lst_mut(node);
}
BinaryOperator::CrtLstEql(node) => {
visitor.visit_crt_lst_eql_mut(node);
}
BinaryOperator::CrtGst(node) => {
visitor.visit_crt_gst_mut(node);
}
BinaryOperator::CrtGstEql(node) => {
visitor.visit_crt_gst_eql_mut(node);
}
BinaryOperator::CrtCrt(node) => {
visitor.visit_crt_crt_mut(node);
}
BinaryOperator::CrtCrtEql(node) => {
visitor.visit_crt_crt_eql_mut(node);
}
BinaryOperator::Ubs(node) => {
visitor.visit_ubs_mut(node);
}
BinaryOperator::UbsEql(node) => {
visitor.visit_ubs_eql_mut(node);
}
BinaryOperator::UbsLst(node) => {
visitor.visit_ubs_lst_mut(node);
}
BinaryOperator::UbsLstEql(node) => {
visitor.visit_ubs_lst_eql_mut(node);
}
BinaryOperator::UbsGst(node) => {
visitor.visit_ubs_gst_mut(node);
}
BinaryOperator::UbsGstEql(node) => {
visitor.visit_ubs_gst_eql_mut(node);
}
BinaryOperator::Pip(node) => {
visitor.visit_pip_mut(node);
}
BinaryOperator::PipEql(node) => {
visitor.visit_pip_eql_mut(node);
}
BinaryOperator::PipSub(node) => {
visitor.visit_pip_sub_mut(node);
}
BinaryOperator::PipSubEql(node) => {
visitor.visit_pip_sub_eql_mut(node);
}
BinaryOperator::PipUbs(node) => {
visitor.visit_pip_ubs_mut(node);
}
BinaryOperator::PipUbsEql(node) => {
visitor.visit_pip_ubs_eql_mut(node);
}
BinaryOperator::PipPip(node) => {
visitor.visit_pip_pip_mut(node);
}
BinaryOperator::PipPipEql(node) => {
visitor.visit_pip_pip_eql_mut(node);
}
BinaryOperator::Tld(node) => {
visitor.visit_tld_mut(node);
}
BinaryOperator::TldEql(node) => {
visitor.visit_tld_eql_mut(node);
}
BinaryOperator::Cdt(node) => {
visitor.visit_cdt_mut(node);
}
BinaryOperator::CdtEql(node) => {
visitor.visit_cdt_eql_mut(node);
}
BinaryOperator::Box(node) => {
visitor.visit_box_mut(node);
}
BinaryOperator::BoxEql(node) => {
visitor.visit_box_eql_mut(node);
}
BinaryOperator::Sfp(node) => {
visitor.visit_sfp_mut(node);
}
BinaryOperator::SfpEql(node) => {
visitor.visit_sfp_eql_mut(node);
}
BinaryOperator::And(node) => {
visitor.visit_and_mut(node);
}
BinaryOperator::Or(node) => {
visitor.visit_or_mut(node);
}
BinaryOperator::Space(node) => {
visitor.visit_space_mut(node);
}
BinaryOperator::Xor(node) => {
visitor.visit_xor_mut(node);
}
}
}
pub fn visit_postfix_operator_mut<V>(visitor: &mut V, node: &mut PostfixOperator)
where
V: VisitMut + ?Sized,
{
match node {
PostfixOperator::Bng(node) => {
visitor.visit_bng_mut(node);
}
PostfixOperator::Graded(node) => {
visitor.visit_graded_mut(node);
}
PostfixOperator::CrtBng(node) => {
visitor.visit_crt_bng_mut(node);
}
PostfixOperator::CrtMul(node) => {
visitor.visit_crt_mul_mut(node);
}
PostfixOperator::CrtTld(node) => {
visitor.visit_crt_tld_mut(node);
}
PostfixOperator::UbsBng(node) => {
visitor.visit_ubs_bng_mut(node);
}
PostfixOperator::UbsMul(node) => {
visitor.visit_ubs_mul_mut(node);
}
PostfixOperator::UbsTld(node) => {
visitor.visit_ubs_tld_mut(node);
}
}
}
pub fn visit_debug_keyword_mut<V>(visitor: &mut V, node: &mut DebugKeyword)
where
V: VisitMut + ?Sized,
{
match node {
DebugKeyword::Step(node) => {
visitor.visit_step_keyword_mut(node);
}
DebugKeyword::Finish(node) => {
visitor.visit_finish_keyword_mut(node);
}
DebugKeyword::Shield(node) => {
visitor.visit_shield_keyword_mut(node);
}
DebugKeyword::Test(node) => {
visitor.visit_test_keyword_mut(node);
}
DebugKeyword::Time(node) => {
visitor.visit_time_keyword_mut(node);
}
DebugKeyword::Timing(node) => {
visitor.visit_timing_keyword_mut(node);
}
DebugKeyword::Breakpoint(node) => {
visitor.visit_breakpoint_keyword_mut(node);
}
DebugKeyword::ElapsedTime(node) => {
visitor.visit_elapsed_time_keyword_mut(node);
}
DebugKeyword::ElapsedTiming(node) => {
visitor.visit_elapsed_timing_keyword_mut(node);
}
DebugKeyword::Profile(node) => {
visitor.visit_profile_keyword_mut(node);
}
}
}
pub fn visit_try_fallback_mut<V>(visitor: &mut V, node: &mut TryFallback)
where
V: VisitMut + ?Sized,
{
match node {
TryFallback::ExceptClause(node) => {
visitor.visit_except_clause_mut(node);
}
TryFallback::ElseClause(node) => {
visitor.visit_else_clause_mut(node);
}
}
}
pub fn visit_quote_specifier_mut<V>(visitor: &mut V, node: &mut QuoteSpecifier)
where
V: VisitMut + ?Sized,
{
match node {
QuoteSpecifier::Symbol(node) => {
visitor.visit_symbol_keyword_mut(node);
}
QuoteSpecifier::Local(node) => {
visitor.visit_local_keyword_mut(node);
}
QuoteSpecifier::Global(node) => {
visitor.visit_global_keyword_mut(node);
}
QuoteSpecifier::ThreadVariable(node) => {
visitor.visit_thread_variable_keyword_mut(node);
}
QuoteSpecifier::ThreadLocal(node) => {
visitor.visit_thread_local_keyword_mut(node);
}
}
}
pub fn visit_any_cell_mut<V>(visitor: &mut V, node: &mut AnyCell)
where
V: VisitMut + ?Sized,
{
match node {
AnyCell::ExpressionCell(node) => {
visitor.visit_expression_cell_mut(node);
}
AnyCell::SequenceCell(node) => {
visitor.visit_sequence_cell_mut(node);
}
AnyCell::MutedCell(node) => {
visitor.visit_muted_cell_mut(node);
}
}
}
pub fn visit_component_mut<V>(visitor: &mut V, node: &mut Component)
where
V: VisitMut + ?Sized,
{
match node {
Component::EmptyComponent(node) => {
visitor.visit_empty_component_mut(node);
}
Component::Expr(node) => {
visitor.visit_expr_mut(node);
}
}
}
pub fn visit_sequence_element_mut<V>(visitor: &mut V, node: &mut SequenceElement)
where
V: VisitMut + ?Sized,
{
match node {
SequenceElement::Component(node) => {
visitor.visit_component_mut(node);
}
SequenceElement::MutedGroup(node) => {
visitor.visit_muted_group_mut(node);
}
}
}
pub fn visit_string_element_mut<V>(visitor: &mut V, node: &mut StringElement)
where
V: VisitMut + ?Sized,
{
match node {
StringElement::EscapeSequence(node) => {
visitor.visit_escape_sequence_mut(node);
}
StringElement::StringContent(node) => {
visitor.visit_string_content_mut(node);
}
}
}
pub fn visit_raw_string_element_mut<V>(visitor: &mut V, node: &mut RawStringElement)
where
V: VisitMut + ?Sized,
{
match node {
RawStringElement::EscapeSequence(node) => {
visitor.visit_escape_sequence_mut(node);
}
RawStringElement::RawStringContent(node) => {
visitor.visit_raw_string_content_mut(node);
}
}
}
pub fn visit_collection_mut<V>(visitor: &mut V, node: &mut Collection)
where
V: VisitMut + ?Sized,
{
match node {
Collection::ParenthesizedExpression(node) => {
visitor.visit_parenthesized_expression_mut(node);
}
Collection::Sequence(node) => {
visitor.visit_sequence_mut(node);
}
Collection::List(node) => {
visitor.visit_list_mut(node);
}
Collection::Array(node) => {
visitor.visit_array_mut(node);
}
Collection::AngleBarList(node) => {
visitor.visit_angle_bar_list_mut(node);
}
}
}
pub fn visit_binding_pack_mut<V>(visitor: &mut V, node: &mut BindingPack)
where
V: VisitMut + ?Sized,
{
match node {
BindingPack::ParenthesizedExpression(node) => {
visitor.visit_parenthesized_expression_mut(node);
}
BindingPack::Sequence(node) => {
visitor.visit_sequence_mut(node);
}
BindingPack::List(node) => {
visitor.visit_list_mut(node);
}
BindingPack::Array(node) => {
visitor.visit_array_mut(node);
}
BindingPack::AngleBarList(node) => {
visitor.visit_angle_bar_list_mut(node);
}
}
}
pub fn visit_lambda_parameters_mut<V>(visitor: &mut V, node: &mut LambdaParameters)
where
V: VisitMut + ?Sized,
{
match node {
LambdaParameters::Symbol(node) => {
visitor.visit_symbol_mut(node);
}
LambdaParameters::ParenthesizedExpression(node) => {
visitor.visit_parenthesized_expression_mut(node);
}
LambdaParameters::Sequence(node) => {
visitor.visit_sequence_mut(node);
}
LambdaParameters::List(node) => {
visitor.visit_list_mut(node);
}
LambdaParameters::Array(node) => {
visitor.visit_array_mut(node);
}
LambdaParameters::AngleBarList(node) => {
visitor.visit_angle_bar_list_mut(node);
}
}
}
pub fn visit_operator_expr_mut<V>(visitor: &mut V, node: &mut OperatorExpr)
where
V: VisitMut + ?Sized,
{
match node {
OperatorExpr::AdjacentExpression(node) => {
visitor.visit_adjacent_expression_mut(node);
}
OperatorExpr::BinaryExpression(node) => {
visitor.visit_binary_expression_mut(node);
}
OperatorExpr::PrefixExpression(node) => {
visitor.visit_prefix_expression_mut(node);
}
OperatorExpr::PostfixExpression(node) => {
visitor.visit_postfix_expression_mut(node);
}
}
}
pub fn visit_assignment_expr_mut<V>(visitor: &mut V, node: &mut AssignmentExpr)
where
V: VisitMut + ?Sized,
{
match node {
AssignmentExpr::Assignment(node) => {
visitor.visit_assignment_mut(node);
}
AssignmentExpr::LocalAssignment(node) => {
visitor.visit_local_assignment_mut(node);
}
AssignmentExpr::BinaryAssignment(node) => {
visitor.visit_binary_assignment_mut(node);
}
AssignmentExpr::BinaryInstallation(node) => {
visitor.visit_binary_installation_mut(node);
}
AssignmentExpr::PrefixAssignment(node) => {
visitor.visit_prefix_assignment_mut(node);
}
AssignmentExpr::PrefixInstallation(node) => {
visitor.visit_prefix_installation_mut(node);
}
AssignmentExpr::PostfixAssignment(node) => {
visitor.visit_postfix_assignment_mut(node);
}
AssignmentExpr::PostfixInstallation(node) => {
visitor.visit_postfix_installation_mut(node);
}
AssignmentExpr::StructuredBinding(node) => {
visitor.visit_structured_binding_mut(node);
}
AssignmentExpr::LocalStructuredBinding(node) => {
visitor.visit_local_structured_binding_mut(node);
}
AssignmentExpr::EvaluatedAssignment(node) => {
visitor.visit_evaluated_assignment_mut(node);
}
}
}
pub fn visit_expr_mut<V>(visitor: &mut V, node: &mut Expr)
where
V: VisitMut + ?Sized,
{
match node {
Expr::Collection(node) => {
visitor.visit_collection_mut(node);
}
Expr::OperatorExpr(node) => {
visitor.visit_operator_expr_mut(node);
}
Expr::AssignmentExpr(node) => {
visitor.visit_assignment_expr_mut(node);
}
Expr::OptionExpression(node) => {
visitor.visit_option_expression_mut(node);
}
Expr::LambdaExpression(node) => {
visitor.visit_lambda_expression_mut(node);
}
Expr::IfStatement(node) => {
visitor.visit_if_statement_mut(node);
}
Expr::ForLoop(node) => {
visitor.visit_for_loop_mut(node);
}
Expr::WhileLoop(node) => {
visitor.visit_while_loop_mut(node);
}
Expr::TryStatement(node) => {
visitor.visit_try_statement_mut(node);
}
Expr::QuoteExpression(node) => {
visitor.visit_quote_expression_mut(node);
}
Expr::NewStatement(node) => {
visitor.visit_new_statement_mut(node);
}
Expr::BreakStatement(node) => {
visitor.visit_break_statement_mut(node);
}
Expr::ContinueStatement(node) => {
visitor.visit_continue_statement_mut(node);
}
Expr::ReturnStatement(node) => {
visitor.visit_return_statement_mut(node);
}
Expr::CatchStatement(node) => {
visitor.visit_catch_statement_mut(node);
}
Expr::ThrowStatement(node) => {
visitor.visit_throw_statement_mut(node);
}
Expr::TrapStatement(node) => {
visitor.visit_trap_statement_mut(node);
}
Expr::DebugClause(node) => {
visitor.visit_debug_clause_mut(node);
}
Expr::FloatLiteral(node) => {
visitor.visit_float_literal_mut(node);
}
Expr::IntegerLiteral(node) => {
visitor.visit_integer_literal_mut(node);
}
Expr::RawStringLiteral(node) => {
visitor.visit_raw_string_literal_mut(node);
}
Expr::StringLiteral(node) => {
visitor.visit_string_literal_mut(node);
}
Expr::Symbol(node) => {
visitor.visit_symbol_mut(node);
}
}
}
pub fn visit_syntax_node_mut<V>(visitor: &mut V, node: &mut SyntaxNode)
where
V: VisitMut + ?Sized,
{
match node {
SyntaxNode::SourceFile(node) => {
visitor.visit_source_file_mut(node);
}
SyntaxNode::AnyCell(node) => {
visitor.visit_any_cell_mut(node);
}
SyntaxNode::Expr(node) => {
visitor.visit_expr_mut(node);
}
}
}
};
}