#[doc(hidden)]
#[macro_export]
macro_rules! __m2_syn_fold_methods {
() => {
fn fold_bng_eql(&mut self, node: Token![!=]) -> Token![!=] {
$crate::fold::fold_bng_eql(self, node)
}
fn fold_hsh(&mut self, node: Token![#]) -> Token![#] {
$crate::fold::fold_hsh(self, node)
}
fn fold_hsh_qsm(&mut self, node: Token![#?]) -> Token![#?] {
$crate::fold::fold_hsh_qsm(self, node)
}
fn fold_mod(&mut self, node: Token![%]) -> Token![%] {
$crate::fold::fold_mod(self, node)
}
fn fold_mod_eql(&mut self, node: Token![%=]) -> Token![%=] {
$crate::fold::fold_mod_eql(self, node)
}
fn fold_amp(&mut self, node: Token![&]) -> Token![&] {
$crate::fold::fold_amp(self, node)
}
fn fold_amp_eql(&mut self, node: Token![&=]) -> Token![&=] {
$crate::fold::fold_amp_eql(self, node)
}
fn fold_mul(&mut self, node: Token![*]) -> Token![*] {
$crate::fold::fold_mul(self, node)
}
fn fold_mul_eql(&mut self, node: Token![*=]) -> Token![*=] {
$crate::fold::fold_mul_eql(self, node)
}
fn fold_mul_mul(&mut self, node: Token![**]) -> Token![**] {
$crate::fold::fold_mul_mul(self, node)
}
fn fold_mul_mul_eql(&mut self, node: Token![**=]) -> Token![**=] {
$crate::fold::fold_mul_mul_eql(self, node)
}
fn fold_add(&mut self, node: Token![+]) -> Token![+] {
$crate::fold::fold_add(self, node)
}
fn fold_add_eql(&mut self, node: Token![+=]) -> Token![+=] {
$crate::fold::fold_add_eql(self, node)
}
fn fold_add_add(&mut self, node: Token![++]) -> Token![++] {
$crate::fold::fold_add_add(self, node)
}
fn fold_add_add_eql(&mut self, node: Token![++=]) -> Token![++=] {
$crate::fold::fold_add_add_eql(self, node)
}
fn fold_sub(&mut self, node: Token![-]) -> Token![-] {
$crate::fold::fold_sub(self, node)
}
fn fold_sub_eql(&mut self, node: Token![-=]) -> Token![-=] {
$crate::fold::fold_sub_eql(self, node)
}
fn fold_sub_gst(&mut self, node: Token![->]) -> Token![->] {
$crate::fold::fold_sub_gst(self, node)
}
fn fold_dot(&mut self, node: Token![.]) -> Token![.] {
$crate::fold::fold_dot(self, node)
}
fn fold_dot_dot(&mut self, node: Token![..]) -> Token![..] {
$crate::fold::fold_dot_dot(self, node)
}
fn fold_dot_dot_eql(&mut self, node: Token![..=]) -> Token![..=] {
$crate::fold::fold_dot_dot_eql(self, node)
}
fn fold_dot_dot_lst(&mut self, node: Token![..<]) -> Token![..<] {
$crate::fold::fold_dot_dot_lst(self, node)
}
fn fold_dot_dot_lst_eql(&mut self, node: Token![..<=]) -> Token![..<=] {
$crate::fold::fold_dot_dot_lst_eql(self, node)
}
fn fold_dot_qsm(&mut self, node: Token![.?]) -> Token![.?] {
$crate::fold::fold_dot_qsm(self, node)
}
fn fold_slh(&mut self, node: Token![/]) -> Token![/] {
$crate::fold::fold_slh(self, node)
}
fn fold_slh_eql(&mut self, node: Token![/=]) -> Token![/=] {
$crate::fold::fold_slh_eql(self, node)
}
fn fold_slh_slh(&mut self, node: Token![/ /]) -> Token![/ /] {
$crate::fold::fold_slh_slh(self, node)
}
fn fold_slh_slh_eql(&mut self, node: Token![/ /=]) -> Token![/ /=] {
$crate::fold::fold_slh_slh_eql(self, node)
}
fn fold_col(&mut self, node: Token![:]) -> Token![:] {
$crate::fold::fold_col(self, node)
}
fn fold_col_eql(&mut self, node: Token![:=]) -> Token![:=] {
$crate::fold::fold_col_eql(self, node)
}
fn fold_lst(&mut self, node: Token![<]) -> Token![<] {
$crate::fold::fold_lst(self, node)
}
fn fold_lst_sub(&mut self, node: Token![<-]) -> Token![<-] {
$crate::fold::fold_lst_sub(self, node)
}
fn fold_lst_lst(&mut self, node: Token![<<]) -> Token![<<] {
$crate::fold::fold_lst_lst(self, node)
}
fn fold_lst_lst_eql(&mut self, node: Token![<<=]) -> Token![<<=] {
$crate::fold::fold_lst_lst_eql(self, node)
}
fn fold_lst_eql(&mut self, node: Token![<=]) -> Token![<=] {
$crate::fold::fold_lst_eql(self, node)
}
fn fold_lst_eql_eql(&mut self, node: Token![<==]) -> Token![<==] {
$crate::fold::fold_lst_eql_eql(self, node)
}
fn fold_lst_eql_eql_eql(&mut self, node: Token![<===]) -> Token![<===] {
$crate::fold::fold_lst_eql_eql_eql(self, node)
}
fn fold_lst_eql_eql_gst(&mut self, node: Token![<==>]) -> Token![<==>] {
$crate::fold::fold_lst_eql_eql_gst(self, node)
}
fn fold_lst_eql_eql_gst_eql(&mut self, node: Token![<==>=]) -> Token![<==>=] {
$crate::fold::fold_lst_eql_eql_gst_eql(self, node)
}
fn fold_eql(&mut self, node: Token![=]) -> Token![=] {
$crate::fold::fold_eql(self, node)
}
fn fold_eql_bng_eql(&mut self, node: Token![=!=]) -> Token![=!=] {
$crate::fold::fold_eql_bng_eql(self, node)
}
fn fold_eql_eql(&mut self, node: Token![==]) -> Token![==] {
$crate::fold::fold_eql_eql(self, node)
}
fn fold_eql_eql_eql(&mut self, node: Token![===]) -> Token![===] {
$crate::fold::fold_eql_eql_eql(self, node)
}
fn fold_eql_eql_eql_gst(&mut self, node: Token![===>]) -> Token![===>] {
$crate::fold::fold_eql_eql_eql_gst(self, node)
}
fn fold_eql_eql_eql_gst_eql(&mut self, node: Token![===>=]) -> Token![===>=] {
$crate::fold::fold_eql_eql_eql_gst_eql(self, node)
}
fn fold_eql_eql_gst(&mut self, node: Token![==>]) -> Token![==>] {
$crate::fold::fold_eql_eql_gst(self, node)
}
fn fold_eql_eql_gst_eql(&mut self, node: Token![==>=]) -> Token![==>=] {
$crate::fold::fold_eql_eql_gst_eql(self, node)
}
fn fold_eql_gst(&mut self, node: Token![=>]) -> Token![=>] {
$crate::fold::fold_eql_gst(self, node)
}
fn fold_gst(&mut self, node: Token![>]) -> Token![>] {
$crate::fold::fold_gst(self, node)
}
fn fold_gst_eql(&mut self, node: Token![>=]) -> Token![>=] {
$crate::fold::fold_gst_eql(self, node)
}
fn fold_gst_gst(&mut self, node: Token![>>]) -> Token![>>] {
$crate::fold::fold_gst_gst(self, node)
}
fn fold_gst_gst_eql(&mut self, node: Token![>>=]) -> Token![>>=] {
$crate::fold::fold_gst_gst_eql(self, node)
}
fn fold_qsm(&mut self, node: Token![?]) -> Token![?] {
$crate::fold::fold_qsm(self, node)
}
fn fold_qsm_qsm(&mut self, node: Token![??]) -> Token![??] {
$crate::fold::fold_qsm_qsm(self, node)
}
fn fold_qsm_qsm_eql(&mut self, node: Token![??=]) -> Token![??=] {
$crate::fold::fold_qsm_qsm_eql(self, node)
}
fn fold_att(&mut self, node: Token![@]) -> Token![@] {
$crate::fold::fold_att(self, node)
}
fn fold_att_eql(&mut self, node: Token![@=]) -> Token![@=] {
$crate::fold::fold_att_eql(self, node)
}
fn fold_att_att(&mut self, node: Token![@@]) -> Token![@@] {
$crate::fold::fold_att_att(self, node)
}
fn fold_att_att_eql(&mut self, node: Token![@@=]) -> Token![@@=] {
$crate::fold::fold_att_att_eql(self, node)
}
fn fold_att_att_qsm(&mut self, node: Token![@@?]) -> Token![@@?] {
$crate::fold::fold_att_att_qsm(self, node)
}
fn fold_att_att_qsm_eql(&mut self, node: Token![@@?=]) -> Token![@@?=] {
$crate::fold::fold_att_att_qsm_eql(self, node)
}
fn fold_bsl(&mut self, node: Token!["\\"]) -> Token!["\\"] {
$crate::fold::fold_bsl(self, node)
}
fn fold_bsl_eql(&mut self, node: Token!["\\="]) -> Token!["\\="] {
$crate::fold::fold_bsl_eql(self, node)
}
fn fold_bsl_bsl(&mut self, node: Token!["\\\\"]) -> Token!["\\\\"] {
$crate::fold::fold_bsl_bsl(self, node)
}
fn fold_bsl_bsl_eql(&mut self, node: Token!["\\\\="]) -> Token!["\\\\="] {
$crate::fold::fold_bsl_bsl_eql(self, node)
}
fn fold_crt(&mut self, node: Token![^]) -> Token![^] {
$crate::fold::fold_crt(self, node)
}
fn fold_crt_eql(&mut self, node: Token![^=]) -> Token![^=] {
$crate::fold::fold_crt_eql(self, node)
}
fn fold_crt_mul_mul(&mut self, node: Token![^**]) -> Token![^**] {
$crate::fold::fold_crt_mul_mul(self, node)
}
fn fold_crt_mul_mul_eql(&mut self, node: Token![^**=]) -> Token![^**=] {
$crate::fold::fold_crt_mul_mul_eql(self, node)
}
fn fold_crt_lst(&mut self, node: Token![^<]) -> Token![^<] {
$crate::fold::fold_crt_lst(self, node)
}
fn fold_crt_lst_eql(&mut self, node: Token![^<=]) -> Token![^<=] {
$crate::fold::fold_crt_lst_eql(self, node)
}
fn fold_crt_gst(&mut self, node: Token![^>]) -> Token![^>] {
$crate::fold::fold_crt_gst(self, node)
}
fn fold_crt_gst_eql(&mut self, node: Token![^>=]) -> Token![^>=] {
$crate::fold::fold_crt_gst_eql(self, node)
}
fn fold_crt_crt(&mut self, node: Token![^^]) -> Token![^^] {
$crate::fold::fold_crt_crt(self, node)
}
fn fold_crt_crt_eql(&mut self, node: Token![^^=]) -> Token![^^=] {
$crate::fold::fold_crt_crt_eql(self, node)
}
fn fold_ubs(&mut self, node: Token![_]) -> Token![_] {
$crate::fold::fold_ubs(self, node)
}
fn fold_ubs_eql(&mut self, node: Token![_=]) -> Token![_=] {
$crate::fold::fold_ubs_eql(self, node)
}
fn fold_ubs_lst(&mut self, node: Token![_<]) -> Token![_<] {
$crate::fold::fold_ubs_lst(self, node)
}
fn fold_ubs_lst_eql(&mut self, node: Token![_<=]) -> Token![_<=] {
$crate::fold::fold_ubs_lst_eql(self, node)
}
fn fold_ubs_gst(&mut self, node: Token![_>]) -> Token![_>] {
$crate::fold::fold_ubs_gst(self, node)
}
fn fold_ubs_gst_eql(&mut self, node: Token![_>=]) -> Token![_>=] {
$crate::fold::fold_ubs_gst_eql(self, node)
}
fn fold_pip(&mut self, node: Token![|]) -> Token![|] {
$crate::fold::fold_pip(self, node)
}
fn fold_pip_eql(&mut self, node: Token![|=]) -> Token![|=] {
$crate::fold::fold_pip_eql(self, node)
}
fn fold_pip_sub(&mut self, node: Token![|-]) -> Token![|-] {
$crate::fold::fold_pip_sub(self, node)
}
fn fold_pip_sub_eql(&mut self, node: Token![|-=]) -> Token![|-=] {
$crate::fold::fold_pip_sub_eql(self, node)
}
fn fold_pip_ubs(&mut self, node: Token![|_]) -> Token![|_] {
$crate::fold::fold_pip_ubs(self, node)
}
fn fold_pip_ubs_eql(&mut self, node: Token![|_=]) -> Token![|_=] {
$crate::fold::fold_pip_ubs_eql(self, node)
}
fn fold_pip_pip(&mut self, node: Token![||]) -> Token![||] {
$crate::fold::fold_pip_pip(self, node)
}
fn fold_pip_pip_eql(&mut self, node: Token![||=]) -> Token![||=] {
$crate::fold::fold_pip_pip_eql(self, node)
}
fn fold_tld(&mut self, node: Token![~]) -> Token![~] {
$crate::fold::fold_tld(self, node)
}
fn fold_tld_eql(&mut self, node: Token![~=]) -> Token![~=] {
$crate::fold::fold_tld_eql(self, node)
}
fn fold_cdt(&mut self, node: Token!["·"]) -> Token!["·"] {
$crate::fold::fold_cdt(self, node)
}
fn fold_cdt_eql(&mut self, node: Token!["·="]) -> Token!["·="] {
$crate::fold::fold_cdt_eql(self, node)
}
fn fold_box(&mut self, node: Token!["⊠"]) -> Token!["⊠"] {
$crate::fold::fold_box(self, node)
}
fn fold_box_eql(&mut self, node: Token!["⊠="]) -> Token!["⊠="] {
$crate::fold::fold_box_eql(self, node)
}
fn fold_sfp(&mut self, node: Token!["⧢"]) -> Token!["⧢"] {
$crate::fold::fold_sfp(self, node)
}
fn fold_sfp_eql(&mut self, node: Token!["⧢="]) -> Token!["⧢="] {
$crate::fold::fold_sfp_eql(self, node)
}
fn fold_and(&mut self, node: Token![and]) -> Token![and] {
$crate::fold::fold_and(self, node)
}
fn fold_or(&mut self, node: Token![or]) -> Token![or] {
$crate::fold::fold_or(self, node)
}
fn fold_space(&mut self, node: Token![SPACE]) -> Token![SPACE] {
$crate::fold::fold_space(self, node)
}
fn fold_xor(&mut self, node: Token![xor]) -> Token![xor] {
$crate::fold::fold_xor(self, node)
}
fn fold_bng(&mut self, node: Token![!]) -> Token![!] {
$crate::fold::fold_bng(self, node)
}
fn fold_graded(&mut self, node: Token![(*)]) -> Token![(*)] {
$crate::fold::fold_graded(self, node)
}
fn fold_crt_bng(&mut self, node: Token![^!]) -> Token![^!] {
$crate::fold::fold_crt_bng(self, node)
}
fn fold_crt_mul(&mut self, node: Token![^*]) -> Token![^*] {
$crate::fold::fold_crt_mul(self, node)
}
fn fold_crt_tld(&mut self, node: Token![^~]) -> Token![^~] {
$crate::fold::fold_crt_tld(self, node)
}
fn fold_ubs_bng(&mut self, node: Token![_!]) -> Token![_!] {
$crate::fold::fold_ubs_bng(self, node)
}
fn fold_ubs_mul(&mut self, node: Token![_*]) -> Token![_*] {
$crate::fold::fold_ubs_mul(self, node)
}
fn fold_ubs_tld(&mut self, node: Token![_~]) -> Token![_~] {
$crate::fold::fold_ubs_tld(self, node)
}
fn fold_not(&mut self, node: Token![not]) -> Token![not] {
$crate::fold::fold_not(self, node)
}
fn fold_break_keyword(&mut self, node: Token![break]) -> Token![break] {
$crate::fold::fold_break_keyword(self, node)
}
fn fold_breakpoint_keyword(&mut self, node: Token![breakpoint]) -> Token![breakpoint] {
$crate::fold::fold_breakpoint_keyword(self, node)
}
fn fold_catch_keyword(&mut self, node: Token![catch]) -> Token![catch] {
$crate::fold::fold_catch_keyword(self, node)
}
fn fold_continue_keyword(&mut self, node: Token![continue]) -> Token![continue] {
$crate::fold::fold_continue_keyword(self, node)
}
fn fold_do_keyword(&mut self, node: Token![do]) -> Token![do] {
$crate::fold::fold_do_keyword(self, node)
}
fn fold_elapsed_time_keyword(&mut self, node: Token![elapsedTime]) -> Token![elapsedTime] {
$crate::fold::fold_elapsed_time_keyword(self, node)
}
fn fold_elapsed_timing_keyword(
&mut self,
node: Token![elapsedTiming],
) -> Token![elapsedTiming] {
$crate::fold::fold_elapsed_timing_keyword(self, node)
}
fn fold_else_keyword(&mut self, node: Token![else]) -> Token![else] {
$crate::fold::fold_else_keyword(self, node)
}
fn fold_except_keyword(&mut self, node: Token![except]) -> Token![except] {
$crate::fold::fold_except_keyword(self, node)
}
fn fold_finish_keyword(&mut self, node: Token![finish]) -> Token![finish] {
$crate::fold::fold_finish_keyword(self, node)
}
fn fold_for_keyword(&mut self, node: Token![for]) -> Token![for] {
$crate::fold::fold_for_keyword(self, node)
}
fn fold_from_keyword(&mut self, node: Token![from]) -> Token![from] {
$crate::fold::fold_from_keyword(self, node)
}
fn fold_global_keyword(&mut self, node: Token![global]) -> Token![global] {
$crate::fold::fold_global_keyword(self, node)
}
fn fold_if_keyword(&mut self, node: Token![if]) -> Token![if] {
$crate::fold::fold_if_keyword(self, node)
}
fn fold_in_keyword(&mut self, node: Token![in]) -> Token![in] {
$crate::fold::fold_in_keyword(self, node)
}
fn fold_list_keyword(&mut self, node: Token![list]) -> Token![list] {
$crate::fold::fold_list_keyword(self, node)
}
fn fold_local_keyword(&mut self, node: Token![local]) -> Token![local] {
$crate::fold::fold_local_keyword(self, node)
}
fn fold_new_keyword(&mut self, node: Token![new]) -> Token![new] {
$crate::fold::fold_new_keyword(self, node)
}
fn fold_of_keyword(&mut self, node: Token![of]) -> Token![of] {
$crate::fold::fold_of_keyword(self, node)
}
fn fold_profile_keyword(&mut self, node: Token![profile]) -> Token![profile] {
$crate::fold::fold_profile_keyword(self, node)
}
fn fold_return_keyword(&mut self, node: Token![return]) -> Token![return] {
$crate::fold::fold_return_keyword(self, node)
}
fn fold_shield_keyword(&mut self, node: Token![shield]) -> Token![shield] {
$crate::fold::fold_shield_keyword(self, node)
}
fn fold_step_keyword(&mut self, node: Token![step]) -> Token![step] {
$crate::fold::fold_step_keyword(self, node)
}
fn fold_symbol_keyword(&mut self, node: Token![symbol]) -> Token![symbol] {
$crate::fold::fold_symbol_keyword(self, node)
}
fn fold_test_keyword(&mut self, node: Token![TEST]) -> Token![TEST] {
$crate::fold::fold_test_keyword(self, node)
}
fn fold_then_keyword(&mut self, node: Token![then]) -> Token![then] {
$crate::fold::fold_then_keyword(self, node)
}
fn fold_thread_local_keyword(&mut self, node: Token![threadLocal]) -> Token![threadLocal] {
$crate::fold::fold_thread_local_keyword(self, node)
}
fn fold_thread_variable_keyword(
&mut self,
node: Token![threadVariable],
) -> Token![threadVariable] {
$crate::fold::fold_thread_variable_keyword(self, node)
}
fn fold_throw_keyword(&mut self, node: Token![throw]) -> Token![throw] {
$crate::fold::fold_throw_keyword(self, node)
}
fn fold_time_keyword(&mut self, node: Token![time]) -> Token![time] {
$crate::fold::fold_time_keyword(self, node)
}
fn fold_timing_keyword(&mut self, node: Token![timing]) -> Token![timing] {
$crate::fold::fold_timing_keyword(self, node)
}
fn fold_to_keyword(&mut self, node: Token![to]) -> Token![to] {
$crate::fold::fold_to_keyword(self, node)
}
fn fold_trap_keyword(&mut self, node: Token![trap]) -> Token![trap] {
$crate::fold::fold_trap_keyword(self, node)
}
fn fold_try_keyword(&mut self, node: Token![try]) -> Token![try] {
$crate::fold::fold_try_keyword(self, node)
}
fn fold_when_keyword(&mut self, node: Token![when]) -> Token![when] {
$crate::fold::fold_when_keyword(self, node)
}
fn fold_while_keyword(&mut self, node: Token![while]) -> Token![while] {
$crate::fold::fold_while_keyword(self, node)
}
fn fold_scl(&mut self, node: Token![;]) -> Token![;] {
$crate::fold::fold_scl(self, node)
}
fn fold_cma(&mut self, node: Token![,]) -> Token![,] {
$crate::fold::fold_cma(self, node)
}
fn fold_symbol(&mut self, node: Symbol) -> Symbol {
$crate::fold::fold_symbol(self, node)
}
fn fold_block_comment(&mut self, node: BlockComment) -> BlockComment {
$crate::fold::fold_block_comment(self, node)
}
fn fold_line_comment(&mut self, node: LineComment) -> LineComment {
$crate::fold::fold_line_comment(self, node)
}
fn fold_empty_component(&mut self, node: EmptyComponent) -> EmptyComponent {
$crate::fold::fold_empty_component(self, node)
}
fn fold_escape_sequence(&mut self, node: EscapeSequence) -> EscapeSequence {
$crate::fold::fold_escape_sequence(self, node)
}
fn fold_float_literal(&mut self, node: FloatLiteral) -> FloatLiteral {
$crate::fold::fold_float_literal(self, node)
}
fn fold_integer_literal(&mut self, node: IntegerLiteral) -> IntegerLiteral {
$crate::fold::fold_integer_literal(self, node)
}
fn fold_raw_string_content(&mut self, node: RawStringContent) -> RawStringContent {
$crate::fold::fold_raw_string_content(self, node)
}
fn fold_string_content(&mut self, node: StringContent) -> StringContent {
$crate::fold::fold_string_content(self, node)
}
fn fold_source_file(&mut self, node: SourceFile) -> SourceFile {
$crate::fold::fold_source_file(self, node)
}
fn fold_expression_cell(&mut self, node: ExpressionCell) -> ExpressionCell {
$crate::fold::fold_expression_cell(self, node)
}
fn fold_sequence_cell(&mut self, node: SequenceCell) -> SequenceCell {
$crate::fold::fold_sequence_cell(self, node)
}
fn fold_naked_sequence(&mut self, node: NakedSequence) -> NakedSequence {
$crate::fold::fold_naked_sequence(self, node)
}
fn fold_muted_cell(&mut self, node: MutedCell) -> MutedCell {
$crate::fold::fold_muted_cell(self, node)
}
fn fold_muted_group(&mut self, node: MutedGroup) -> MutedGroup {
$crate::fold::fold_muted_group(self, node)
}
fn fold_array(&mut self, node: Array) -> Array {
$crate::fold::fold_array(self, node)
}
fn fold_list(&mut self, node: List) -> List {
$crate::fold::fold_list(self, node)
}
fn fold_angle_bar_list(&mut self, node: AngleBarList) -> AngleBarList {
$crate::fold::fold_angle_bar_list(self, node)
}
fn fold_sequence(&mut self, node: Sequence) -> Sequence {
$crate::fold::fold_sequence(self, node)
}
fn fold_parenthesized_expression(
&mut self,
node: ParenthesizedExpression,
) -> ParenthesizedExpression {
$crate::fold::fold_parenthesized_expression(self, node)
}
fn fold_string_literal(&mut self, node: StringLiteral) -> StringLiteral {
$crate::fold::fold_string_literal(self, node)
}
fn fold_raw_string_literal(&mut self, node: RawStringLiteral) -> RawStringLiteral {
$crate::fold::fold_raw_string_literal(self, node)
}
fn fold_binary_expression(&mut self, node: BinaryExpression) -> BinaryExpression {
$crate::fold::fold_binary_expression(self, node)
}
fn fold_adjacent_expression(&mut self, node: AdjacentExpression) -> AdjacentExpression {
$crate::fold::fold_adjacent_expression(self, node)
}
fn fold_prefix_expression(&mut self, node: PrefixExpression) -> PrefixExpression {
$crate::fold::fold_prefix_expression(self, node)
}
fn fold_postfix_expression(&mut self, node: PostfixExpression) -> PostfixExpression {
$crate::fold::fold_postfix_expression(self, node)
}
fn fold_lambda_expression(&mut self, node: LambdaExpression) -> LambdaExpression {
$crate::fold::fold_lambda_expression(self, node)
}
fn fold_assignment(&mut self, node: Assignment) -> Assignment {
$crate::fold::fold_assignment(self, node)
}
fn fold_local_assignment(&mut self, node: LocalAssignment) -> LocalAssignment {
$crate::fold::fold_local_assignment(self, node)
}
fn fold_binary_assignment(&mut self, node: BinaryAssignment) -> BinaryAssignment {
$crate::fold::fold_binary_assignment(self, node)
}
fn fold_binary_installation(&mut self, node: BinaryInstallation) -> BinaryInstallation {
$crate::fold::fold_binary_installation(self, node)
}
fn fold_prefix_assignment(&mut self, node: PrefixAssignment) -> PrefixAssignment {
$crate::fold::fold_prefix_assignment(self, node)
}
fn fold_prefix_installation(&mut self, node: PrefixInstallation) -> PrefixInstallation {
$crate::fold::fold_prefix_installation(self, node)
}
fn fold_postfix_assignment(&mut self, node: PostfixAssignment) -> PostfixAssignment {
$crate::fold::fold_postfix_assignment(self, node)
}
fn fold_postfix_installation(&mut self, node: PostfixInstallation) -> PostfixInstallation {
$crate::fold::fold_postfix_installation(self, node)
}
fn fold_structured_binding(&mut self, node: StructuredBinding) -> StructuredBinding {
$crate::fold::fold_structured_binding(self, node)
}
fn fold_local_structured_binding(
&mut self,
node: LocalStructuredBinding,
) -> LocalStructuredBinding {
$crate::fold::fold_local_structured_binding(self, node)
}
fn fold_evaluated_assignment(&mut self, node: EvaluatedAssignment) -> EvaluatedAssignment {
$crate::fold::fold_evaluated_assignment(self, node)
}
fn fold_option_expression(&mut self, node: OptionExpression) -> OptionExpression {
$crate::fold::fold_option_expression(self, node)
}
fn fold_then_clause(&mut self, node: ThenClause) -> ThenClause {
$crate::fold::fold_then_clause(self, node)
}
fn fold_else_clause(&mut self, node: ElseClause) -> ElseClause {
$crate::fold::fold_else_clause(self, node)
}
fn fold_if_statement(&mut self, node: IfStatement) -> IfStatement {
$crate::fold::fold_if_statement(self, node)
}
fn fold_loop_body(&mut self, node: LoopBody) -> LoopBody {
$crate::fold::fold_loop_body(self, node)
}
fn fold_iteration_range(&mut self, node: IterationRange) -> IterationRange {
$crate::fold::fold_iteration_range(self, node)
}
fn fold_for_loop(&mut self, node: ForLoop) -> ForLoop {
$crate::fold::fold_for_loop(self, node)
}
fn fold_while_loop(&mut self, node: WhileLoop) -> WhileLoop {
$crate::fold::fold_while_loop(self, node)
}
fn fold_new_statement(&mut self, node: NewStatement) -> NewStatement {
$crate::fold::fold_new_statement(self, node)
}
fn fold_debug_clause(&mut self, node: DebugClause) -> DebugClause {
$crate::fold::fold_debug_clause(self, node)
}
fn fold_break_statement(&mut self, node: BreakStatement) -> BreakStatement {
$crate::fold::fold_break_statement(self, node)
}
fn fold_continue_statement(&mut self, node: ContinueStatement) -> ContinueStatement {
$crate::fold::fold_continue_statement(self, node)
}
fn fold_return_statement(&mut self, node: ReturnStatement) -> ReturnStatement {
$crate::fold::fold_return_statement(self, node)
}
fn fold_catch_statement(&mut self, node: CatchStatement) -> CatchStatement {
$crate::fold::fold_catch_statement(self, node)
}
fn fold_throw_statement(&mut self, node: ThrowStatement) -> ThrowStatement {
$crate::fold::fold_throw_statement(self, node)
}
fn fold_trap_statement(&mut self, node: TrapStatement) -> TrapStatement {
$crate::fold::fold_trap_statement(self, node)
}
fn fold_except_clause(&mut self, node: ExceptClause) -> ExceptClause {
$crate::fold::fold_except_clause(self, node)
}
fn fold_try_statement(&mut self, node: TryStatement) -> TryStatement {
$crate::fold::fold_try_statement(self, node)
}
fn fold_quote_expression(&mut self, node: QuoteExpression) -> QuoteExpression {
$crate::fold::fold_quote_expression(self, node)
}
fn fold_prefix_operator(&mut self, node: PrefixOperator) -> PrefixOperator {
$crate::fold::fold_prefix_operator(self, node)
}
fn fold_binary_operator(&mut self, node: BinaryOperator) -> BinaryOperator {
$crate::fold::fold_binary_operator(self, node)
}
fn fold_postfix_operator(&mut self, node: PostfixOperator) -> PostfixOperator {
$crate::fold::fold_postfix_operator(self, node)
}
fn fold_debug_keyword(&mut self, node: DebugKeyword) -> DebugKeyword {
$crate::fold::fold_debug_keyword(self, node)
}
fn fold_try_fallback(&mut self, node: TryFallback) -> TryFallback {
$crate::fold::fold_try_fallback(self, node)
}
fn fold_quote_specifier(&mut self, node: QuoteSpecifier) -> QuoteSpecifier {
$crate::fold::fold_quote_specifier(self, node)
}
fn fold_any_cell(&mut self, node: AnyCell) -> AnyCell {
$crate::fold::fold_any_cell(self, node)
}
fn fold_component(&mut self, node: Component) -> Component {
$crate::fold::fold_component(self, node)
}
fn fold_sequence_element(&mut self, node: SequenceElement) -> SequenceElement {
$crate::fold::fold_sequence_element(self, node)
}
fn fold_string_element(&mut self, node: StringElement) -> StringElement {
$crate::fold::fold_string_element(self, node)
}
fn fold_raw_string_element(&mut self, node: RawStringElement) -> RawStringElement {
$crate::fold::fold_raw_string_element(self, node)
}
fn fold_collection(&mut self, node: Collection) -> Collection {
$crate::fold::fold_collection(self, node)
}
fn fold_binding_pack(&mut self, node: BindingPack) -> BindingPack {
$crate::fold::fold_binding_pack(self, node)
}
fn fold_lambda_parameters(&mut self, node: LambdaParameters) -> LambdaParameters {
$crate::fold::fold_lambda_parameters(self, node)
}
fn fold_operator_expr(&mut self, node: OperatorExpr) -> OperatorExpr {
$crate::fold::fold_operator_expr(self, node)
}
fn fold_assignment_expr(&mut self, node: AssignmentExpr) -> AssignmentExpr {
$crate::fold::fold_assignment_expr(self, node)
}
fn fold_expr(&mut self, node: Expr) -> Expr {
$crate::fold::fold_expr(self, node)
}
fn fold_syntax_node(&mut self, node: SyntaxNode) -> SyntaxNode {
$crate::fold::fold_syntax_node(self, node)
}
};
}
#[doc(hidden)]
#[macro_export]
macro_rules! __m2_syn_fold_walkers {
() => {
pub fn fold_bng_eql<F>(_folder: &mut F, node: Token![!=]) -> Token![!=]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_hsh<F>(_folder: &mut F, node: Token![#]) -> Token![#]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_hsh_qsm<F>(_folder: &mut F, node: Token![#?]) -> Token![#?]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_mod<F>(_folder: &mut F, node: Token![%]) -> Token![%]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_mod_eql<F>(_folder: &mut F, node: Token![%=]) -> Token![%=]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_amp<F>(_folder: &mut F, node: Token![&]) -> Token![&]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_amp_eql<F>(_folder: &mut F, node: Token![&=]) -> Token![&=]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_mul<F>(_folder: &mut F, node: Token![*]) -> Token![*]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_mul_eql<F>(_folder: &mut F, node: Token![*=]) -> Token![*=]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_mul_mul<F>(_folder: &mut F, node: Token![**]) -> Token![**]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_mul_mul_eql<F>(_folder: &mut F, node: Token![**=]) -> Token![**=]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_add<F>(_folder: &mut F, node: Token![+]) -> Token![+]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_add_eql<F>(_folder: &mut F, node: Token![+=]) -> Token![+=]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_add_add<F>(_folder: &mut F, node: Token![++]) -> Token![++]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_add_add_eql<F>(_folder: &mut F, node: Token![++=]) -> Token![++=]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_sub<F>(_folder: &mut F, node: Token![-]) -> Token![-]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_sub_eql<F>(_folder: &mut F, node: Token![-=]) -> Token![-=]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_sub_gst<F>(_folder: &mut F, node: Token![->]) -> Token![->]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_dot<F>(_folder: &mut F, node: Token![.]) -> Token![.]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_dot_dot<F>(_folder: &mut F, node: Token![..]) -> Token![..]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_dot_dot_eql<F>(_folder: &mut F, node: Token![..=]) -> Token![..=]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_dot_dot_lst<F>(_folder: &mut F, node: Token![..<]) -> Token![..<]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_dot_dot_lst_eql<F>(_folder: &mut F, node: Token![..<=]) -> Token![..<=]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_dot_qsm<F>(_folder: &mut F, node: Token![.?]) -> Token![.?]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_slh<F>(_folder: &mut F, node: Token![/]) -> Token![/]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_slh_eql<F>(_folder: &mut F, node: Token![/=]) -> Token![/=]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_slh_slh<F>(_folder: &mut F, node: Token![/ /]) -> Token![/ /]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_slh_slh_eql<F>(_folder: &mut F, node: Token![/ /=]) -> Token![/ /=]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_col<F>(_folder: &mut F, node: Token![:]) -> Token![:]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_col_eql<F>(_folder: &mut F, node: Token![:=]) -> Token![:=]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_lst<F>(_folder: &mut F, node: Token![<]) -> Token![<]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_lst_sub<F>(_folder: &mut F, node: Token![<-]) -> Token![<-]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_lst_lst<F>(_folder: &mut F, node: Token![<<]) -> Token![<<]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_lst_lst_eql<F>(_folder: &mut F, node: Token![<<=]) -> Token![<<=]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_lst_eql<F>(_folder: &mut F, node: Token![<=]) -> Token![<=]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_lst_eql_eql<F>(_folder: &mut F, node: Token![<==]) -> Token![<==]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_lst_eql_eql_eql<F>(_folder: &mut F, node: Token![<===]) -> Token![<===]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_lst_eql_eql_gst<F>(_folder: &mut F, node: Token![<==>]) -> Token![<==>]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_lst_eql_eql_gst_eql<F>(_folder: &mut F, node: Token![<==>=]) -> Token![<==>=]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_eql<F>(_folder: &mut F, node: Token![=]) -> Token![=]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_eql_bng_eql<F>(_folder: &mut F, node: Token![=!=]) -> Token![=!=]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_eql_eql<F>(_folder: &mut F, node: Token![==]) -> Token![==]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_eql_eql_eql<F>(_folder: &mut F, node: Token![===]) -> Token![===]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_eql_eql_eql_gst<F>(_folder: &mut F, node: Token![===>]) -> Token![===>]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_eql_eql_eql_gst_eql<F>(_folder: &mut F, node: Token![===>=]) -> Token![===>=]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_eql_eql_gst<F>(_folder: &mut F, node: Token![==>]) -> Token![==>]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_eql_eql_gst_eql<F>(_folder: &mut F, node: Token![==>=]) -> Token![==>=]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_eql_gst<F>(_folder: &mut F, node: Token![=>]) -> Token![=>]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_gst<F>(_folder: &mut F, node: Token![>]) -> Token![>]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_gst_eql<F>(_folder: &mut F, node: Token![>=]) -> Token![>=]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_gst_gst<F>(_folder: &mut F, node: Token![>>]) -> Token![>>]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_gst_gst_eql<F>(_folder: &mut F, node: Token![>>=]) -> Token![>>=]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_qsm<F>(_folder: &mut F, node: Token![?]) -> Token![?]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_qsm_qsm<F>(_folder: &mut F, node: Token![??]) -> Token![??]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_qsm_qsm_eql<F>(_folder: &mut F, node: Token![??=]) -> Token![??=]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_att<F>(_folder: &mut F, node: Token![@]) -> Token![@]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_att_eql<F>(_folder: &mut F, node: Token![@=]) -> Token![@=]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_att_att<F>(_folder: &mut F, node: Token![@@]) -> Token![@@]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_att_att_eql<F>(_folder: &mut F, node: Token![@@=]) -> Token![@@=]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_att_att_qsm<F>(_folder: &mut F, node: Token![@@?]) -> Token![@@?]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_att_att_qsm_eql<F>(_folder: &mut F, node: Token![@@?=]) -> Token![@@?=]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_bsl<F>(_folder: &mut F, node: Token!["\\"]) -> Token!["\\"]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_bsl_eql<F>(_folder: &mut F, node: Token!["\\="]) -> Token!["\\="]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_bsl_bsl<F>(_folder: &mut F, node: Token!["\\\\"]) -> Token!["\\\\"]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_bsl_bsl_eql<F>(_folder: &mut F, node: Token!["\\\\="]) -> Token!["\\\\="]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_crt<F>(_folder: &mut F, node: Token![^]) -> Token![^]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_crt_eql<F>(_folder: &mut F, node: Token![^=]) -> Token![^=]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_crt_mul_mul<F>(_folder: &mut F, node: Token![^**]) -> Token![^**]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_crt_mul_mul_eql<F>(_folder: &mut F, node: Token![^**=]) -> Token![^**=]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_crt_lst<F>(_folder: &mut F, node: Token![^<]) -> Token![^<]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_crt_lst_eql<F>(_folder: &mut F, node: Token![^<=]) -> Token![^<=]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_crt_gst<F>(_folder: &mut F, node: Token![^>]) -> Token![^>]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_crt_gst_eql<F>(_folder: &mut F, node: Token![^>=]) -> Token![^>=]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_crt_crt<F>(_folder: &mut F, node: Token![^^]) -> Token![^^]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_crt_crt_eql<F>(_folder: &mut F, node: Token![^^=]) -> Token![^^=]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_ubs<F>(_folder: &mut F, node: Token![_]) -> Token![_]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_ubs_eql<F>(_folder: &mut F, node: Token![_=]) -> Token![_=]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_ubs_lst<F>(_folder: &mut F, node: Token![_<]) -> Token![_<]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_ubs_lst_eql<F>(_folder: &mut F, node: Token![_<=]) -> Token![_<=]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_ubs_gst<F>(_folder: &mut F, node: Token![_>]) -> Token![_>]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_ubs_gst_eql<F>(_folder: &mut F, node: Token![_>=]) -> Token![_>=]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_pip<F>(_folder: &mut F, node: Token![|]) -> Token![|]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_pip_eql<F>(_folder: &mut F, node: Token![|=]) -> Token![|=]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_pip_sub<F>(_folder: &mut F, node: Token![|-]) -> Token![|-]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_pip_sub_eql<F>(_folder: &mut F, node: Token![|-=]) -> Token![|-=]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_pip_ubs<F>(_folder: &mut F, node: Token![|_]) -> Token![|_]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_pip_ubs_eql<F>(_folder: &mut F, node: Token![|_=]) -> Token![|_=]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_pip_pip<F>(_folder: &mut F, node: Token![||]) -> Token![||]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_pip_pip_eql<F>(_folder: &mut F, node: Token![||=]) -> Token![||=]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_tld<F>(_folder: &mut F, node: Token![~]) -> Token![~]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_tld_eql<F>(_folder: &mut F, node: Token![~=]) -> Token![~=]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_cdt<F>(_folder: &mut F, node: Token!["·"]) -> Token!["·"]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_cdt_eql<F>(_folder: &mut F, node: Token!["·="]) -> Token!["·="]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_box<F>(_folder: &mut F, node: Token!["⊠"]) -> Token!["⊠"]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_box_eql<F>(_folder: &mut F, node: Token!["⊠="]) -> Token!["⊠="]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_sfp<F>(_folder: &mut F, node: Token!["⧢"]) -> Token!["⧢"]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_sfp_eql<F>(_folder: &mut F, node: Token!["⧢="]) -> Token!["⧢="]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_and<F>(_folder: &mut F, node: Token![and]) -> Token![and]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_or<F>(_folder: &mut F, node: Token![or]) -> Token![or]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_space<F>(_folder: &mut F, node: Token![SPACE]) -> Token![SPACE]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_xor<F>(_folder: &mut F, node: Token![xor]) -> Token![xor]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_bng<F>(_folder: &mut F, node: Token![!]) -> Token![!]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_graded<F>(_folder: &mut F, node: Token![(*)]) -> Token![(*)]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_crt_bng<F>(_folder: &mut F, node: Token![^!]) -> Token![^!]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_crt_mul<F>(_folder: &mut F, node: Token![^*]) -> Token![^*]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_crt_tld<F>(_folder: &mut F, node: Token![^~]) -> Token![^~]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_ubs_bng<F>(_folder: &mut F, node: Token![_!]) -> Token![_!]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_ubs_mul<F>(_folder: &mut F, node: Token![_*]) -> Token![_*]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_ubs_tld<F>(_folder: &mut F, node: Token![_~]) -> Token![_~]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_not<F>(_folder: &mut F, node: Token![not]) -> Token![not]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_break_keyword<F>(_folder: &mut F, node: Token![break]) -> Token![break]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_breakpoint_keyword<F>(
_folder: &mut F,
node: Token![breakpoint],
) -> Token![breakpoint]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_catch_keyword<F>(_folder: &mut F, node: Token![catch]) -> Token![catch]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_continue_keyword<F>(_folder: &mut F, node: Token![continue]) -> Token![continue]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_do_keyword<F>(_folder: &mut F, node: Token![do]) -> Token![do]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_elapsed_time_keyword<F>(
_folder: &mut F,
node: Token![elapsedTime],
) -> Token![elapsedTime]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_elapsed_timing_keyword<F>(
_folder: &mut F,
node: Token![elapsedTiming],
) -> Token![elapsedTiming]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_else_keyword<F>(_folder: &mut F, node: Token![else]) -> Token![else]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_except_keyword<F>(_folder: &mut F, node: Token![except]) -> Token![except]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_finish_keyword<F>(_folder: &mut F, node: Token![finish]) -> Token![finish]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_for_keyword<F>(_folder: &mut F, node: Token![for]) -> Token![for]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_from_keyword<F>(_folder: &mut F, node: Token![from]) -> Token![from]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_global_keyword<F>(_folder: &mut F, node: Token![global]) -> Token![global]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_if_keyword<F>(_folder: &mut F, node: Token![if]) -> Token![if]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_in_keyword<F>(_folder: &mut F, node: Token![in]) -> Token![in]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_list_keyword<F>(_folder: &mut F, node: Token![list]) -> Token![list]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_local_keyword<F>(_folder: &mut F, node: Token![local]) -> Token![local]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_new_keyword<F>(_folder: &mut F, node: Token![new]) -> Token![new]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_of_keyword<F>(_folder: &mut F, node: Token![of]) -> Token![of]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_profile_keyword<F>(_folder: &mut F, node: Token![profile]) -> Token![profile]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_return_keyword<F>(_folder: &mut F, node: Token![return]) -> Token![return]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_shield_keyword<F>(_folder: &mut F, node: Token![shield]) -> Token![shield]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_step_keyword<F>(_folder: &mut F, node: Token![step]) -> Token![step]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_symbol_keyword<F>(_folder: &mut F, node: Token![symbol]) -> Token![symbol]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_test_keyword<F>(_folder: &mut F, node: Token![TEST]) -> Token![TEST]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_then_keyword<F>(_folder: &mut F, node: Token![then]) -> Token![then]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_thread_local_keyword<F>(
_folder: &mut F,
node: Token![threadLocal],
) -> Token![threadLocal]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_thread_variable_keyword<F>(
_folder: &mut F,
node: Token![threadVariable],
) -> Token![threadVariable]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_throw_keyword<F>(_folder: &mut F, node: Token![throw]) -> Token![throw]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_time_keyword<F>(_folder: &mut F, node: Token![time]) -> Token![time]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_timing_keyword<F>(_folder: &mut F, node: Token![timing]) -> Token![timing]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_to_keyword<F>(_folder: &mut F, node: Token![to]) -> Token![to]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_trap_keyword<F>(_folder: &mut F, node: Token![trap]) -> Token![trap]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_try_keyword<F>(_folder: &mut F, node: Token![try]) -> Token![try]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_when_keyword<F>(_folder: &mut F, node: Token![when]) -> Token![when]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_while_keyword<F>(_folder: &mut F, node: Token![while]) -> Token![while]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_scl<F>(_folder: &mut F, node: Token![;]) -> Token![;]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_cma<F>(_folder: &mut F, node: Token![,]) -> Token![,]
where
F: Fold + ?Sized,
{
node
}
pub fn fold_symbol<F>(_folder: &mut F, node: Symbol) -> Symbol
where
F: Fold + ?Sized,
{
node
}
pub fn fold_block_comment<F>(_folder: &mut F, node: BlockComment) -> BlockComment
where
F: Fold + ?Sized,
{
node
}
pub fn fold_line_comment<F>(_folder: &mut F, node: LineComment) -> LineComment
where
F: Fold + ?Sized,
{
node
}
pub fn fold_empty_component<F>(_folder: &mut F, node: EmptyComponent) -> EmptyComponent
where
F: Fold + ?Sized,
{
node
}
pub fn fold_escape_sequence<F>(_folder: &mut F, node: EscapeSequence) -> EscapeSequence
where
F: Fold + ?Sized,
{
node
}
pub fn fold_float_literal<F>(_folder: &mut F, node: FloatLiteral) -> FloatLiteral
where
F: Fold + ?Sized,
{
node
}
pub fn fold_integer_literal<F>(_folder: &mut F, node: IntegerLiteral) -> IntegerLiteral
where
F: Fold + ?Sized,
{
node
}
pub fn fold_raw_string_content<F>(
_folder: &mut F,
node: RawStringContent,
) -> RawStringContent
where
F: Fold + ?Sized,
{
node
}
pub fn fold_string_content<F>(_folder: &mut F, node: StringContent) -> StringContent
where
F: Fold + ?Sized,
{
node
}
pub fn fold_source_file<F>(folder: &mut F, node: SourceFile) -> SourceFile
where
F: Fold + ?Sized,
{
SourceFile {
elements: node
.elements
.into_iter()
.map(|value| folder.fold_any_cell(value))
.collect(),
}
}
pub fn fold_expression_cell<F>(folder: &mut F, node: ExpressionCell) -> ExpressionCell
where
F: Fold + ?Sized,
{
ExpressionCell {
value: ::std::boxed::Box::new(folder.fold_expr(*node.value)),
}
}
pub fn fold_sequence_cell<F>(folder: &mut F, node: SequenceCell) -> SequenceCell
where
F: Fold + ?Sized,
{
SequenceCell {
value: ::std::boxed::Box::new(folder.fold_naked_sequence(*node.value)),
}
}
pub fn fold_naked_sequence<F>(folder: &mut F, node: NakedSequence) -> NakedSequence
where
F: Fold + ?Sized,
{
NakedSequence {
elements: node.elements.map(|value| folder.fold_component(value)),
}
}
pub fn fold_muted_cell<F>(folder: &mut F, node: MutedCell) -> MutedCell
where
F: Fold + ?Sized,
{
MutedCell {
elements: node.elements.map(|value| folder.fold_component(value)),
semicolon: folder.fold_scl(node.semicolon),
}
}
pub fn fold_muted_group<F>(folder: &mut F, node: MutedGroup) -> MutedGroup
where
F: Fold + ?Sized,
{
MutedGroup {
elements: node.elements.map(|value| folder.fold_component(value)),
semicolon: folder.fold_scl(node.semicolon),
}
}
pub fn fold_array<F>(folder: &mut F, node: Array) -> Array
where
F: Fold + ?Sized,
{
Array {
muted: node
.muted
.into_iter()
.map(|value| folder.fold_muted_group(value))
.collect(),
elements: node.elements.map(|value| folder.fold_component(value)),
delimiter: node.delimiter,
}
}
pub fn fold_list<F>(folder: &mut F, node: List) -> List
where
F: Fold + ?Sized,
{
List {
muted: node
.muted
.into_iter()
.map(|value| folder.fold_muted_group(value))
.collect(),
elements: node.elements.map(|value| folder.fold_component(value)),
delimiter: node.delimiter,
}
}
pub fn fold_angle_bar_list<F>(folder: &mut F, node: AngleBarList) -> AngleBarList
where
F: Fold + ?Sized,
{
AngleBarList {
muted: node
.muted
.into_iter()
.map(|value| folder.fold_muted_group(value))
.collect(),
elements: node.elements.map(|value| folder.fold_component(value)),
delimiter: node.delimiter,
}
}
pub fn fold_sequence<F>(folder: &mut F, node: Sequence) -> Sequence
where
F: Fold + ?Sized,
{
Sequence {
muted: node
.muted
.into_iter()
.map(|value| folder.fold_muted_group(value))
.collect(),
elements: node.elements.map(|value| folder.fold_component(value)),
delimiter: node.delimiter,
}
}
pub fn fold_parenthesized_expression<F>(
folder: &mut F,
node: ParenthesizedExpression,
) -> ParenthesizedExpression
where
F: Fold + ?Sized,
{
ParenthesizedExpression {
muted: node
.muted
.into_iter()
.map(|value| folder.fold_muted_group(value))
.collect(),
value: node
.value
.map(|value| ::std::boxed::Box::new(folder.fold_expr(*value))),
delimiter: node.delimiter,
}
}
pub fn fold_string_literal<F>(folder: &mut F, node: StringLiteral) -> StringLiteral
where
F: Fold + ?Sized,
{
StringLiteral {
elements: node
.elements
.into_iter()
.map(|value| folder.fold_string_element(value))
.collect(),
}
}
pub fn fold_raw_string_literal<F>(
folder: &mut F,
node: RawStringLiteral,
) -> RawStringLiteral
where
F: Fold + ?Sized,
{
RawStringLiteral {
elements: node
.elements
.into_iter()
.map(|value| folder.fold_raw_string_element(value))
.collect(),
}
}
pub fn fold_binary_expression<F>(folder: &mut F, node: BinaryExpression) -> BinaryExpression
where
F: Fold + ?Sized,
{
BinaryExpression {
left: ::std::boxed::Box::new(folder.fold_expr(*node.left)),
operator: folder.fold_binary_operator(node.operator),
right: ::std::boxed::Box::new(folder.fold_expr(*node.right)),
}
}
pub fn fold_adjacent_expression<F>(
folder: &mut F,
node: AdjacentExpression,
) -> AdjacentExpression
where
F: Fold + ?Sized,
{
AdjacentExpression {
left: ::std::boxed::Box::new(folder.fold_expr(*node.left)),
right: ::std::boxed::Box::new(folder.fold_expr(*node.right)),
}
}
pub fn fold_prefix_expression<F>(folder: &mut F, node: PrefixExpression) -> PrefixExpression
where
F: Fold + ?Sized,
{
PrefixExpression {
operator: folder.fold_prefix_operator(node.operator),
operand: ::std::boxed::Box::new(folder.fold_expr(*node.operand)),
}
}
pub fn fold_postfix_expression<F>(
folder: &mut F,
node: PostfixExpression,
) -> PostfixExpression
where
F: Fold + ?Sized,
{
PostfixExpression {
operand: ::std::boxed::Box::new(folder.fold_expr(*node.operand)),
operator: folder.fold_postfix_operator(node.operator),
}
}
pub fn fold_lambda_expression<F>(folder: &mut F, node: LambdaExpression) -> LambdaExpression
where
F: Fold + ?Sized,
{
LambdaExpression {
parameters: ::std::boxed::Box::new(folder.fold_lambda_parameters(*node.parameters)),
operator: folder.fold_sub_gst(node.operator),
body: ::std::boxed::Box::new(folder.fold_expr(*node.body)),
}
}
pub fn fold_assignment<F>(folder: &mut F, node: Assignment) -> Assignment
where
F: Fold + ?Sized,
{
Assignment {
left: ::std::boxed::Box::new(folder.fold_symbol(*node.left)),
operator: folder.fold_eql(node.operator),
right: ::std::boxed::Box::new(folder.fold_expr(*node.right)),
}
}
pub fn fold_local_assignment<F>(folder: &mut F, node: LocalAssignment) -> LocalAssignment
where
F: Fold + ?Sized,
{
LocalAssignment {
left: ::std::boxed::Box::new(folder.fold_symbol(*node.left)),
operator: folder.fold_col_eql(node.operator),
right: ::std::boxed::Box::new(folder.fold_expr(*node.right)),
}
}
pub fn fold_binary_assignment<F>(folder: &mut F, node: BinaryAssignment) -> BinaryAssignment
where
F: Fold + ?Sized,
{
BinaryAssignment {
left: ::std::boxed::Box::new(folder.fold_binary_expression(*node.left)),
operator: folder.fold_eql(node.operator),
right: ::std::boxed::Box::new(folder.fold_expr(*node.right)),
}
}
pub fn fold_binary_installation<F>(
folder: &mut F,
node: BinaryInstallation,
) -> BinaryInstallation
where
F: Fold + ?Sized,
{
BinaryInstallation {
left: ::std::boxed::Box::new(folder.fold_binary_expression(*node.left)),
operator: folder.fold_col_eql(node.operator),
right: ::std::boxed::Box::new(folder.fold_expr(*node.right)),
}
}
pub fn fold_prefix_assignment<F>(folder: &mut F, node: PrefixAssignment) -> PrefixAssignment
where
F: Fold + ?Sized,
{
PrefixAssignment {
left: ::std::boxed::Box::new(folder.fold_prefix_expression(*node.left)),
operator: folder.fold_eql(node.operator),
right: ::std::boxed::Box::new(folder.fold_expr(*node.right)),
}
}
pub fn fold_prefix_installation<F>(
folder: &mut F,
node: PrefixInstallation,
) -> PrefixInstallation
where
F: Fold + ?Sized,
{
PrefixInstallation {
left: ::std::boxed::Box::new(folder.fold_prefix_expression(*node.left)),
operator: folder.fold_col_eql(node.operator),
right: ::std::boxed::Box::new(folder.fold_expr(*node.right)),
}
}
pub fn fold_postfix_assignment<F>(
folder: &mut F,
node: PostfixAssignment,
) -> PostfixAssignment
where
F: Fold + ?Sized,
{
PostfixAssignment {
left: ::std::boxed::Box::new(folder.fold_postfix_expression(*node.left)),
operator: folder.fold_eql(node.operator),
right: ::std::boxed::Box::new(folder.fold_expr(*node.right)),
}
}
pub fn fold_postfix_installation<F>(
folder: &mut F,
node: PostfixInstallation,
) -> PostfixInstallation
where
F: Fold + ?Sized,
{
PostfixInstallation {
left: ::std::boxed::Box::new(folder.fold_postfix_expression(*node.left)),
operator: folder.fold_col_eql(node.operator),
right: ::std::boxed::Box::new(folder.fold_expr(*node.right)),
}
}
pub fn fold_structured_binding<F>(
folder: &mut F,
node: StructuredBinding,
) -> StructuredBinding
where
F: Fold + ?Sized,
{
StructuredBinding {
binding_pack: ::std::boxed::Box::new(folder.fold_binding_pack(*node.binding_pack)),
operator: folder.fold_eql(node.operator),
right: ::std::boxed::Box::new(folder.fold_expr(*node.right)),
}
}
pub fn fold_local_structured_binding<F>(
folder: &mut F,
node: LocalStructuredBinding,
) -> LocalStructuredBinding
where
F: Fold + ?Sized,
{
LocalStructuredBinding {
binding_pack: ::std::boxed::Box::new(folder.fold_binding_pack(*node.binding_pack)),
operator: folder.fold_col_eql(node.operator),
right: ::std::boxed::Box::new(folder.fold_expr(*node.right)),
}
}
pub fn fold_evaluated_assignment<F>(
folder: &mut F,
node: EvaluatedAssignment,
) -> EvaluatedAssignment
where
F: Fold + ?Sized,
{
EvaluatedAssignment {
left: ::std::boxed::Box::new(folder.fold_expr(*node.left)),
operator: folder.fold_lst_sub(node.operator),
right: ::std::boxed::Box::new(folder.fold_expr(*node.right)),
}
}
pub fn fold_option_expression<F>(folder: &mut F, node: OptionExpression) -> OptionExpression
where
F: Fold + ?Sized,
{
OptionExpression {
left: ::std::boxed::Box::new(folder.fold_expr(*node.left)),
operator: folder.fold_eql_gst(node.operator),
right: ::std::boxed::Box::new(folder.fold_expr(*node.right)),
}
}
pub fn fold_then_clause<F>(folder: &mut F, node: ThenClause) -> ThenClause
where
F: Fold + ?Sized,
{
ThenClause {
keyword: folder.fold_then_keyword(node.keyword),
value: ::std::boxed::Box::new(folder.fold_expr(*node.value)),
}
}
pub fn fold_else_clause<F>(folder: &mut F, node: ElseClause) -> ElseClause
where
F: Fold + ?Sized,
{
ElseClause {
keyword: folder.fold_else_keyword(node.keyword),
value: ::std::boxed::Box::new(folder.fold_expr(*node.value)),
}
}
pub fn fold_if_statement<F>(folder: &mut F, node: IfStatement) -> IfStatement
where
F: Fold + ?Sized,
{
IfStatement {
keyword: folder.fold_if_keyword(node.keyword),
condition: ::std::boxed::Box::new(folder.fold_expr(*node.condition)),
then_clause: ::std::boxed::Box::new(folder.fold_then_clause(*node.then_clause)),
else_clause: node
.else_clause
.map(|value| ::std::boxed::Box::new(folder.fold_else_clause(*value))),
}
}
pub fn fold_loop_body<F>(folder: &mut F, node: LoopBody) -> LoopBody
where
F: Fold + ?Sized,
{
LoopBody {
list_keyword: node
.list_keyword
.map(|value| folder.fold_list_keyword(value)),
listed_value: node
.listed_value
.map(|value| ::std::boxed::Box::new(folder.fold_expr(*value))),
do_keyword: node.do_keyword.map(|value| folder.fold_do_keyword(value)),
ignored_value: node
.ignored_value
.map(|value| ::std::boxed::Box::new(folder.fold_expr(*value))),
}
}
pub fn fold_iteration_range<F>(folder: &mut F, node: IterationRange) -> IterationRange
where
F: Fold + ?Sized,
{
IterationRange {
in_keyword: node.in_keyword.map(|value| folder.fold_in_keyword(value)),
iterated_collection: node
.iterated_collection
.map(|value| ::std::boxed::Box::new(folder.fold_expr(*value))),
from_keyword: node
.from_keyword
.map(|value| folder.fold_from_keyword(value)),
range_start: node
.range_start
.map(|value| ::std::boxed::Box::new(folder.fold_expr(*value))),
to_keyword: node.to_keyword.map(|value| folder.fold_to_keyword(value)),
range_end: node
.range_end
.map(|value| ::std::boxed::Box::new(folder.fold_expr(*value))),
}
}
pub fn fold_for_loop<F>(folder: &mut F, node: ForLoop) -> ForLoop
where
F: Fold + ?Sized,
{
ForLoop {
keyword: folder.fold_for_keyword(node.keyword),
variable: ::std::boxed::Box::new(folder.fold_symbol(*node.variable)),
range: node
.range
.map(|value| ::std::boxed::Box::new(folder.fold_iteration_range(*value))),
when_keyword: node
.when_keyword
.map(|value| folder.fold_when_keyword(value)),
filter: node
.filter
.map(|value| ::std::boxed::Box::new(folder.fold_expr(*value))),
body: ::std::boxed::Box::new(folder.fold_loop_body(*node.body)),
}
}
pub fn fold_while_loop<F>(folder: &mut F, node: WhileLoop) -> WhileLoop
where
F: Fold + ?Sized,
{
WhileLoop {
keyword: folder.fold_while_keyword(node.keyword),
condition: ::std::boxed::Box::new(folder.fold_expr(*node.condition)),
body: ::std::boxed::Box::new(folder.fold_loop_body(*node.body)),
}
}
pub fn fold_new_statement<F>(folder: &mut F, node: NewStatement) -> NewStatement
where
F: Fold + ?Sized,
{
NewStatement {
keyword: folder.fold_new_keyword(node.keyword),
class: ::std::boxed::Box::new(folder.fold_expr(*node.class)),
of_keyword: node.of_keyword.map(|value| folder.fold_of_keyword(value)),
parent: node
.parent
.map(|value| ::std::boxed::Box::new(folder.fold_expr(*value))),
from_keyword: node
.from_keyword
.map(|value| folder.fold_from_keyword(value)),
instance: node
.instance
.map(|value| ::std::boxed::Box::new(folder.fold_expr(*value))),
}
}
pub fn fold_debug_clause<F>(folder: &mut F, node: DebugClause) -> DebugClause
where
F: Fold + ?Sized,
{
DebugClause {
keyword: folder.fold_debug_keyword(node.keyword),
value: node
.value
.map(|value| ::std::boxed::Box::new(folder.fold_expr(*value))),
}
}
pub fn fold_break_statement<F>(folder: &mut F, node: BreakStatement) -> BreakStatement
where
F: Fold + ?Sized,
{
BreakStatement {
keyword: folder.fold_break_keyword(node.keyword),
value: node
.value
.map(|value| ::std::boxed::Box::new(folder.fold_expr(*value))),
}
}
pub fn fold_continue_statement<F>(
folder: &mut F,
node: ContinueStatement,
) -> ContinueStatement
where
F: Fold + ?Sized,
{
ContinueStatement {
keyword: folder.fold_continue_keyword(node.keyword),
value: node
.value
.map(|value| ::std::boxed::Box::new(folder.fold_expr(*value))),
}
}
pub fn fold_return_statement<F>(folder: &mut F, node: ReturnStatement) -> ReturnStatement
where
F: Fold + ?Sized,
{
ReturnStatement {
keyword: folder.fold_return_keyword(node.keyword),
value: node
.value
.map(|value| ::std::boxed::Box::new(folder.fold_expr(*value))),
}
}
pub fn fold_catch_statement<F>(folder: &mut F, node: CatchStatement) -> CatchStatement
where
F: Fold + ?Sized,
{
CatchStatement {
keyword: folder.fold_catch_keyword(node.keyword),
value: ::std::boxed::Box::new(folder.fold_expr(*node.value)),
}
}
pub fn fold_throw_statement<F>(folder: &mut F, node: ThrowStatement) -> ThrowStatement
where
F: Fold + ?Sized,
{
ThrowStatement {
keyword: folder.fold_throw_keyword(node.keyword),
value: ::std::boxed::Box::new(folder.fold_expr(*node.value)),
}
}
pub fn fold_trap_statement<F>(folder: &mut F, node: TrapStatement) -> TrapStatement
where
F: Fold + ?Sized,
{
TrapStatement {
keyword: folder.fold_trap_keyword(node.keyword),
value: ::std::boxed::Box::new(folder.fold_expr(*node.value)),
}
}
pub fn fold_except_clause<F>(folder: &mut F, node: ExceptClause) -> ExceptClause
where
F: Fold + ?Sized,
{
ExceptClause {
keyword: folder.fold_except_keyword(node.keyword),
exception: ::std::boxed::Box::new(folder.fold_symbol(*node.exception)),
do_keyword: folder.fold_do_keyword(node.do_keyword),
value: ::std::boxed::Box::new(folder.fold_expr(*node.value)),
}
}
pub fn fold_try_statement<F>(folder: &mut F, node: TryStatement) -> TryStatement
where
F: Fold + ?Sized,
{
TryStatement {
keyword: folder.fold_try_keyword(node.keyword),
value: ::std::boxed::Box::new(folder.fold_expr(*node.value)),
then_clause: node
.then_clause
.map(|value| ::std::boxed::Box::new(folder.fold_then_clause(*value))),
fallback: node
.fallback
.map(|value| ::std::boxed::Box::new(folder.fold_try_fallback(*value))),
}
}
pub fn fold_quote_expression<F>(folder: &mut F, node: QuoteExpression) -> QuoteExpression
where
F: Fold + ?Sized,
{
QuoteExpression {
specifier: folder.fold_quote_specifier(node.specifier),
token: ::std::boxed::Box::new(folder.fold_symbol(*node.token)),
}
}
pub fn fold_prefix_operator<F>(folder: &mut F, node: PrefixOperator) -> PrefixOperator
where
F: Fold + ?Sized,
{
match node {
PrefixOperator::Hsh(node) => PrefixOperator::Hsh(folder.fold_hsh(node)),
PrefixOperator::Mul(node) => PrefixOperator::Mul(folder.fold_mul(node)),
PrefixOperator::Add(node) => PrefixOperator::Add(folder.fold_add(node)),
PrefixOperator::Sub(node) => PrefixOperator::Sub(folder.fold_sub(node)),
PrefixOperator::Lst(node) => PrefixOperator::Lst(folder.fold_lst(node)),
PrefixOperator::LstLst(node) => PrefixOperator::LstLst(folder.fold_lst_lst(node)),
PrefixOperator::LstEql(node) => PrefixOperator::LstEql(folder.fold_lst_eql(node)),
PrefixOperator::LstEqlEql(node) => {
PrefixOperator::LstEqlEql(folder.fold_lst_eql_eql(node))
}
PrefixOperator::LstEqlEqlEql(node) => {
PrefixOperator::LstEqlEqlEql(folder.fold_lst_eql_eql_eql(node))
}
PrefixOperator::Gst(node) => PrefixOperator::Gst(folder.fold_gst(node)),
PrefixOperator::GstEql(node) => PrefixOperator::GstEql(folder.fold_gst_eql(node)),
PrefixOperator::Qsm(node) => PrefixOperator::Qsm(folder.fold_qsm(node)),
PrefixOperator::QsmQsm(node) => PrefixOperator::QsmQsm(folder.fold_qsm_qsm(node)),
PrefixOperator::PipSub(node) => PrefixOperator::PipSub(folder.fold_pip_sub(node)),
PrefixOperator::Tld(node) => PrefixOperator::Tld(folder.fold_tld(node)),
PrefixOperator::Not(node) => PrefixOperator::Not(folder.fold_not(node)),
}
}
pub fn fold_binary_operator<F>(folder: &mut F, node: BinaryOperator) -> BinaryOperator
where
F: Fold + ?Sized,
{
match node {
BinaryOperator::BngEql(node) => BinaryOperator::BngEql(folder.fold_bng_eql(node)),
BinaryOperator::Hsh(node) => BinaryOperator::Hsh(folder.fold_hsh(node)),
BinaryOperator::HshQsm(node) => BinaryOperator::HshQsm(folder.fold_hsh_qsm(node)),
BinaryOperator::Mod(node) => BinaryOperator::Mod(folder.fold_mod(node)),
BinaryOperator::ModEql(node) => BinaryOperator::ModEql(folder.fold_mod_eql(node)),
BinaryOperator::Amp(node) => BinaryOperator::Amp(folder.fold_amp(node)),
BinaryOperator::AmpEql(node) => BinaryOperator::AmpEql(folder.fold_amp_eql(node)),
BinaryOperator::Mul(node) => BinaryOperator::Mul(folder.fold_mul(node)),
BinaryOperator::MulEql(node) => BinaryOperator::MulEql(folder.fold_mul_eql(node)),
BinaryOperator::MulMul(node) => BinaryOperator::MulMul(folder.fold_mul_mul(node)),
BinaryOperator::MulMulEql(node) => {
BinaryOperator::MulMulEql(folder.fold_mul_mul_eql(node))
}
BinaryOperator::Add(node) => BinaryOperator::Add(folder.fold_add(node)),
BinaryOperator::AddEql(node) => BinaryOperator::AddEql(folder.fold_add_eql(node)),
BinaryOperator::AddAdd(node) => BinaryOperator::AddAdd(folder.fold_add_add(node)),
BinaryOperator::AddAddEql(node) => {
BinaryOperator::AddAddEql(folder.fold_add_add_eql(node))
}
BinaryOperator::Sub(node) => BinaryOperator::Sub(folder.fold_sub(node)),
BinaryOperator::SubEql(node) => BinaryOperator::SubEql(folder.fold_sub_eql(node)),
BinaryOperator::Dot(node) => BinaryOperator::Dot(folder.fold_dot(node)),
BinaryOperator::DotDot(node) => BinaryOperator::DotDot(folder.fold_dot_dot(node)),
BinaryOperator::DotDotEql(node) => {
BinaryOperator::DotDotEql(folder.fold_dot_dot_eql(node))
}
BinaryOperator::DotDotLst(node) => {
BinaryOperator::DotDotLst(folder.fold_dot_dot_lst(node))
}
BinaryOperator::DotDotLstEql(node) => {
BinaryOperator::DotDotLstEql(folder.fold_dot_dot_lst_eql(node))
}
BinaryOperator::DotQsm(node) => BinaryOperator::DotQsm(folder.fold_dot_qsm(node)),
BinaryOperator::Slh(node) => BinaryOperator::Slh(folder.fold_slh(node)),
BinaryOperator::SlhEql(node) => BinaryOperator::SlhEql(folder.fold_slh_eql(node)),
BinaryOperator::SlhSlh(node) => BinaryOperator::SlhSlh(folder.fold_slh_slh(node)),
BinaryOperator::SlhSlhEql(node) => {
BinaryOperator::SlhSlhEql(folder.fold_slh_slh_eql(node))
}
BinaryOperator::Col(node) => BinaryOperator::Col(folder.fold_col(node)),
BinaryOperator::ColEql(node) => BinaryOperator::ColEql(folder.fold_col_eql(node)),
BinaryOperator::Lst(node) => BinaryOperator::Lst(folder.fold_lst(node)),
BinaryOperator::LstLst(node) => BinaryOperator::LstLst(folder.fold_lst_lst(node)),
BinaryOperator::LstLstEql(node) => {
BinaryOperator::LstLstEql(folder.fold_lst_lst_eql(node))
}
BinaryOperator::LstEql(node) => BinaryOperator::LstEql(folder.fold_lst_eql(node)),
BinaryOperator::LstEqlEql(node) => {
BinaryOperator::LstEqlEql(folder.fold_lst_eql_eql(node))
}
BinaryOperator::LstEqlEqlEql(node) => {
BinaryOperator::LstEqlEqlEql(folder.fold_lst_eql_eql_eql(node))
}
BinaryOperator::LstEqlEqlGst(node) => {
BinaryOperator::LstEqlEqlGst(folder.fold_lst_eql_eql_gst(node))
}
BinaryOperator::LstEqlEqlGstEql(node) => {
BinaryOperator::LstEqlEqlGstEql(folder.fold_lst_eql_eql_gst_eql(node))
}
BinaryOperator::EqlBngEql(node) => {
BinaryOperator::EqlBngEql(folder.fold_eql_bng_eql(node))
}
BinaryOperator::EqlEql(node) => BinaryOperator::EqlEql(folder.fold_eql_eql(node)),
BinaryOperator::EqlEqlEql(node) => {
BinaryOperator::EqlEqlEql(folder.fold_eql_eql_eql(node))
}
BinaryOperator::EqlEqlEqlGst(node) => {
BinaryOperator::EqlEqlEqlGst(folder.fold_eql_eql_eql_gst(node))
}
BinaryOperator::EqlEqlEqlGstEql(node) => {
BinaryOperator::EqlEqlEqlGstEql(folder.fold_eql_eql_eql_gst_eql(node))
}
BinaryOperator::EqlEqlGst(node) => {
BinaryOperator::EqlEqlGst(folder.fold_eql_eql_gst(node))
}
BinaryOperator::EqlEqlGstEql(node) => {
BinaryOperator::EqlEqlGstEql(folder.fold_eql_eql_gst_eql(node))
}
BinaryOperator::Gst(node) => BinaryOperator::Gst(folder.fold_gst(node)),
BinaryOperator::GstEql(node) => BinaryOperator::GstEql(folder.fold_gst_eql(node)),
BinaryOperator::GstGst(node) => BinaryOperator::GstGst(folder.fold_gst_gst(node)),
BinaryOperator::GstGstEql(node) => {
BinaryOperator::GstGstEql(folder.fold_gst_gst_eql(node))
}
BinaryOperator::Qsm(node) => BinaryOperator::Qsm(folder.fold_qsm(node)),
BinaryOperator::QsmQsm(node) => BinaryOperator::QsmQsm(folder.fold_qsm_qsm(node)),
BinaryOperator::QsmQsmEql(node) => {
BinaryOperator::QsmQsmEql(folder.fold_qsm_qsm_eql(node))
}
BinaryOperator::Att(node) => BinaryOperator::Att(folder.fold_att(node)),
BinaryOperator::AttEql(node) => BinaryOperator::AttEql(folder.fold_att_eql(node)),
BinaryOperator::AttAtt(node) => BinaryOperator::AttAtt(folder.fold_att_att(node)),
BinaryOperator::AttAttEql(node) => {
BinaryOperator::AttAttEql(folder.fold_att_att_eql(node))
}
BinaryOperator::AttAttQsm(node) => {
BinaryOperator::AttAttQsm(folder.fold_att_att_qsm(node))
}
BinaryOperator::AttAttQsmEql(node) => {
BinaryOperator::AttAttQsmEql(folder.fold_att_att_qsm_eql(node))
}
BinaryOperator::Bsl(node) => BinaryOperator::Bsl(folder.fold_bsl(node)),
BinaryOperator::BslEql(node) => BinaryOperator::BslEql(folder.fold_bsl_eql(node)),
BinaryOperator::BslBsl(node) => BinaryOperator::BslBsl(folder.fold_bsl_bsl(node)),
BinaryOperator::BslBslEql(node) => {
BinaryOperator::BslBslEql(folder.fold_bsl_bsl_eql(node))
}
BinaryOperator::Crt(node) => BinaryOperator::Crt(folder.fold_crt(node)),
BinaryOperator::CrtEql(node) => BinaryOperator::CrtEql(folder.fold_crt_eql(node)),
BinaryOperator::CrtMulMul(node) => {
BinaryOperator::CrtMulMul(folder.fold_crt_mul_mul(node))
}
BinaryOperator::CrtMulMulEql(node) => {
BinaryOperator::CrtMulMulEql(folder.fold_crt_mul_mul_eql(node))
}
BinaryOperator::CrtLst(node) => BinaryOperator::CrtLst(folder.fold_crt_lst(node)),
BinaryOperator::CrtLstEql(node) => {
BinaryOperator::CrtLstEql(folder.fold_crt_lst_eql(node))
}
BinaryOperator::CrtGst(node) => BinaryOperator::CrtGst(folder.fold_crt_gst(node)),
BinaryOperator::CrtGstEql(node) => {
BinaryOperator::CrtGstEql(folder.fold_crt_gst_eql(node))
}
BinaryOperator::CrtCrt(node) => BinaryOperator::CrtCrt(folder.fold_crt_crt(node)),
BinaryOperator::CrtCrtEql(node) => {
BinaryOperator::CrtCrtEql(folder.fold_crt_crt_eql(node))
}
BinaryOperator::Ubs(node) => BinaryOperator::Ubs(folder.fold_ubs(node)),
BinaryOperator::UbsEql(node) => BinaryOperator::UbsEql(folder.fold_ubs_eql(node)),
BinaryOperator::UbsLst(node) => BinaryOperator::UbsLst(folder.fold_ubs_lst(node)),
BinaryOperator::UbsLstEql(node) => {
BinaryOperator::UbsLstEql(folder.fold_ubs_lst_eql(node))
}
BinaryOperator::UbsGst(node) => BinaryOperator::UbsGst(folder.fold_ubs_gst(node)),
BinaryOperator::UbsGstEql(node) => {
BinaryOperator::UbsGstEql(folder.fold_ubs_gst_eql(node))
}
BinaryOperator::Pip(node) => BinaryOperator::Pip(folder.fold_pip(node)),
BinaryOperator::PipEql(node) => BinaryOperator::PipEql(folder.fold_pip_eql(node)),
BinaryOperator::PipSub(node) => BinaryOperator::PipSub(folder.fold_pip_sub(node)),
BinaryOperator::PipSubEql(node) => {
BinaryOperator::PipSubEql(folder.fold_pip_sub_eql(node))
}
BinaryOperator::PipUbs(node) => BinaryOperator::PipUbs(folder.fold_pip_ubs(node)),
BinaryOperator::PipUbsEql(node) => {
BinaryOperator::PipUbsEql(folder.fold_pip_ubs_eql(node))
}
BinaryOperator::PipPip(node) => BinaryOperator::PipPip(folder.fold_pip_pip(node)),
BinaryOperator::PipPipEql(node) => {
BinaryOperator::PipPipEql(folder.fold_pip_pip_eql(node))
}
BinaryOperator::Tld(node) => BinaryOperator::Tld(folder.fold_tld(node)),
BinaryOperator::TldEql(node) => BinaryOperator::TldEql(folder.fold_tld_eql(node)),
BinaryOperator::Cdt(node) => BinaryOperator::Cdt(folder.fold_cdt(node)),
BinaryOperator::CdtEql(node) => BinaryOperator::CdtEql(folder.fold_cdt_eql(node)),
BinaryOperator::Box(node) => BinaryOperator::Box(folder.fold_box(node)),
BinaryOperator::BoxEql(node) => BinaryOperator::BoxEql(folder.fold_box_eql(node)),
BinaryOperator::Sfp(node) => BinaryOperator::Sfp(folder.fold_sfp(node)),
BinaryOperator::SfpEql(node) => BinaryOperator::SfpEql(folder.fold_sfp_eql(node)),
BinaryOperator::And(node) => BinaryOperator::And(folder.fold_and(node)),
BinaryOperator::Or(node) => BinaryOperator::Or(folder.fold_or(node)),
BinaryOperator::Space(node) => BinaryOperator::Space(folder.fold_space(node)),
BinaryOperator::Xor(node) => BinaryOperator::Xor(folder.fold_xor(node)),
}
}
pub fn fold_postfix_operator<F>(folder: &mut F, node: PostfixOperator) -> PostfixOperator
where
F: Fold + ?Sized,
{
match node {
PostfixOperator::Bng(node) => PostfixOperator::Bng(folder.fold_bng(node)),
PostfixOperator::Graded(node) => PostfixOperator::Graded(folder.fold_graded(node)),
PostfixOperator::CrtBng(node) => PostfixOperator::CrtBng(folder.fold_crt_bng(node)),
PostfixOperator::CrtMul(node) => PostfixOperator::CrtMul(folder.fold_crt_mul(node)),
PostfixOperator::CrtTld(node) => PostfixOperator::CrtTld(folder.fold_crt_tld(node)),
PostfixOperator::UbsBng(node) => PostfixOperator::UbsBng(folder.fold_ubs_bng(node)),
PostfixOperator::UbsMul(node) => PostfixOperator::UbsMul(folder.fold_ubs_mul(node)),
PostfixOperator::UbsTld(node) => PostfixOperator::UbsTld(folder.fold_ubs_tld(node)),
}
}
pub fn fold_debug_keyword<F>(folder: &mut F, node: DebugKeyword) -> DebugKeyword
where
F: Fold + ?Sized,
{
match node {
DebugKeyword::Step(node) => DebugKeyword::Step(folder.fold_step_keyword(node)),
DebugKeyword::Finish(node) => {
DebugKeyword::Finish(folder.fold_finish_keyword(node))
}
DebugKeyword::Shield(node) => {
DebugKeyword::Shield(folder.fold_shield_keyword(node))
}
DebugKeyword::Test(node) => DebugKeyword::Test(folder.fold_test_keyword(node)),
DebugKeyword::Time(node) => DebugKeyword::Time(folder.fold_time_keyword(node)),
DebugKeyword::Timing(node) => {
DebugKeyword::Timing(folder.fold_timing_keyword(node))
}
DebugKeyword::Breakpoint(node) => {
DebugKeyword::Breakpoint(folder.fold_breakpoint_keyword(node))
}
DebugKeyword::ElapsedTime(node) => {
DebugKeyword::ElapsedTime(folder.fold_elapsed_time_keyword(node))
}
DebugKeyword::ElapsedTiming(node) => {
DebugKeyword::ElapsedTiming(folder.fold_elapsed_timing_keyword(node))
}
DebugKeyword::Profile(node) => {
DebugKeyword::Profile(folder.fold_profile_keyword(node))
}
}
}
pub fn fold_try_fallback<F>(folder: &mut F, node: TryFallback) -> TryFallback
where
F: Fold + ?Sized,
{
match node {
TryFallback::ExceptClause(node) => {
TryFallback::ExceptClause(folder.fold_except_clause(node))
}
TryFallback::ElseClause(node) => {
TryFallback::ElseClause(folder.fold_else_clause(node))
}
}
}
pub fn fold_quote_specifier<F>(folder: &mut F, node: QuoteSpecifier) -> QuoteSpecifier
where
F: Fold + ?Sized,
{
match node {
QuoteSpecifier::Symbol(node) => {
QuoteSpecifier::Symbol(folder.fold_symbol_keyword(node))
}
QuoteSpecifier::Local(node) => {
QuoteSpecifier::Local(folder.fold_local_keyword(node))
}
QuoteSpecifier::Global(node) => {
QuoteSpecifier::Global(folder.fold_global_keyword(node))
}
QuoteSpecifier::ThreadVariable(node) => {
QuoteSpecifier::ThreadVariable(folder.fold_thread_variable_keyword(node))
}
QuoteSpecifier::ThreadLocal(node) => {
QuoteSpecifier::ThreadLocal(folder.fold_thread_local_keyword(node))
}
}
}
pub fn fold_any_cell<F>(folder: &mut F, node: AnyCell) -> AnyCell
where
F: Fold + ?Sized,
{
match node {
AnyCell::ExpressionCell(node) => {
AnyCell::ExpressionCell(folder.fold_expression_cell(node))
}
AnyCell::SequenceCell(node) => {
AnyCell::SequenceCell(folder.fold_sequence_cell(node))
}
AnyCell::MutedCell(node) => AnyCell::MutedCell(folder.fold_muted_cell(node)),
}
}
pub fn fold_component<F>(folder: &mut F, node: Component) -> Component
where
F: Fold + ?Sized,
{
match node {
Component::EmptyComponent(node) => {
Component::EmptyComponent(folder.fold_empty_component(node))
}
Component::Expr(node) => Component::Expr(folder.fold_expr(node)),
}
}
pub fn fold_sequence_element<F>(folder: &mut F, node: SequenceElement) -> SequenceElement
where
F: Fold + ?Sized,
{
match node {
SequenceElement::Component(node) => {
SequenceElement::Component(folder.fold_component(node))
}
SequenceElement::MutedGroup(node) => {
SequenceElement::MutedGroup(folder.fold_muted_group(node))
}
}
}
pub fn fold_string_element<F>(folder: &mut F, node: StringElement) -> StringElement
where
F: Fold + ?Sized,
{
match node {
StringElement::EscapeSequence(node) => {
StringElement::EscapeSequence(folder.fold_escape_sequence(node))
}
StringElement::StringContent(node) => {
StringElement::StringContent(folder.fold_string_content(node))
}
}
}
pub fn fold_raw_string_element<F>(
folder: &mut F,
node: RawStringElement,
) -> RawStringElement
where
F: Fold + ?Sized,
{
match node {
RawStringElement::EscapeSequence(node) => {
RawStringElement::EscapeSequence(folder.fold_escape_sequence(node))
}
RawStringElement::RawStringContent(node) => {
RawStringElement::RawStringContent(folder.fold_raw_string_content(node))
}
}
}
pub fn fold_collection<F>(folder: &mut F, node: Collection) -> Collection
where
F: Fold + ?Sized,
{
match node {
Collection::ParenthesizedExpression(node) => {
Collection::ParenthesizedExpression(folder.fold_parenthesized_expression(node))
}
Collection::Sequence(node) => Collection::Sequence(folder.fold_sequence(node)),
Collection::List(node) => Collection::List(folder.fold_list(node)),
Collection::Array(node) => Collection::Array(folder.fold_array(node)),
Collection::AngleBarList(node) => {
Collection::AngleBarList(folder.fold_angle_bar_list(node))
}
}
}
pub fn fold_binding_pack<F>(folder: &mut F, node: BindingPack) -> BindingPack
where
F: Fold + ?Sized,
{
match node {
BindingPack::ParenthesizedExpression(node) => {
BindingPack::ParenthesizedExpression(folder.fold_parenthesized_expression(node))
}
BindingPack::Sequence(node) => BindingPack::Sequence(folder.fold_sequence(node)),
BindingPack::List(node) => BindingPack::List(folder.fold_list(node)),
BindingPack::Array(node) => BindingPack::Array(folder.fold_array(node)),
BindingPack::AngleBarList(node) => {
BindingPack::AngleBarList(folder.fold_angle_bar_list(node))
}
}
}
pub fn fold_lambda_parameters<F>(folder: &mut F, node: LambdaParameters) -> LambdaParameters
where
F: Fold + ?Sized,
{
match node {
LambdaParameters::Symbol(node) => {
LambdaParameters::Symbol(folder.fold_symbol(node))
}
LambdaParameters::ParenthesizedExpression(node) => {
LambdaParameters::ParenthesizedExpression(
folder.fold_parenthesized_expression(node),
)
}
LambdaParameters::Sequence(node) => {
LambdaParameters::Sequence(folder.fold_sequence(node))
}
LambdaParameters::List(node) => LambdaParameters::List(folder.fold_list(node)),
LambdaParameters::Array(node) => LambdaParameters::Array(folder.fold_array(node)),
LambdaParameters::AngleBarList(node) => {
LambdaParameters::AngleBarList(folder.fold_angle_bar_list(node))
}
}
}
pub fn fold_operator_expr<F>(folder: &mut F, node: OperatorExpr) -> OperatorExpr
where
F: Fold + ?Sized,
{
match node {
OperatorExpr::AdjacentExpression(node) => {
OperatorExpr::AdjacentExpression(folder.fold_adjacent_expression(node))
}
OperatorExpr::BinaryExpression(node) => {
OperatorExpr::BinaryExpression(folder.fold_binary_expression(node))
}
OperatorExpr::PrefixExpression(node) => {
OperatorExpr::PrefixExpression(folder.fold_prefix_expression(node))
}
OperatorExpr::PostfixExpression(node) => {
OperatorExpr::PostfixExpression(folder.fold_postfix_expression(node))
}
}
}
pub fn fold_assignment_expr<F>(folder: &mut F, node: AssignmentExpr) -> AssignmentExpr
where
F: Fold + ?Sized,
{
match node {
AssignmentExpr::Assignment(node) => {
AssignmentExpr::Assignment(folder.fold_assignment(node))
}
AssignmentExpr::LocalAssignment(node) => {
AssignmentExpr::LocalAssignment(folder.fold_local_assignment(node))
}
AssignmentExpr::BinaryAssignment(node) => {
AssignmentExpr::BinaryAssignment(folder.fold_binary_assignment(node))
}
AssignmentExpr::BinaryInstallation(node) => {
AssignmentExpr::BinaryInstallation(folder.fold_binary_installation(node))
}
AssignmentExpr::PrefixAssignment(node) => {
AssignmentExpr::PrefixAssignment(folder.fold_prefix_assignment(node))
}
AssignmentExpr::PrefixInstallation(node) => {
AssignmentExpr::PrefixInstallation(folder.fold_prefix_installation(node))
}
AssignmentExpr::PostfixAssignment(node) => {
AssignmentExpr::PostfixAssignment(folder.fold_postfix_assignment(node))
}
AssignmentExpr::PostfixInstallation(node) => {
AssignmentExpr::PostfixInstallation(folder.fold_postfix_installation(node))
}
AssignmentExpr::StructuredBinding(node) => {
AssignmentExpr::StructuredBinding(folder.fold_structured_binding(node))
}
AssignmentExpr::LocalStructuredBinding(node) => {
AssignmentExpr::LocalStructuredBinding(
folder.fold_local_structured_binding(node),
)
}
AssignmentExpr::EvaluatedAssignment(node) => {
AssignmentExpr::EvaluatedAssignment(folder.fold_evaluated_assignment(node))
}
}
}
pub fn fold_expr<F>(folder: &mut F, node: Expr) -> Expr
where
F: Fold + ?Sized,
{
match node {
Expr::Collection(node) => Expr::Collection(folder.fold_collection(node)),
Expr::OperatorExpr(node) => Expr::OperatorExpr(folder.fold_operator_expr(node)),
Expr::AssignmentExpr(node) => {
Expr::AssignmentExpr(folder.fold_assignment_expr(node))
}
Expr::OptionExpression(node) => {
Expr::OptionExpression(folder.fold_option_expression(node))
}
Expr::LambdaExpression(node) => {
Expr::LambdaExpression(folder.fold_lambda_expression(node))
}
Expr::IfStatement(node) => Expr::IfStatement(folder.fold_if_statement(node)),
Expr::ForLoop(node) => Expr::ForLoop(folder.fold_for_loop(node)),
Expr::WhileLoop(node) => Expr::WhileLoop(folder.fold_while_loop(node)),
Expr::TryStatement(node) => Expr::TryStatement(folder.fold_try_statement(node)),
Expr::QuoteExpression(node) => {
Expr::QuoteExpression(folder.fold_quote_expression(node))
}
Expr::NewStatement(node) => Expr::NewStatement(folder.fold_new_statement(node)),
Expr::BreakStatement(node) => {
Expr::BreakStatement(folder.fold_break_statement(node))
}
Expr::ContinueStatement(node) => {
Expr::ContinueStatement(folder.fold_continue_statement(node))
}
Expr::ReturnStatement(node) => {
Expr::ReturnStatement(folder.fold_return_statement(node))
}
Expr::CatchStatement(node) => {
Expr::CatchStatement(folder.fold_catch_statement(node))
}
Expr::ThrowStatement(node) => {
Expr::ThrowStatement(folder.fold_throw_statement(node))
}
Expr::TrapStatement(node) => Expr::TrapStatement(folder.fold_trap_statement(node)),
Expr::DebugClause(node) => Expr::DebugClause(folder.fold_debug_clause(node)),
Expr::FloatLiteral(node) => Expr::FloatLiteral(folder.fold_float_literal(node)),
Expr::IntegerLiteral(node) => {
Expr::IntegerLiteral(folder.fold_integer_literal(node))
}
Expr::RawStringLiteral(node) => {
Expr::RawStringLiteral(folder.fold_raw_string_literal(node))
}
Expr::StringLiteral(node) => Expr::StringLiteral(folder.fold_string_literal(node)),
Expr::Symbol(node) => Expr::Symbol(folder.fold_symbol(node)),
}
}
pub fn fold_syntax_node<F>(folder: &mut F, node: SyntaxNode) -> SyntaxNode
where
F: Fold + ?Sized,
{
match node {
SyntaxNode::SourceFile(node) => {
SyntaxNode::SourceFile(folder.fold_source_file(node))
}
SyntaxNode::AnyCell(node) => SyntaxNode::AnyCell(folder.fold_any_cell(node)),
SyntaxNode::Expr(node) => SyntaxNode::Expr(folder.fold_expr(node)),
}
}
};
}