Lines Matching full:node
1030 pub fn fold_abi<F>(f: &mut F, node: crate::Abi) -> crate::Abi in fold_abi()
1035 extern_token: node.extern_token, in fold_abi()
1036 name: (node.name).map(|it| f.fold_lit_str(it)), in fold_abi()
1043 node: crate::AngleBracketedGenericArguments, in fold_angle_bracketed_generic_arguments()
1049 colon2_token: node.colon2_token, in fold_angle_bracketed_generic_arguments()
1050 lt_token: node.lt_token, in fold_angle_bracketed_generic_arguments()
1051 args: crate::punctuated::fold(node.args, f, F::fold_generic_argument), in fold_angle_bracketed_generic_arguments()
1052 gt_token: node.gt_token, in fold_angle_bracketed_generic_arguments()
1057 pub fn fold_arm<F>(f: &mut F, node: crate::Arm) -> crate::Arm in fold_arm()
1062 attrs: f.fold_attributes(node.attrs), in fold_arm()
1063 pat: f.fold_pat(node.pat), in fold_arm()
1064 guard: (node.guard).map(|it| ((it).0, Box::new(f.fold_expr(*(it).1)))), in fold_arm()
1065 fat_arrow_token: node.fat_arrow_token, in fold_arm()
1066 body: Box::new(f.fold_expr(*node.body)), in fold_arm()
1067 comma: node.comma, in fold_arm()
1072 pub fn fold_assoc_const<F>(f: &mut F, node: crate::AssocConst) -> crate::AssocConst in fold_assoc_const()
1077 ident: f.fold_ident(node.ident), in fold_assoc_const()
1078 generics: (node.generics).map(|it| f.fold_angle_bracketed_generic_arguments(it)), in fold_assoc_const()
1079 eq_token: node.eq_token, in fold_assoc_const()
1080 value: f.fold_expr(node.value), in fold_assoc_const()
1085 pub fn fold_assoc_type<F>(f: &mut F, node: crate::AssocType) -> crate::AssocType in fold_assoc_type()
1090 ident: f.fold_ident(node.ident), in fold_assoc_type()
1091 generics: (node.generics).map(|it| f.fold_angle_bracketed_generic_arguments(it)), in fold_assoc_type()
1092 eq_token: node.eq_token, in fold_assoc_type()
1093 ty: f.fold_type(node.ty), in fold_assoc_type()
1098 pub fn fold_attr_style<F>(f: &mut F, node: crate::AttrStyle) -> crate::AttrStyle in fold_attr_style()
1102 match node { in fold_attr_style()
1109 pub fn fold_attribute<F>(f: &mut F, node: crate::Attribute) -> crate::Attribute in fold_attribute()
1114 pound_token: node.pound_token, in fold_attribute()
1115 style: f.fold_attr_style(node.style), in fold_attribute()
1116 bracket_token: node.bracket_token, in fold_attribute()
1117 meta: f.fold_meta(node.meta), in fold_attribute()
1122 pub fn fold_bare_fn_arg<F>(f: &mut F, node: crate::BareFnArg) -> crate::BareFnArg in fold_bare_fn_arg()
1127 attrs: f.fold_attributes(node.attrs), in fold_bare_fn_arg()
1128 name: (node.name).map(|it| (f.fold_ident((it).0), (it).1)), in fold_bare_fn_arg()
1129 ty: f.fold_type(node.ty), in fold_bare_fn_arg()
1134 pub fn fold_bare_variadic<F>(f: &mut F, node: crate::BareVariadic) -> crate::BareVariadic in fold_bare_variadic()
1139 attrs: f.fold_attributes(node.attrs), in fold_bare_variadic()
1140 name: (node.name).map(|it| (f.fold_ident((it).0), (it).1)), in fold_bare_variadic()
1141 dots: node.dots, in fold_bare_variadic()
1142 comma: node.comma, in fold_bare_variadic()
1147 pub fn fold_bin_op<F>(f: &mut F, node: crate::BinOp) -> crate::BinOp in fold_bin_op()
1151 match node { in fold_bin_op()
1184 pub fn fold_block<F>(f: &mut F, node: crate::Block) -> crate::Block in fold_block()
1189 brace_token: node.brace_token, in fold_block()
1190 stmts: fold_vec(node.stmts, f, F::fold_stmt), in fold_block()
1197 node: crate::BoundLifetimes, in fold_bound_lifetimes()
1203 for_token: node.for_token, in fold_bound_lifetimes()
1204 lt_token: node.lt_token, in fold_bound_lifetimes()
1205 lifetimes: crate::punctuated::fold(node.lifetimes, f, F::fold_generic_param), in fold_bound_lifetimes()
1206 gt_token: node.gt_token, in fold_bound_lifetimes()
1213 node: crate::CapturedParam, in fold_captured_param()
1218 match node { in fold_captured_param()
1229 pub fn fold_const_param<F>(f: &mut F, node: crate::ConstParam) -> crate::ConstParam in fold_const_param()
1234 attrs: f.fold_attributes(node.attrs), in fold_const_param()
1235 const_token: node.const_token, in fold_const_param()
1236 ident: f.fold_ident(node.ident), in fold_const_param()
1237 colon_token: node.colon_token, in fold_const_param()
1238 ty: f.fold_type(node.ty), in fold_const_param()
1239 eq_token: node.eq_token, in fold_const_param()
1240 default: (node.default).map(|it| f.fold_expr(it)), in fold_const_param()
1245 pub fn fold_constraint<F>(f: &mut F, node: crate::Constraint) -> crate::Constraint in fold_constraint()
1250 ident: f.fold_ident(node.ident), in fold_constraint()
1251 generics: (node.generics).map(|it| f.fold_angle_bracketed_generic_arguments(it)), in fold_constraint()
1252 colon_token: node.colon_token, in fold_constraint()
1253 bounds: crate::punctuated::fold(node.bounds, f, F::fold_type_param_bound), in fold_constraint()
1258 pub fn fold_data<F>(f: &mut F, node: crate::Data) -> crate::Data in fold_data()
1262 match node { in fold_data()
1274 pub fn fold_data_enum<F>(f: &mut F, node: crate::DataEnum) -> crate::DataEnum in fold_data_enum()
1279 enum_token: node.enum_token, in fold_data_enum()
1280 brace_token: node.brace_token, in fold_data_enum()
1281 variants: crate::punctuated::fold(node.variants, f, F::fold_variant), in fold_data_enum()
1286 pub fn fold_data_struct<F>(f: &mut F, node: crate::DataStruct) -> crate::DataStruct in fold_data_struct()
1291 struct_token: node.struct_token, in fold_data_struct()
1292 fields: f.fold_fields(node.fields), in fold_data_struct()
1293 semi_token: node.semi_token, in fold_data_struct()
1298 pub fn fold_data_union<F>(f: &mut F, node: crate::DataUnion) -> crate::DataUnion in fold_data_union()
1303 union_token: node.union_token, in fold_data_union()
1304 fields: f.fold_fields_named(node.fields), in fold_data_union()
1309 pub fn fold_derive_input<F>(f: &mut F, node: crate::DeriveInput) -> crate::DeriveInput in fold_derive_input()
1314 attrs: f.fold_attributes(node.attrs), in fold_derive_input()
1315 vis: f.fold_visibility(node.vis), in fold_derive_input()
1316 ident: f.fold_ident(node.ident), in fold_derive_input()
1317 generics: f.fold_generics(node.generics), in fold_derive_input()
1318 data: f.fold_data(node.data), in fold_derive_input()
1323 pub fn fold_expr<F>(f: &mut F, node: crate::Expr) -> crate::Expr in fold_expr()
1327 match node { in fold_expr()
1442 pub fn fold_expr_array<F>(f: &mut F, node: crate::ExprArray) -> crate::ExprArray in fold_expr_array()
1447 attrs: f.fold_attributes(node.attrs), in fold_expr_array()
1448 bracket_token: node.bracket_token, in fold_expr_array()
1449 elems: crate::punctuated::fold(node.elems, f, F::fold_expr), in fold_expr_array()
1454 pub fn fold_expr_assign<F>(f: &mut F, node: crate::ExprAssign) -> crate::ExprAssign in fold_expr_assign()
1459 attrs: f.fold_attributes(node.attrs), in fold_expr_assign()
1460 left: Box::new(f.fold_expr(*node.left)), in fold_expr_assign()
1461 eq_token: node.eq_token, in fold_expr_assign()
1462 right: Box::new(f.fold_expr(*node.right)), in fold_expr_assign()
1467 pub fn fold_expr_async<F>(f: &mut F, node: crate::ExprAsync) -> crate::ExprAsync in fold_expr_async()
1472 attrs: f.fold_attributes(node.attrs), in fold_expr_async()
1473 async_token: node.async_token, in fold_expr_async()
1474 capture: node.capture, in fold_expr_async()
1475 block: f.fold_block(node.block), in fold_expr_async()
1480 pub fn fold_expr_await<F>(f: &mut F, node: crate::ExprAwait) -> crate::ExprAwait in fold_expr_await()
1485 attrs: f.fold_attributes(node.attrs), in fold_expr_await()
1486 base: Box::new(f.fold_expr(*node.base)), in fold_expr_await()
1487 dot_token: node.dot_token, in fold_expr_await()
1488 await_token: node.await_token, in fold_expr_await()
1493 pub fn fold_expr_binary<F>(f: &mut F, node: crate::ExprBinary) -> crate::ExprBinary in fold_expr_binary()
1498 attrs: f.fold_attributes(node.attrs), in fold_expr_binary()
1499 left: Box::new(f.fold_expr(*node.left)), in fold_expr_binary()
1500 op: f.fold_bin_op(node.op), in fold_expr_binary()
1501 right: Box::new(f.fold_expr(*node.right)), in fold_expr_binary()
1506 pub fn fold_expr_block<F>(f: &mut F, node: crate::ExprBlock) -> crate::ExprBlock in fold_expr_block()
1511 attrs: f.fold_attributes(node.attrs), in fold_expr_block()
1512 label: (node.label).map(|it| f.fold_label(it)), in fold_expr_block()
1513 block: f.fold_block(node.block), in fold_expr_block()
1518 pub fn fold_expr_break<F>(f: &mut F, node: crate::ExprBreak) -> crate::ExprBreak in fold_expr_break()
1523 attrs: f.fold_attributes(node.attrs), in fold_expr_break()
1524 break_token: node.break_token, in fold_expr_break()
1525 label: (node.label).map(|it| f.fold_lifetime(it)), in fold_expr_break()
1526 expr: (node.expr).map(|it| Box::new(f.fold_expr(*it))), in fold_expr_break()
1531 pub fn fold_expr_call<F>(f: &mut F, node: crate::ExprCall) -> crate::ExprCall in fold_expr_call()
1536 attrs: f.fold_attributes(node.attrs), in fold_expr_call()
1537 func: Box::new(f.fold_expr(*node.func)), in fold_expr_call()
1538 paren_token: node.paren_token, in fold_expr_call()
1539 args: crate::punctuated::fold(node.args, f, F::fold_expr), in fold_expr_call()
1544 pub fn fold_expr_cast<F>(f: &mut F, node: crate::ExprCast) -> crate::ExprCast in fold_expr_cast()
1549 attrs: f.fold_attributes(node.attrs), in fold_expr_cast()
1550 expr: Box::new(f.fold_expr(*node.expr)), in fold_expr_cast()
1551 as_token: node.as_token, in fold_expr_cast()
1552 ty: Box::new(f.fold_type(*node.ty)), in fold_expr_cast()
1557 pub fn fold_expr_closure<F>(f: &mut F, node: crate::ExprClosure) -> crate::ExprClosure in fold_expr_closure()
1562 attrs: f.fold_attributes(node.attrs), in fold_expr_closure()
1563 lifetimes: (node.lifetimes).map(|it| f.fold_bound_lifetimes(it)), in fold_expr_closure()
1564 constness: node.constness, in fold_expr_closure()
1565 movability: node.movability, in fold_expr_closure()
1566 asyncness: node.asyncness, in fold_expr_closure()
1567 capture: node.capture, in fold_expr_closure()
1568 or1_token: node.or1_token, in fold_expr_closure()
1569 inputs: crate::punctuated::fold(node.inputs, f, F::fold_pat), in fold_expr_closure()
1570 or2_token: node.or2_token, in fold_expr_closure()
1571 output: f.fold_return_type(node.output), in fold_expr_closure()
1572 body: Box::new(f.fold_expr(*node.body)), in fold_expr_closure()
1577 pub fn fold_expr_const<F>(f: &mut F, node: crate::ExprConst) -> crate::ExprConst in fold_expr_const()
1582 attrs: f.fold_attributes(node.attrs), in fold_expr_const()
1583 const_token: node.const_token, in fold_expr_const()
1584 block: f.fold_block(node.block), in fold_expr_const()
1589 pub fn fold_expr_continue<F>(f: &mut F, node: crate::ExprContinue) -> crate::ExprContinue in fold_expr_continue()
1594 attrs: f.fold_attributes(node.attrs), in fold_expr_continue()
1595 continue_token: node.continue_token, in fold_expr_continue()
1596 label: (node.label).map(|it| f.fold_lifetime(it)), in fold_expr_continue()
1601 pub fn fold_expr_field<F>(f: &mut F, node: crate::ExprField) -> crate::ExprField in fold_expr_field()
1606 attrs: f.fold_attributes(node.attrs), in fold_expr_field()
1607 base: Box::new(f.fold_expr(*node.base)), in fold_expr_field()
1608 dot_token: node.dot_token, in fold_expr_field()
1609 member: f.fold_member(node.member), in fold_expr_field()
1614 pub fn fold_expr_for_loop<F>(f: &mut F, node: crate::ExprForLoop) -> crate::ExprForLoop in fold_expr_for_loop()
1619 attrs: f.fold_attributes(node.attrs), in fold_expr_for_loop()
1620 label: (node.label).map(|it| f.fold_label(it)), in fold_expr_for_loop()
1621 for_token: node.for_token, in fold_expr_for_loop()
1622 pat: Box::new(f.fold_pat(*node.pat)), in fold_expr_for_loop()
1623 in_token: node.in_token, in fold_expr_for_loop()
1624 expr: Box::new(f.fold_expr(*node.expr)), in fold_expr_for_loop()
1625 body: f.fold_block(node.body), in fold_expr_for_loop()
1630 pub fn fold_expr_group<F>(f: &mut F, node: crate::ExprGroup) -> crate::ExprGroup in fold_expr_group()
1635 attrs: f.fold_attributes(node.attrs), in fold_expr_group()
1636 group_token: node.group_token, in fold_expr_group()
1637 expr: Box::new(f.fold_expr(*node.expr)), in fold_expr_group()
1642 pub fn fold_expr_if<F>(f: &mut F, node: crate::ExprIf) -> crate::ExprIf in fold_expr_if()
1647 attrs: f.fold_attributes(node.attrs), in fold_expr_if()
1648 if_token: node.if_token, in fold_expr_if()
1649 cond: Box::new(f.fold_expr(*node.cond)), in fold_expr_if()
1650 then_branch: f.fold_block(node.then_branch), in fold_expr_if()
1651 else_branch: (node.else_branch) in fold_expr_if()
1657 pub fn fold_expr_index<F>(f: &mut F, node: crate::ExprIndex) -> crate::ExprIndex in fold_expr_index()
1662 attrs: f.fold_attributes(node.attrs), in fold_expr_index()
1663 expr: Box::new(f.fold_expr(*node.expr)), in fold_expr_index()
1664 bracket_token: node.bracket_token, in fold_expr_index()
1665 index: Box::new(f.fold_expr(*node.index)), in fold_expr_index()
1670 pub fn fold_expr_infer<F>(f: &mut F, node: crate::ExprInfer) -> crate::ExprInfer in fold_expr_infer()
1675 attrs: f.fold_attributes(node.attrs), in fold_expr_infer()
1676 underscore_token: node.underscore_token, in fold_expr_infer()
1681 pub fn fold_expr_let<F>(f: &mut F, node: crate::ExprLet) -> crate::ExprLet in fold_expr_let()
1686 attrs: f.fold_attributes(node.attrs), in fold_expr_let()
1687 let_token: node.let_token, in fold_expr_let()
1688 pat: Box::new(f.fold_pat(*node.pat)), in fold_expr_let()
1689 eq_token: node.eq_token, in fold_expr_let()
1690 expr: Box::new(f.fold_expr(*node.expr)), in fold_expr_let()
1695 pub fn fold_expr_lit<F>(f: &mut F, node: crate::ExprLit) -> crate::ExprLit in fold_expr_lit()
1700 attrs: f.fold_attributes(node.attrs), in fold_expr_lit()
1701 lit: f.fold_lit(node.lit), in fold_expr_lit()
1706 pub fn fold_expr_loop<F>(f: &mut F, node: crate::ExprLoop) -> crate::ExprLoop in fold_expr_loop()
1711 attrs: f.fold_attributes(node.attrs), in fold_expr_loop()
1712 label: (node.label).map(|it| f.fold_label(it)), in fold_expr_loop()
1713 loop_token: node.loop_token, in fold_expr_loop()
1714 body: f.fold_block(node.body), in fold_expr_loop()
1719 pub fn fold_expr_macro<F>(f: &mut F, node: crate::ExprMacro) -> crate::ExprMacro in fold_expr_macro()
1724 attrs: f.fold_attributes(node.attrs), in fold_expr_macro()
1725 mac: f.fold_macro(node.mac), in fold_expr_macro()
1730 pub fn fold_expr_match<F>(f: &mut F, node: crate::ExprMatch) -> crate::ExprMatch in fold_expr_match()
1735 attrs: f.fold_attributes(node.attrs), in fold_expr_match()
1736 match_token: node.match_token, in fold_expr_match()
1737 expr: Box::new(f.fold_expr(*node.expr)), in fold_expr_match()
1738 brace_token: node.brace_token, in fold_expr_match()
1739 arms: fold_vec(node.arms, f, F::fold_arm), in fold_expr_match()
1746 node: crate::ExprMethodCall, in fold_expr_method_call()
1752 attrs: f.fold_attributes(node.attrs), in fold_expr_method_call()
1753 receiver: Box::new(f.fold_expr(*node.receiver)), in fold_expr_method_call()
1754 dot_token: node.dot_token, in fold_expr_method_call()
1755 method: f.fold_ident(node.method), in fold_expr_method_call()
1756 turbofish: (node.turbofish) in fold_expr_method_call()
1758 paren_token: node.paren_token, in fold_expr_method_call()
1759 args: crate::punctuated::fold(node.args, f, F::fold_expr), in fold_expr_method_call()
1764 pub fn fold_expr_paren<F>(f: &mut F, node: crate::ExprParen) -> crate::ExprParen in fold_expr_paren()
1769 attrs: f.fold_attributes(node.attrs), in fold_expr_paren()
1770 paren_token: node.paren_token, in fold_expr_paren()
1771 expr: Box::new(f.fold_expr(*node.expr)), in fold_expr_paren()
1776 pub fn fold_expr_path<F>(f: &mut F, node: crate::ExprPath) -> crate::ExprPath in fold_expr_path()
1781 attrs: f.fold_attributes(node.attrs), in fold_expr_path()
1782 qself: (node.qself).map(|it| f.fold_qself(it)), in fold_expr_path()
1783 path: f.fold_path(node.path), in fold_expr_path()
1788 pub fn fold_expr_range<F>(f: &mut F, node: crate::ExprRange) -> crate::ExprRange in fold_expr_range()
1793 attrs: f.fold_attributes(node.attrs), in fold_expr_range()
1794 start: (node.start).map(|it| Box::new(f.fold_expr(*it))), in fold_expr_range()
1795 limits: f.fold_range_limits(node.limits), in fold_expr_range()
1796 end: (node.end).map(|it| Box::new(f.fold_expr(*it))), in fold_expr_range()
1801 pub fn fold_expr_raw_addr<F>(f: &mut F, node: crate::ExprRawAddr) -> crate::ExprRawAddr in fold_expr_raw_addr()
1806 attrs: f.fold_attributes(node.attrs), in fold_expr_raw_addr()
1807 and_token: node.and_token, in fold_expr_raw_addr()
1808 raw: node.raw, in fold_expr_raw_addr()
1809 mutability: f.fold_pointer_mutability(node.mutability), in fold_expr_raw_addr()
1810 expr: Box::new(f.fold_expr(*node.expr)), in fold_expr_raw_addr()
1817 node: crate::ExprReference, in fold_expr_reference()
1823 attrs: f.fold_attributes(node.attrs), in fold_expr_reference()
1824 and_token: node.and_token, in fold_expr_reference()
1825 mutability: node.mutability, in fold_expr_reference()
1826 expr: Box::new(f.fold_expr(*node.expr)), in fold_expr_reference()
1831 pub fn fold_expr_repeat<F>(f: &mut F, node: crate::ExprRepeat) -> crate::ExprRepeat in fold_expr_repeat()
1836 attrs: f.fold_attributes(node.attrs), in fold_expr_repeat()
1837 bracket_token: node.bracket_token, in fold_expr_repeat()
1838 expr: Box::new(f.fold_expr(*node.expr)), in fold_expr_repeat()
1839 semi_token: node.semi_token, in fold_expr_repeat()
1840 len: Box::new(f.fold_expr(*node.len)), in fold_expr_repeat()
1845 pub fn fold_expr_return<F>(f: &mut F, node: crate::ExprReturn) -> crate::ExprReturn in fold_expr_return()
1850 attrs: f.fold_attributes(node.attrs), in fold_expr_return()
1851 return_token: node.return_token, in fold_expr_return()
1852 expr: (node.expr).map(|it| Box::new(f.fold_expr(*it))), in fold_expr_return()
1857 pub fn fold_expr_struct<F>(f: &mut F, node: crate::ExprStruct) -> crate::ExprStruct in fold_expr_struct()
1862 attrs: f.fold_attributes(node.attrs), in fold_expr_struct()
1863 qself: (node.qself).map(|it| f.fold_qself(it)), in fold_expr_struct()
1864 path: f.fold_path(node.path), in fold_expr_struct()
1865 brace_token: node.brace_token, in fold_expr_struct()
1866 fields: crate::punctuated::fold(node.fields, f, F::fold_field_value), in fold_expr_struct()
1867 dot2_token: node.dot2_token, in fold_expr_struct()
1868 rest: (node.rest).map(|it| Box::new(f.fold_expr(*it))), in fold_expr_struct()
1873 pub fn fold_expr_try<F>(f: &mut F, node: crate::ExprTry) -> crate::ExprTry in fold_expr_try()
1878 attrs: f.fold_attributes(node.attrs), in fold_expr_try()
1879 expr: Box::new(f.fold_expr(*node.expr)), in fold_expr_try()
1880 question_token: node.question_token, in fold_expr_try()
1887 node: crate::ExprTryBlock, in fold_expr_try_block()
1893 attrs: f.fold_attributes(node.attrs), in fold_expr_try_block()
1894 try_token: node.try_token, in fold_expr_try_block()
1895 block: f.fold_block(node.block), in fold_expr_try_block()
1900 pub fn fold_expr_tuple<F>(f: &mut F, node: crate::ExprTuple) -> crate::ExprTuple in fold_expr_tuple()
1905 attrs: f.fold_attributes(node.attrs), in fold_expr_tuple()
1906 paren_token: node.paren_token, in fold_expr_tuple()
1907 elems: crate::punctuated::fold(node.elems, f, F::fold_expr), in fold_expr_tuple()
1912 pub fn fold_expr_unary<F>(f: &mut F, node: crate::ExprUnary) -> crate::ExprUnary in fold_expr_unary()
1917 attrs: f.fold_attributes(node.attrs), in fold_expr_unary()
1918 op: f.fold_un_op(node.op), in fold_expr_unary()
1919 expr: Box::new(f.fold_expr(*node.expr)), in fold_expr_unary()
1924 pub fn fold_expr_unsafe<F>(f: &mut F, node: crate::ExprUnsafe) -> crate::ExprUnsafe in fold_expr_unsafe()
1929 attrs: f.fold_attributes(node.attrs), in fold_expr_unsafe()
1930 unsafe_token: node.unsafe_token, in fold_expr_unsafe()
1931 block: f.fold_block(node.block), in fold_expr_unsafe()
1936 pub fn fold_expr_while<F>(f: &mut F, node: crate::ExprWhile) -> crate::ExprWhile in fold_expr_while()
1941 attrs: f.fold_attributes(node.attrs), in fold_expr_while()
1942 label: (node.label).map(|it| f.fold_label(it)), in fold_expr_while()
1943 while_token: node.while_token, in fold_expr_while()
1944 cond: Box::new(f.fold_expr(*node.cond)), in fold_expr_while()
1945 body: f.fold_block(node.body), in fold_expr_while()
1950 pub fn fold_expr_yield<F>(f: &mut F, node: crate::ExprYield) -> crate::ExprYield in fold_expr_yield()
1955 attrs: f.fold_attributes(node.attrs), in fold_expr_yield()
1956 yield_token: node.yield_token, in fold_expr_yield()
1957 expr: (node.expr).map(|it| Box::new(f.fold_expr(*it))), in fold_expr_yield()
1962 pub fn fold_field<F>(f: &mut F, node: crate::Field) -> crate::Field in fold_field()
1967 attrs: f.fold_attributes(node.attrs), in fold_field()
1968 vis: f.fold_visibility(node.vis), in fold_field()
1969 mutability: f.fold_field_mutability(node.mutability), in fold_field()
1970 ident: (node.ident).map(|it| f.fold_ident(it)), in fold_field()
1971 colon_token: node.colon_token, in fold_field()
1972 ty: f.fold_type(node.ty), in fold_field()
1979 node: crate::FieldMutability, in fold_field_mutability()
1984 match node { in fold_field_mutability()
1990 pub fn fold_field_pat<F>(f: &mut F, node: crate::FieldPat) -> crate::FieldPat in fold_field_pat()
1995 attrs: f.fold_attributes(node.attrs), in fold_field_pat()
1996 member: f.fold_member(node.member), in fold_field_pat()
1997 colon_token: node.colon_token, in fold_field_pat()
1998 pat: Box::new(f.fold_pat(*node.pat)), in fold_field_pat()
2003 pub fn fold_field_value<F>(f: &mut F, node: crate::FieldValue) -> crate::FieldValue in fold_field_value()
2008 attrs: f.fold_attributes(node.attrs), in fold_field_value()
2009 member: f.fold_member(node.member), in fold_field_value()
2010 colon_token: node.colon_token, in fold_field_value()
2011 expr: f.fold_expr(node.expr), in fold_field_value()
2016 pub fn fold_fields<F>(f: &mut F, node: crate::Fields) -> crate::Fields in fold_fields()
2020 match node { in fold_fields()
2032 pub fn fold_fields_named<F>(f: &mut F, node: crate::FieldsNamed) -> crate::FieldsNamed in fold_fields_named()
2037 brace_token: node.brace_token, in fold_fields_named()
2038 named: crate::punctuated::fold(node.named, f, F::fold_field), in fold_fields_named()
2045 node: crate::FieldsUnnamed, in fold_fields_unnamed()
2051 paren_token: node.paren_token, in fold_fields_unnamed()
2052 unnamed: crate::punctuated::fold(node.unnamed, f, F::fold_field), in fold_fields_unnamed()
2057 pub fn fold_file<F>(f: &mut F, node: crate::File) -> crate::File in fold_file()
2062 shebang: node.shebang, in fold_file()
2063 attrs: f.fold_attributes(node.attrs), in fold_file()
2064 items: fold_vec(node.items, f, F::fold_item), in fold_file()
2069 pub fn fold_fn_arg<F>(f: &mut F, node: crate::FnArg) -> crate::FnArg in fold_fn_arg()
2073 match node { in fold_fn_arg()
2084 pub fn fold_foreign_item<F>(f: &mut F, node: crate::ForeignItem) -> crate::ForeignItem in fold_foreign_item()
2088 match node { in fold_foreign_item()
2110 node: crate::ForeignItemFn, in fold_foreign_item_fn()
2116 attrs: f.fold_attributes(node.attrs), in fold_foreign_item_fn()
2117 vis: f.fold_visibility(node.vis), in fold_foreign_item_fn()
2118 sig: f.fold_signature(node.sig), in fold_foreign_item_fn()
2119 semi_token: node.semi_token, in fold_foreign_item_fn()
2126 node: crate::ForeignItemMacro, in fold_foreign_item_macro()
2132 attrs: f.fold_attributes(node.attrs), in fold_foreign_item_macro()
2133 mac: f.fold_macro(node.mac), in fold_foreign_item_macro()
2134 semi_token: node.semi_token, in fold_foreign_item_macro()
2141 node: crate::ForeignItemStatic, in fold_foreign_item_static()
2147 attrs: f.fold_attributes(node.attrs), in fold_foreign_item_static()
2148 vis: f.fold_visibility(node.vis), in fold_foreign_item_static()
2149 static_token: node.static_token, in fold_foreign_item_static()
2150 mutability: f.fold_static_mutability(node.mutability), in fold_foreign_item_static()
2151 ident: f.fold_ident(node.ident), in fold_foreign_item_static()
2152 colon_token: node.colon_token, in fold_foreign_item_static()
2153 ty: Box::new(f.fold_type(*node.ty)), in fold_foreign_item_static()
2154 semi_token: node.semi_token, in fold_foreign_item_static()
2161 node: crate::ForeignItemType, in fold_foreign_item_type()
2167 attrs: f.fold_attributes(node.attrs), in fold_foreign_item_type()
2168 vis: f.fold_visibility(node.vis), in fold_foreign_item_type()
2169 type_token: node.type_token, in fold_foreign_item_type()
2170 ident: f.fold_ident(node.ident), in fold_foreign_item_type()
2171 generics: f.fold_generics(node.generics), in fold_foreign_item_type()
2172 semi_token: node.semi_token, in fold_foreign_item_type()
2179 node: crate::GenericArgument, in fold_generic_argument()
2184 match node { in fold_generic_argument()
2207 pub fn fold_generic_param<F>(f: &mut F, node: crate::GenericParam) -> crate::GenericParam in fold_generic_param()
2211 match node { in fold_generic_param()
2225 pub fn fold_generics<F>(f: &mut F, node: crate::Generics) -> crate::Generics in fold_generics()
2230 lt_token: node.lt_token, in fold_generics()
2231 params: crate::punctuated::fold(node.params, f, F::fold_generic_param), in fold_generics()
2232 gt_token: node.gt_token, in fold_generics()
2233 where_clause: (node.where_clause).map(|it| f.fold_where_clause(it)), in fold_generics()
2236 pub fn fold_ident<F>(f: &mut F, node: proc_macro2::Ident) -> proc_macro2::Ident in fold_ident()
2240 let mut node = node; in fold_ident() localVariable
2241 let span = f.fold_span(node.span()); in fold_ident()
2242 node.set_span(span); in fold_ident()
2243 node in fold_ident()
2247 pub fn fold_impl_item<F>(f: &mut F, node: crate::ImplItem) -> crate::ImplItem in fold_impl_item()
2251 match node { in fold_impl_item()
2273 node: crate::ImplItemConst, in fold_impl_item_const()
2279 attrs: f.fold_attributes(node.attrs), in fold_impl_item_const()
2280 vis: f.fold_visibility(node.vis), in fold_impl_item_const()
2281 defaultness: node.defaultness, in fold_impl_item_const()
2282 const_token: node.const_token, in fold_impl_item_const()
2283 ident: f.fold_ident(node.ident), in fold_impl_item_const()
2284 generics: f.fold_generics(node.generics), in fold_impl_item_const()
2285 colon_token: node.colon_token, in fold_impl_item_const()
2286 ty: f.fold_type(node.ty), in fold_impl_item_const()
2287 eq_token: node.eq_token, in fold_impl_item_const()
2288 expr: f.fold_expr(node.expr), in fold_impl_item_const()
2289 semi_token: node.semi_token, in fold_impl_item_const()
2294 pub fn fold_impl_item_fn<F>(f: &mut F, node: crate::ImplItemFn) -> crate::ImplItemFn in fold_impl_item_fn()
2299 attrs: f.fold_attributes(node.attrs), in fold_impl_item_fn()
2300 vis: f.fold_visibility(node.vis), in fold_impl_item_fn()
2301 defaultness: node.defaultness, in fold_impl_item_fn()
2302 sig: f.fold_signature(node.sig), in fold_impl_item_fn()
2303 block: f.fold_block(node.block), in fold_impl_item_fn()
2310 node: crate::ImplItemMacro, in fold_impl_item_macro()
2316 attrs: f.fold_attributes(node.attrs), in fold_impl_item_macro()
2317 mac: f.fold_macro(node.mac), in fold_impl_item_macro()
2318 semi_token: node.semi_token, in fold_impl_item_macro()
2325 node: crate::ImplItemType, in fold_impl_item_type()
2331 attrs: f.fold_attributes(node.attrs), in fold_impl_item_type()
2332 vis: f.fold_visibility(node.vis), in fold_impl_item_type()
2333 defaultness: node.defaultness, in fold_impl_item_type()
2334 type_token: node.type_token, in fold_impl_item_type()
2335 ident: f.fold_ident(node.ident), in fold_impl_item_type()
2336 generics: f.fold_generics(node.generics), in fold_impl_item_type()
2337 eq_token: node.eq_token, in fold_impl_item_type()
2338 ty: f.fold_type(node.ty), in fold_impl_item_type()
2339 semi_token: node.semi_token, in fold_impl_item_type()
2346 node: crate::ImplRestriction, in fold_impl_restriction()
2351 match node {} in fold_impl_restriction()
2355 pub fn fold_index<F>(f: &mut F, node: crate::Index) -> crate::Index in fold_index()
2360 index: node.index, in fold_index()
2361 span: f.fold_span(node.span), in fold_index()
2366 pub fn fold_item<F>(f: &mut F, node: crate::Item) -> crate::Item in fold_item()
2370 match node { in fold_item()
2411 pub fn fold_item_const<F>(f: &mut F, node: crate::ItemConst) -> crate::ItemConst in fold_item_const()
2416 attrs: f.fold_attributes(node.attrs), in fold_item_const()
2417 vis: f.fold_visibility(node.vis), in fold_item_const()
2418 const_token: node.const_token, in fold_item_const()
2419 ident: f.fold_ident(node.ident), in fold_item_const()
2420 generics: f.fold_generics(node.generics), in fold_item_const()
2421 colon_token: node.colon_token, in fold_item_const()
2422 ty: Box::new(f.fold_type(*node.ty)), in fold_item_const()
2423 eq_token: node.eq_token, in fold_item_const()
2424 expr: Box::new(f.fold_expr(*node.expr)), in fold_item_const()
2425 semi_token: node.semi_token, in fold_item_const()
2430 pub fn fold_item_enum<F>(f: &mut F, node: crate::ItemEnum) -> crate::ItemEnum in fold_item_enum()
2435 attrs: f.fold_attributes(node.attrs), in fold_item_enum()
2436 vis: f.fold_visibility(node.vis), in fold_item_enum()
2437 enum_token: node.enum_token, in fold_item_enum()
2438 ident: f.fold_ident(node.ident), in fold_item_enum()
2439 generics: f.fold_generics(node.generics), in fold_item_enum()
2440 brace_token: node.brace_token, in fold_item_enum()
2441 variants: crate::punctuated::fold(node.variants, f, F::fold_variant), in fold_item_enum()
2448 node: crate::ItemExternCrate, in fold_item_extern_crate()
2454 attrs: f.fold_attributes(node.attrs), in fold_item_extern_crate()
2455 vis: f.fold_visibility(node.vis), in fold_item_extern_crate()
2456 extern_token: node.extern_token, in fold_item_extern_crate()
2457 crate_token: node.crate_token, in fold_item_extern_crate()
2458 ident: f.fold_ident(node.ident), in fold_item_extern_crate()
2459 rename: (node.rename).map(|it| ((it).0, f.fold_ident((it).1))), in fold_item_extern_crate()
2460 semi_token: node.semi_token, in fold_item_extern_crate()
2465 pub fn fold_item_fn<F>(f: &mut F, node: crate::ItemFn) -> crate::ItemFn in fold_item_fn()
2470 attrs: f.fold_attributes(node.attrs), in fold_item_fn()
2471 vis: f.fold_visibility(node.vis), in fold_item_fn()
2472 sig: f.fold_signature(node.sig), in fold_item_fn()
2473 block: Box::new(f.fold_block(*node.block)), in fold_item_fn()
2480 node: crate::ItemForeignMod, in fold_item_foreign_mod()
2486 attrs: f.fold_attributes(node.attrs), in fold_item_foreign_mod()
2487 unsafety: node.unsafety, in fold_item_foreign_mod()
2488 abi: f.fold_abi(node.abi), in fold_item_foreign_mod()
2489 brace_token: node.brace_token, in fold_item_foreign_mod()
2490 items: fold_vec(node.items, f, F::fold_foreign_item), in fold_item_foreign_mod()
2495 pub fn fold_item_impl<F>(f: &mut F, node: crate::ItemImpl) -> crate::ItemImpl in fold_item_impl()
2500 attrs: f.fold_attributes(node.attrs), in fold_item_impl()
2501 defaultness: node.defaultness, in fold_item_impl()
2502 unsafety: node.unsafety, in fold_item_impl()
2503 impl_token: node.impl_token, in fold_item_impl()
2504 generics: f.fold_generics(node.generics), in fold_item_impl()
2505 trait_: (node.trait_).map(|it| ((it).0, f.fold_path((it).1), (it).2)), in fold_item_impl()
2506 self_ty: Box::new(f.fold_type(*node.self_ty)), in fold_item_impl()
2507 brace_token: node.brace_token, in fold_item_impl()
2508 items: fold_vec(node.items, f, F::fold_impl_item), in fold_item_impl()
2513 pub fn fold_item_macro<F>(f: &mut F, node: crate::ItemMacro) -> crate::ItemMacro in fold_item_macro()
2518 attrs: f.fold_attributes(node.attrs), in fold_item_macro()
2519 ident: (node.ident).map(|it| f.fold_ident(it)), in fold_item_macro()
2520 mac: f.fold_macro(node.mac), in fold_item_macro()
2521 semi_token: node.semi_token, in fold_item_macro()
2526 pub fn fold_item_mod<F>(f: &mut F, node: crate::ItemMod) -> crate::ItemMod in fold_item_mod()
2531 attrs: f.fold_attributes(node.attrs), in fold_item_mod()
2532 vis: f.fold_visibility(node.vis), in fold_item_mod()
2533 unsafety: node.unsafety, in fold_item_mod()
2534 mod_token: node.mod_token, in fold_item_mod()
2535 ident: f.fold_ident(node.ident), in fold_item_mod()
2536 content: (node.content).map(|it| ((it).0, fold_vec((it).1, f, F::fold_item))), in fold_item_mod()
2537 semi: node.semi, in fold_item_mod()
2542 pub fn fold_item_static<F>(f: &mut F, node: crate::ItemStatic) -> crate::ItemStatic in fold_item_static()
2547 attrs: f.fold_attributes(node.attrs), in fold_item_static()
2548 vis: f.fold_visibility(node.vis), in fold_item_static()
2549 static_token: node.static_token, in fold_item_static()
2550 mutability: f.fold_static_mutability(node.mutability), in fold_item_static()
2551 ident: f.fold_ident(node.ident), in fold_item_static()
2552 colon_token: node.colon_token, in fold_item_static()
2553 ty: Box::new(f.fold_type(*node.ty)), in fold_item_static()
2554 eq_token: node.eq_token, in fold_item_static()
2555 expr: Box::new(f.fold_expr(*node.expr)), in fold_item_static()
2556 semi_token: node.semi_token, in fold_item_static()
2561 pub fn fold_item_struct<F>(f: &mut F, node: crate::ItemStruct) -> crate::ItemStruct in fold_item_struct()
2566 attrs: f.fold_attributes(node.attrs), in fold_item_struct()
2567 vis: f.fold_visibility(node.vis), in fold_item_struct()
2568 struct_token: node.struct_token, in fold_item_struct()
2569 ident: f.fold_ident(node.ident), in fold_item_struct()
2570 generics: f.fold_generics(node.generics), in fold_item_struct()
2571 fields: f.fold_fields(node.fields), in fold_item_struct()
2572 semi_token: node.semi_token, in fold_item_struct()
2577 pub fn fold_item_trait<F>(f: &mut F, node: crate::ItemTrait) -> crate::ItemTrait in fold_item_trait()
2582 attrs: f.fold_attributes(node.attrs), in fold_item_trait()
2583 vis: f.fold_visibility(node.vis), in fold_item_trait()
2584 unsafety: node.unsafety, in fold_item_trait()
2585 auto_token: node.auto_token, in fold_item_trait()
2586 restriction: (node.restriction).map(|it| f.fold_impl_restriction(it)), in fold_item_trait()
2587 trait_token: node.trait_token, in fold_item_trait()
2588 ident: f.fold_ident(node.ident), in fold_item_trait()
2589 generics: f.fold_generics(node.generics), in fold_item_trait()
2590 colon_token: node.colon_token, in fold_item_trait()
2592 node.supertraits, in fold_item_trait()
2596 brace_token: node.brace_token, in fold_item_trait()
2597 items: fold_vec(node.items, f, F::fold_trait_item), in fold_item_trait()
2604 node: crate::ItemTraitAlias, in fold_item_trait_alias()
2610 attrs: f.fold_attributes(node.attrs), in fold_item_trait_alias()
2611 vis: f.fold_visibility(node.vis), in fold_item_trait_alias()
2612 trait_token: node.trait_token, in fold_item_trait_alias()
2613 ident: f.fold_ident(node.ident), in fold_item_trait_alias()
2614 generics: f.fold_generics(node.generics), in fold_item_trait_alias()
2615 eq_token: node.eq_token, in fold_item_trait_alias()
2616 bounds: crate::punctuated::fold(node.bounds, f, F::fold_type_param_bound), in fold_item_trait_alias()
2617 semi_token: node.semi_token, in fold_item_trait_alias()
2622 pub fn fold_item_type<F>(f: &mut F, node: crate::ItemType) -> crate::ItemType in fold_item_type()
2627 attrs: f.fold_attributes(node.attrs), in fold_item_type()
2628 vis: f.fold_visibility(node.vis), in fold_item_type()
2629 type_token: node.type_token, in fold_item_type()
2630 ident: f.fold_ident(node.ident), in fold_item_type()
2631 generics: f.fold_generics(node.generics), in fold_item_type()
2632 eq_token: node.eq_token, in fold_item_type()
2633 ty: Box::new(f.fold_type(*node.ty)), in fold_item_type()
2634 semi_token: node.semi_token, in fold_item_type()
2639 pub fn fold_item_union<F>(f: &mut F, node: crate::ItemUnion) -> crate::ItemUnion in fold_item_union()
2644 attrs: f.fold_attributes(node.attrs), in fold_item_union()
2645 vis: f.fold_visibility(node.vis), in fold_item_union()
2646 union_token: node.union_token, in fold_item_union()
2647 ident: f.fold_ident(node.ident), in fold_item_union()
2648 generics: f.fold_generics(node.generics), in fold_item_union()
2649 fields: f.fold_fields_named(node.fields), in fold_item_union()
2654 pub fn fold_item_use<F>(f: &mut F, node: crate::ItemUse) -> crate::ItemUse in fold_item_use()
2659 attrs: f.fold_attributes(node.attrs), in fold_item_use()
2660 vis: f.fold_visibility(node.vis), in fold_item_use()
2661 use_token: node.use_token, in fold_item_use()
2662 leading_colon: node.leading_colon, in fold_item_use()
2663 tree: f.fold_use_tree(node.tree), in fold_item_use()
2664 semi_token: node.semi_token, in fold_item_use()
2669 pub fn fold_label<F>(f: &mut F, node: crate::Label) -> crate::Label in fold_label()
2674 name: f.fold_lifetime(node.name), in fold_label()
2675 colon_token: node.colon_token, in fold_label()
2678 pub fn fold_lifetime<F>(f: &mut F, node: crate::Lifetime) -> crate::Lifetime in fold_lifetime()
2683 apostrophe: f.fold_span(node.apostrophe), in fold_lifetime()
2684 ident: f.fold_ident(node.ident), in fold_lifetime()
2691 node: crate::LifetimeParam, in fold_lifetime_param()
2697 attrs: f.fold_attributes(node.attrs), in fold_lifetime_param()
2698 lifetime: f.fold_lifetime(node.lifetime), in fold_lifetime_param()
2699 colon_token: node.colon_token, in fold_lifetime_param()
2700 bounds: crate::punctuated::fold(node.bounds, f, F::fold_lifetime), in fold_lifetime_param()
2703 pub fn fold_lit<F>(f: &mut F, node: crate::Lit) -> crate::Lit in fold_lit()
2707 match node { in fold_lit()
2721 pub fn fold_lit_bool<F>(f: &mut F, node: crate::LitBool) -> crate::LitBool in fold_lit_bool()
2726 value: node.value, in fold_lit_bool()
2727 span: f.fold_span(node.span), in fold_lit_bool()
2730 pub fn fold_lit_byte<F>(f: &mut F, node: crate::LitByte) -> crate::LitByte in fold_lit_byte()
2734 let span = f.fold_span(node.span()); in fold_lit_byte()
2735 let mut node = node; in fold_lit_byte() localVariable
2736 node.set_span(span); in fold_lit_byte()
2737 node in fold_lit_byte()
2739 pub fn fold_lit_byte_str<F>(f: &mut F, node: crate::LitByteStr) -> crate::LitByteStr in fold_lit_byte_str()
2743 let span = f.fold_span(node.span()); in fold_lit_byte_str()
2744 let mut node = node; in fold_lit_byte_str() localVariable
2745 node.set_span(span); in fold_lit_byte_str()
2746 node in fold_lit_byte_str()
2748 pub fn fold_lit_cstr<F>(f: &mut F, node: crate::LitCStr) -> crate::LitCStr in fold_lit_cstr()
2752 let span = f.fold_span(node.span()); in fold_lit_cstr()
2753 let mut node = node; in fold_lit_cstr() localVariable
2754 node.set_span(span); in fold_lit_cstr()
2755 node in fold_lit_cstr()
2757 pub fn fold_lit_char<F>(f: &mut F, node: crate::LitChar) -> crate::LitChar in fold_lit_char()
2761 let span = f.fold_span(node.span()); in fold_lit_char()
2762 let mut node = node; in fold_lit_char() localVariable
2763 node.set_span(span); in fold_lit_char()
2764 node in fold_lit_char()
2766 pub fn fold_lit_float<F>(f: &mut F, node: crate::LitFloat) -> crate::LitFloat in fold_lit_float()
2770 let span = f.fold_span(node.span()); in fold_lit_float()
2771 let mut node = node; in fold_lit_float() localVariable
2772 node.set_span(span); in fold_lit_float()
2773 node in fold_lit_float()
2775 pub fn fold_lit_int<F>(f: &mut F, node: crate::LitInt) -> crate::LitInt in fold_lit_int()
2779 let span = f.fold_span(node.span()); in fold_lit_int()
2780 let mut node = node; in fold_lit_int() localVariable
2781 node.set_span(span); in fold_lit_int()
2782 node in fold_lit_int()
2784 pub fn fold_lit_str<F>(f: &mut F, node: crate::LitStr) -> crate::LitStr in fold_lit_str()
2788 let span = f.fold_span(node.span()); in fold_lit_str()
2789 let mut node = node; in fold_lit_str() localVariable
2790 node.set_span(span); in fold_lit_str()
2791 node in fold_lit_str()
2795 pub fn fold_local<F>(f: &mut F, node: crate::Local) -> crate::Local in fold_local()
2800 attrs: f.fold_attributes(node.attrs), in fold_local()
2801 let_token: node.let_token, in fold_local()
2802 pat: f.fold_pat(node.pat), in fold_local()
2803 init: (node.init).map(|it| f.fold_local_init(it)), in fold_local()
2804 semi_token: node.semi_token, in fold_local()
2809 pub fn fold_local_init<F>(f: &mut F, node: crate::LocalInit) -> crate::LocalInit in fold_local_init()
2814 eq_token: node.eq_token, in fold_local_init()
2815 expr: Box::new(f.fold_expr(*node.expr)), in fold_local_init()
2816 diverge: (node.diverge).map(|it| ((it).0, Box::new(f.fold_expr(*(it).1)))), in fold_local_init()
2821 pub fn fold_macro<F>(f: &mut F, node: crate::Macro) -> crate::Macro in fold_macro()
2826 path: f.fold_path(node.path), in fold_macro()
2827 bang_token: node.bang_token, in fold_macro()
2828 delimiter: f.fold_macro_delimiter(node.delimiter), in fold_macro()
2829 tokens: f.fold_token_stream(node.tokens), in fold_macro()
2836 node: crate::MacroDelimiter, in fold_macro_delimiter()
2841 match node { in fold_macro_delimiter()
2855 pub fn fold_member<F>(f: &mut F, node: crate::Member) -> crate::Member in fold_member()
2859 match node { in fold_member()
2870 pub fn fold_meta<F>(f: &mut F, node: crate::Meta) -> crate::Meta in fold_meta()
2874 match node { in fold_meta()
2884 pub fn fold_meta_list<F>(f: &mut F, node: crate::MetaList) -> crate::MetaList in fold_meta_list()
2889 path: f.fold_path(node.path), in fold_meta_list()
2890 delimiter: f.fold_macro_delimiter(node.delimiter), in fold_meta_list()
2891 tokens: f.fold_token_stream(node.tokens), in fold_meta_list()
2898 node: crate::MetaNameValue, in fold_meta_name_value()
2904 path: f.fold_path(node.path), in fold_meta_name_value()
2905 eq_token: node.eq_token, in fold_meta_name_value()
2906 value: f.fold_expr(node.value), in fold_meta_name_value()
2913 node: crate::ParenthesizedGenericArguments, in fold_parenthesized_generic_arguments()
2919 paren_token: node.paren_token, in fold_parenthesized_generic_arguments()
2920 inputs: crate::punctuated::fold(node.inputs, f, F::fold_type), in fold_parenthesized_generic_arguments()
2921 output: f.fold_return_type(node.output), in fold_parenthesized_generic_arguments()
2926 pub fn fold_pat<F>(f: &mut F, node: crate::Pat) -> crate::Pat in fold_pat()
2930 match node { in fold_pat()
2960 pub fn fold_pat_ident<F>(f: &mut F, node: crate::PatIdent) -> crate::PatIdent in fold_pat_ident()
2965 attrs: f.fold_attributes(node.attrs), in fold_pat_ident()
2966 by_ref: node.by_ref, in fold_pat_ident()
2967 mutability: node.mutability, in fold_pat_ident()
2968 ident: f.fold_ident(node.ident), in fold_pat_ident()
2969 subpat: (node.subpat).map(|it| ((it).0, Box::new(f.fold_pat(*(it).1)))), in fold_pat_ident()
2974 pub fn fold_pat_or<F>(f: &mut F, node: crate::PatOr) -> crate::PatOr in fold_pat_or()
2979 attrs: f.fold_attributes(node.attrs), in fold_pat_or()
2980 leading_vert: node.leading_vert, in fold_pat_or()
2981 cases: crate::punctuated::fold(node.cases, f, F::fold_pat), in fold_pat_or()
2986 pub fn fold_pat_paren<F>(f: &mut F, node: crate::PatParen) -> crate::PatParen in fold_pat_paren()
2991 attrs: f.fold_attributes(node.attrs), in fold_pat_paren()
2992 paren_token: node.paren_token, in fold_pat_paren()
2993 pat: Box::new(f.fold_pat(*node.pat)), in fold_pat_paren()
2998 pub fn fold_pat_reference<F>(f: &mut F, node: crate::PatReference) -> crate::PatReference in fold_pat_reference()
3003 attrs: f.fold_attributes(node.attrs), in fold_pat_reference()
3004 and_token: node.and_token, in fold_pat_reference()
3005 mutability: node.mutability, in fold_pat_reference()
3006 pat: Box::new(f.fold_pat(*node.pat)), in fold_pat_reference()
3011 pub fn fold_pat_rest<F>(f: &mut F, node: crate::PatRest) -> crate::PatRest in fold_pat_rest()
3016 attrs: f.fold_attributes(node.attrs), in fold_pat_rest()
3017 dot2_token: node.dot2_token, in fold_pat_rest()
3022 pub fn fold_pat_slice<F>(f: &mut F, node: crate::PatSlice) -> crate::PatSlice in fold_pat_slice()
3027 attrs: f.fold_attributes(node.attrs), in fold_pat_slice()
3028 bracket_token: node.bracket_token, in fold_pat_slice()
3029 elems: crate::punctuated::fold(node.elems, f, F::fold_pat), in fold_pat_slice()
3034 pub fn fold_pat_struct<F>(f: &mut F, node: crate::PatStruct) -> crate::PatStruct in fold_pat_struct()
3039 attrs: f.fold_attributes(node.attrs), in fold_pat_struct()
3040 qself: (node.qself).map(|it| f.fold_qself(it)), in fold_pat_struct()
3041 path: f.fold_path(node.path), in fold_pat_struct()
3042 brace_token: node.brace_token, in fold_pat_struct()
3043 fields: crate::punctuated::fold(node.fields, f, F::fold_field_pat), in fold_pat_struct()
3044 rest: (node.rest).map(|it| f.fold_pat_rest(it)), in fold_pat_struct()
3049 pub fn fold_pat_tuple<F>(f: &mut F, node: crate::PatTuple) -> crate::PatTuple in fold_pat_tuple()
3054 attrs: f.fold_attributes(node.attrs), in fold_pat_tuple()
3055 paren_token: node.paren_token, in fold_pat_tuple()
3056 elems: crate::punctuated::fold(node.elems, f, F::fold_pat), in fold_pat_tuple()
3063 node: crate::PatTupleStruct, in fold_pat_tuple_struct()
3069 attrs: f.fold_attributes(node.attrs), in fold_pat_tuple_struct()
3070 qself: (node.qself).map(|it| f.fold_qself(it)), in fold_pat_tuple_struct()
3071 path: f.fold_path(node.path), in fold_pat_tuple_struct()
3072 paren_token: node.paren_token, in fold_pat_tuple_struct()
3073 elems: crate::punctuated::fold(node.elems, f, F::fold_pat), in fold_pat_tuple_struct()
3078 pub fn fold_pat_type<F>(f: &mut F, node: crate::PatType) -> crate::PatType in fold_pat_type()
3083 attrs: f.fold_attributes(node.attrs), in fold_pat_type()
3084 pat: Box::new(f.fold_pat(*node.pat)), in fold_pat_type()
3085 colon_token: node.colon_token, in fold_pat_type()
3086 ty: Box::new(f.fold_type(*node.ty)), in fold_pat_type()
3091 pub fn fold_pat_wild<F>(f: &mut F, node: crate::PatWild) -> crate::PatWild in fold_pat_wild()
3096 attrs: f.fold_attributes(node.attrs), in fold_pat_wild()
3097 underscore_token: node.underscore_token, in fold_pat_wild()
3102 pub fn fold_path<F>(f: &mut F, node: crate::Path) -> crate::Path in fold_path()
3107 leading_colon: node.leading_colon, in fold_path()
3108 segments: crate::punctuated::fold(node.segments, f, F::fold_path_segment), in fold_path()
3115 node: crate::PathArguments, in fold_path_arguments()
3120 match node { in fold_path_arguments()
3136 pub fn fold_path_segment<F>(f: &mut F, node: crate::PathSegment) -> crate::PathSegment in fold_path_segment()
3141 ident: f.fold_ident(node.ident), in fold_path_segment()
3142 arguments: f.fold_path_arguments(node.arguments), in fold_path_segment()
3149 node: crate::PointerMutability, in fold_pointer_mutability()
3154 match node { in fold_pointer_mutability()
3167 node: crate::PreciseCapture, in fold_precise_capture()
3173 use_token: node.use_token, in fold_precise_capture()
3174 lt_token: node.lt_token, in fold_precise_capture()
3175 params: crate::punctuated::fold(node.params, f, F::fold_captured_param), in fold_precise_capture()
3176 gt_token: node.gt_token, in fold_precise_capture()
3183 node: crate::PredicateLifetime, in fold_predicate_lifetime()
3189 lifetime: f.fold_lifetime(node.lifetime), in fold_predicate_lifetime()
3190 colon_token: node.colon_token, in fold_predicate_lifetime()
3191 bounds: crate::punctuated::fold(node.bounds, f, F::fold_lifetime), in fold_predicate_lifetime()
3198 node: crate::PredicateType, in fold_predicate_type()
3204 lifetimes: (node.lifetimes).map(|it| f.fold_bound_lifetimes(it)), in fold_predicate_type()
3205 bounded_ty: f.fold_type(node.bounded_ty), in fold_predicate_type()
3206 colon_token: node.colon_token, in fold_predicate_type()
3207 bounds: crate::punctuated::fold(node.bounds, f, F::fold_type_param_bound), in fold_predicate_type()
3212 pub fn fold_qself<F>(f: &mut F, node: crate::QSelf) -> crate::QSelf in fold_qself()
3217 lt_token: node.lt_token, in fold_qself()
3218 ty: Box::new(f.fold_type(*node.ty)), in fold_qself()
3219 position: node.position, in fold_qself()
3220 as_token: node.as_token, in fold_qself()
3221 gt_token: node.gt_token, in fold_qself()
3226 pub fn fold_range_limits<F>(f: &mut F, node: crate::RangeLimits) -> crate::RangeLimits in fold_range_limits()
3230 match node { in fold_range_limits()
3239 pub fn fold_receiver<F>(f: &mut F, node: crate::Receiver) -> crate::Receiver in fold_receiver()
3244 attrs: f.fold_attributes(node.attrs), in fold_receiver()
3245 reference: (node.reference) in fold_receiver()
3247 mutability: node.mutability, in fold_receiver()
3248 self_token: node.self_token, in fold_receiver()
3249 colon_token: node.colon_token, in fold_receiver()
3250 ty: Box::new(f.fold_type(*node.ty)), in fold_receiver()
3255 pub fn fold_return_type<F>(f: &mut F, node: crate::ReturnType) -> crate::ReturnType in fold_return_type()
3259 match node { in fold_return_type()
3268 pub fn fold_signature<F>(f: &mut F, node: crate::Signature) -> crate::Signature in fold_signature()
3273 constness: node.constness, in fold_signature()
3274 asyncness: node.asyncness, in fold_signature()
3275 unsafety: node.unsafety, in fold_signature()
3276 abi: (node.abi).map(|it| f.fold_abi(it)), in fold_signature()
3277 fn_token: node.fn_token, in fold_signature()
3278 ident: f.fold_ident(node.ident), in fold_signature()
3279 generics: f.fold_generics(node.generics), in fold_signature()
3280 paren_token: node.paren_token, in fold_signature()
3281 inputs: crate::punctuated::fold(node.inputs, f, F::fold_fn_arg), in fold_signature()
3282 variadic: (node.variadic).map(|it| f.fold_variadic(it)), in fold_signature()
3283 output: f.fold_return_type(node.output), in fold_signature()
3286 pub fn fold_span<F>(f: &mut F, node: proc_macro2::Span) -> proc_macro2::Span in fold_span()
3290 node in fold_span()
3296 node: crate::StaticMutability, in fold_static_mutability()
3301 match node { in fold_static_mutability()
3310 pub fn fold_stmt<F>(f: &mut F, node: crate::Stmt) -> crate::Stmt in fold_stmt()
3314 match node { in fold_stmt()
3327 pub fn fold_stmt_macro<F>(f: &mut F, node: crate::StmtMacro) -> crate::StmtMacro in fold_stmt_macro()
3332 attrs: f.fold_attributes(node.attrs), in fold_stmt_macro()
3333 mac: f.fold_macro(node.mac), in fold_stmt_macro()
3334 semi_token: node.semi_token, in fold_stmt_macro()
3339 pub fn fold_trait_bound<F>(f: &mut F, node: crate::TraitBound) -> crate::TraitBound in fold_trait_bound()
3344 paren_token: node.paren_token, in fold_trait_bound()
3345 modifier: f.fold_trait_bound_modifier(node.modifier), in fold_trait_bound()
3346 lifetimes: (node.lifetimes).map(|it| f.fold_bound_lifetimes(it)), in fold_trait_bound()
3347 path: f.fold_path(node.path), in fold_trait_bound()
3354 node: crate::TraitBoundModifier, in fold_trait_bound_modifier()
3359 match node { in fold_trait_bound_modifier()
3368 pub fn fold_trait_item<F>(f: &mut F, node: crate::TraitItem) -> crate::TraitItem in fold_trait_item()
3372 match node { in fold_trait_item()
3394 node: crate::TraitItemConst, in fold_trait_item_const()
3400 attrs: f.fold_attributes(node.attrs), in fold_trait_item_const()
3401 const_token: node.const_token, in fold_trait_item_const()
3402 ident: f.fold_ident(node.ident), in fold_trait_item_const()
3403 generics: f.fold_generics(node.generics), in fold_trait_item_const()
3404 colon_token: node.colon_token, in fold_trait_item_const()
3405 ty: f.fold_type(node.ty), in fold_trait_item_const()
3406 default: (node.default).map(|it| ((it).0, f.fold_expr((it).1))), in fold_trait_item_const()
3407 semi_token: node.semi_token, in fold_trait_item_const()
3412 pub fn fold_trait_item_fn<F>(f: &mut F, node: crate::TraitItemFn) -> crate::TraitItemFn in fold_trait_item_fn()
3417 attrs: f.fold_attributes(node.attrs), in fold_trait_item_fn()
3418 sig: f.fold_signature(node.sig), in fold_trait_item_fn()
3419 default: (node.default).map(|it| f.fold_block(it)), in fold_trait_item_fn()
3420 semi_token: node.semi_token, in fold_trait_item_fn()
3427 node: crate::TraitItemMacro, in fold_trait_item_macro()
3433 attrs: f.fold_attributes(node.attrs), in fold_trait_item_macro()
3434 mac: f.fold_macro(node.mac), in fold_trait_item_macro()
3435 semi_token: node.semi_token, in fold_trait_item_macro()
3442 node: crate::TraitItemType, in fold_trait_item_type()
3448 attrs: f.fold_attributes(node.attrs), in fold_trait_item_type()
3449 type_token: node.type_token, in fold_trait_item_type()
3450 ident: f.fold_ident(node.ident), in fold_trait_item_type()
3451 generics: f.fold_generics(node.generics), in fold_trait_item_type()
3452 colon_token: node.colon_token, in fold_trait_item_type()
3453 bounds: crate::punctuated::fold(node.bounds, f, F::fold_type_param_bound), in fold_trait_item_type()
3454 default: (node.default).map(|it| ((it).0, f.fold_type((it).1))), in fold_trait_item_type()
3455 semi_token: node.semi_token, in fold_trait_item_type()
3460 pub fn fold_type<F>(f: &mut F, node: crate::Type) -> crate::Type in fold_type()
3464 match node { in fold_type()
3510 pub fn fold_type_array<F>(f: &mut F, node: crate::TypeArray) -> crate::TypeArray in fold_type_array()
3515 bracket_token: node.bracket_token, in fold_type_array()
3516 elem: Box::new(f.fold_type(*node.elem)), in fold_type_array()
3517 semi_token: node.semi_token, in fold_type_array()
3518 len: f.fold_expr(node.len), in fold_type_array()
3523 pub fn fold_type_bare_fn<F>(f: &mut F, node: crate::TypeBareFn) -> crate::TypeBareFn in fold_type_bare_fn()
3528 lifetimes: (node.lifetimes).map(|it| f.fold_bound_lifetimes(it)), in fold_type_bare_fn()
3529 unsafety: node.unsafety, in fold_type_bare_fn()
3530 abi: (node.abi).map(|it| f.fold_abi(it)), in fold_type_bare_fn()
3531 fn_token: node.fn_token, in fold_type_bare_fn()
3532 paren_token: node.paren_token, in fold_type_bare_fn()
3533 inputs: crate::punctuated::fold(node.inputs, f, F::fold_bare_fn_arg), in fold_type_bare_fn()
3534 variadic: (node.variadic).map(|it| f.fold_bare_variadic(it)), in fold_type_bare_fn()
3535 output: f.fold_return_type(node.output), in fold_type_bare_fn()
3540 pub fn fold_type_group<F>(f: &mut F, node: crate::TypeGroup) -> crate::TypeGroup in fold_type_group()
3545 group_token: node.group_token, in fold_type_group()
3546 elem: Box::new(f.fold_type(*node.elem)), in fold_type_group()
3553 node: crate::TypeImplTrait, in fold_type_impl_trait()
3559 impl_token: node.impl_token, in fold_type_impl_trait()
3560 bounds: crate::punctuated::fold(node.bounds, f, F::fold_type_param_bound), in fold_type_impl_trait()
3565 pub fn fold_type_infer<F>(f: &mut F, node: crate::TypeInfer) -> crate::TypeInfer in fold_type_infer()
3570 underscore_token: node.underscore_token, in fold_type_infer()
3575 pub fn fold_type_macro<F>(f: &mut F, node: crate::TypeMacro) -> crate::TypeMacro in fold_type_macro()
3580 mac: f.fold_macro(node.mac), in fold_type_macro()
3585 pub fn fold_type_never<F>(f: &mut F, node: crate::TypeNever) -> crate::TypeNever in fold_type_never()
3590 bang_token: node.bang_token, in fold_type_never()
3595 pub fn fold_type_param<F>(f: &mut F, node: crate::TypeParam) -> crate::TypeParam in fold_type_param()
3600 attrs: f.fold_attributes(node.attrs), in fold_type_param()
3601 ident: f.fold_ident(node.ident), in fold_type_param()
3602 colon_token: node.colon_token, in fold_type_param()
3603 bounds: crate::punctuated::fold(node.bounds, f, F::fold_type_param_bound), in fold_type_param()
3604 eq_token: node.eq_token, in fold_type_param()
3605 default: (node.default).map(|it| f.fold_type(it)), in fold_type_param()
3612 node: crate::TypeParamBound, in fold_type_param_bound()
3617 match node { in fold_type_param_bound()
3636 pub fn fold_type_paren<F>(f: &mut F, node: crate::TypeParen) -> crate::TypeParen in fold_type_paren()
3641 paren_token: node.paren_token, in fold_type_paren()
3642 elem: Box::new(f.fold_type(*node.elem)), in fold_type_paren()
3647 pub fn fold_type_path<F>(f: &mut F, node: crate::TypePath) -> crate::TypePath in fold_type_path()
3652 qself: (node.qself).map(|it| f.fold_qself(it)), in fold_type_path()
3653 path: f.fold_path(node.path), in fold_type_path()
3658 pub fn fold_type_ptr<F>(f: &mut F, node: crate::TypePtr) -> crate::TypePtr in fold_type_ptr()
3663 star_token: node.star_token, in fold_type_ptr()
3664 const_token: node.const_token, in fold_type_ptr()
3665 mutability: node.mutability, in fold_type_ptr()
3666 elem: Box::new(f.fold_type(*node.elem)), in fold_type_ptr()
3673 node: crate::TypeReference, in fold_type_reference()
3679 and_token: node.and_token, in fold_type_reference()
3680 lifetime: (node.lifetime).map(|it| f.fold_lifetime(it)), in fold_type_reference()
3681 mutability: node.mutability, in fold_type_reference()
3682 elem: Box::new(f.fold_type(*node.elem)), in fold_type_reference()
3687 pub fn fold_type_slice<F>(f: &mut F, node: crate::TypeSlice) -> crate::TypeSlice in fold_type_slice()
3692 bracket_token: node.bracket_token, in fold_type_slice()
3693 elem: Box::new(f.fold_type(*node.elem)), in fold_type_slice()
3700 node: crate::TypeTraitObject, in fold_type_trait_object()
3706 dyn_token: node.dyn_token, in fold_type_trait_object()
3707 bounds: crate::punctuated::fold(node.bounds, f, F::fold_type_param_bound), in fold_type_trait_object()
3712 pub fn fold_type_tuple<F>(f: &mut F, node: crate::TypeTuple) -> crate::TypeTuple in fold_type_tuple()
3717 paren_token: node.paren_token, in fold_type_tuple()
3718 elems: crate::punctuated::fold(node.elems, f, F::fold_type), in fold_type_tuple()
3723 pub fn fold_un_op<F>(f: &mut F, node: crate::UnOp) -> crate::UnOp in fold_un_op()
3727 match node { in fold_un_op()
3735 pub fn fold_use_glob<F>(f: &mut F, node: crate::UseGlob) -> crate::UseGlob in fold_use_glob()
3740 star_token: node.star_token, in fold_use_glob()
3745 pub fn fold_use_group<F>(f: &mut F, node: crate::UseGroup) -> crate::UseGroup in fold_use_group()
3750 brace_token: node.brace_token, in fold_use_group()
3751 items: crate::punctuated::fold(node.items, f, F::fold_use_tree), in fold_use_group()
3756 pub fn fold_use_name<F>(f: &mut F, node: crate::UseName) -> crate::UseName in fold_use_name()
3761 ident: f.fold_ident(node.ident), in fold_use_name()
3766 pub fn fold_use_path<F>(f: &mut F, node: crate::UsePath) -> crate::UsePath in fold_use_path()
3771 ident: f.fold_ident(node.ident), in fold_use_path()
3772 colon2_token: node.colon2_token, in fold_use_path()
3773 tree: Box::new(f.fold_use_tree(*node.tree)), in fold_use_path()
3778 pub fn fold_use_rename<F>(f: &mut F, node: crate::UseRename) -> crate::UseRename in fold_use_rename()
3783 ident: f.fold_ident(node.ident), in fold_use_rename()
3784 as_token: node.as_token, in fold_use_rename()
3785 rename: f.fold_ident(node.rename), in fold_use_rename()
3790 pub fn fold_use_tree<F>(f: &mut F, node: crate::UseTree) -> crate::UseTree in fold_use_tree()
3794 match node { in fold_use_tree()
3814 pub fn fold_variadic<F>(f: &mut F, node: crate::Variadic) -> crate::Variadic in fold_variadic()
3819 attrs: f.fold_attributes(node.attrs), in fold_variadic()
3820 pat: (node.pat).map(|it| (Box::new(f.fold_pat(*(it).0)), (it).1)), in fold_variadic()
3821 dots: node.dots, in fold_variadic()
3822 comma: node.comma, in fold_variadic()
3827 pub fn fold_variant<F>(f: &mut F, node: crate::Variant) -> crate::Variant in fold_variant()
3832 attrs: f.fold_attributes(node.attrs), in fold_variant()
3833 ident: f.fold_ident(node.ident), in fold_variant()
3834 fields: f.fold_fields(node.fields), in fold_variant()
3835 discriminant: (node.discriminant).map(|it| ((it).0, f.fold_expr((it).1))), in fold_variant()
3842 node: crate::VisRestricted, in fold_vis_restricted()
3848 pub_token: node.pub_token, in fold_vis_restricted()
3849 paren_token: node.paren_token, in fold_vis_restricted()
3850 in_token: node.in_token, in fold_vis_restricted()
3851 path: Box::new(f.fold_path(*node.path)), in fold_vis_restricted()
3856 pub fn fold_visibility<F>(f: &mut F, node: crate::Visibility) -> crate::Visibility in fold_visibility()
3860 match node { in fold_visibility()
3870 pub fn fold_where_clause<F>(f: &mut F, node: crate::WhereClause) -> crate::WhereClause in fold_where_clause()
3875 where_token: node.where_token, in fold_where_clause()
3876 predicates: crate::punctuated::fold(node.predicates, f, F::fold_where_predicate), in fold_where_clause()
3883 node: crate::WherePredicate, in fold_where_predicate()
3888 match node { in fold_where_predicate()