Lines Matching refs:f
1030 pub fn fold_abi<F>(f: &mut F, node: crate::Abi) -> crate::Abi in fold_abi()
1036 name: (node.name).map(|it| f.fold_lit_str(it)), in fold_abi()
1042 f: &mut F, in fold_angle_bracketed_generic_arguments()
1051 args: crate::punctuated::fold(node.args, f, F::fold_generic_argument), 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()
1066 body: Box::new(f.fold_expr(*node.body)), 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()
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()
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()
1109 pub fn fold_attribute<F>(f: &mut F, node: crate::Attribute) -> crate::Attribute in fold_attribute()
1115 style: f.fold_attr_style(node.style), 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()
1147 pub fn fold_bin_op<F>(f: &mut F, node: crate::BinOp) -> crate::BinOp in fold_bin_op()
1184 pub fn fold_block<F>(f: &mut F, node: crate::Block) -> crate::Block in fold_block()
1190 stmts: fold_vec(node.stmts, f, F::fold_stmt), in fold_block()
1196 f: &mut F, in fold_bound_lifetimes()
1205 lifetimes: crate::punctuated::fold(node.lifetimes, f, F::fold_generic_param), in fold_bound_lifetimes()
1212 f: &mut F, in fold_captured_param()
1220 crate::CapturedParam::Lifetime(f.fold_lifetime(_binding_0)) in fold_captured_param()
1223 crate::CapturedParam::Ident(f.fold_ident(_binding_0)) 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()
1236 ident: f.fold_ident(node.ident), in fold_const_param()
1238 ty: f.fold_type(node.ty), 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()
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()
1264 crate::Data::Struct(f.fold_data_struct(_binding_0)) in fold_data()
1266 crate::Data::Enum(_binding_0) => crate::Data::Enum(f.fold_data_enum(_binding_0)), in fold_data()
1268 crate::Data::Union(f.fold_data_union(_binding_0)) in fold_data()
1274 pub fn fold_data_enum<F>(f: &mut F, node: crate::DataEnum) -> crate::DataEnum 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()
1292 fields: f.fold_fields(node.fields), in fold_data_struct()
1298 pub fn fold_data_union<F>(f: &mut F, node: crate::DataUnion) -> crate::DataUnion 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()
1329 crate::Expr::Array(full!(f.fold_expr_array(_binding_0))) in fold_expr()
1332 crate::Expr::Assign(full!(f.fold_expr_assign(_binding_0))) in fold_expr()
1335 crate::Expr::Async(full!(f.fold_expr_async(_binding_0))) in fold_expr()
1338 crate::Expr::Await(full!(f.fold_expr_await(_binding_0))) in fold_expr()
1341 crate::Expr::Binary(f.fold_expr_binary(_binding_0)) in fold_expr()
1344 crate::Expr::Block(full!(f.fold_expr_block(_binding_0))) in fold_expr()
1347 crate::Expr::Break(full!(f.fold_expr_break(_binding_0))) in fold_expr()
1349 crate::Expr::Call(_binding_0) => crate::Expr::Call(f.fold_expr_call(_binding_0)), in fold_expr()
1350 crate::Expr::Cast(_binding_0) => crate::Expr::Cast(f.fold_expr_cast(_binding_0)), in fold_expr()
1352 crate::Expr::Closure(full!(f.fold_expr_closure(_binding_0))) in fold_expr()
1355 crate::Expr::Const(full!(f.fold_expr_const(_binding_0))) in fold_expr()
1358 crate::Expr::Continue(full!(f.fold_expr_continue(_binding_0))) in fold_expr()
1361 crate::Expr::Field(f.fold_expr_field(_binding_0)) in fold_expr()
1364 crate::Expr::ForLoop(full!(f.fold_expr_for_loop(_binding_0))) in fold_expr()
1367 crate::Expr::Group(f.fold_expr_group(_binding_0)) in fold_expr()
1369 crate::Expr::If(_binding_0) => crate::Expr::If(full!(f.fold_expr_if(_binding_0))), in fold_expr()
1371 crate::Expr::Index(f.fold_expr_index(_binding_0)) in fold_expr()
1374 crate::Expr::Infer(full!(f.fold_expr_infer(_binding_0))) in fold_expr()
1377 crate::Expr::Let(full!(f.fold_expr_let(_binding_0))) in fold_expr()
1379 crate::Expr::Lit(_binding_0) => crate::Expr::Lit(f.fold_expr_lit(_binding_0)), in fold_expr()
1381 crate::Expr::Loop(full!(f.fold_expr_loop(_binding_0))) in fold_expr()
1384 crate::Expr::Macro(f.fold_expr_macro(_binding_0)) in fold_expr()
1387 crate::Expr::Match(full!(f.fold_expr_match(_binding_0))) in fold_expr()
1390 crate::Expr::MethodCall(f.fold_expr_method_call(_binding_0)) in fold_expr()
1393 crate::Expr::Paren(f.fold_expr_paren(_binding_0)) in fold_expr()
1395 crate::Expr::Path(_binding_0) => crate::Expr::Path(f.fold_expr_path(_binding_0)), in fold_expr()
1397 crate::Expr::Range(full!(f.fold_expr_range(_binding_0))) in fold_expr()
1400 crate::Expr::RawAddr(full!(f.fold_expr_raw_addr(_binding_0))) in fold_expr()
1403 crate::Expr::Reference(f.fold_expr_reference(_binding_0)) in fold_expr()
1406 crate::Expr::Repeat(full!(f.fold_expr_repeat(_binding_0))) in fold_expr()
1409 crate::Expr::Return(full!(f.fold_expr_return(_binding_0))) in fold_expr()
1412 crate::Expr::Struct(f.fold_expr_struct(_binding_0)) in fold_expr()
1415 crate::Expr::Try(full!(f.fold_expr_try(_binding_0))) in fold_expr()
1418 crate::Expr::TryBlock(full!(f.fold_expr_try_block(_binding_0))) in fold_expr()
1421 crate::Expr::Tuple(f.fold_expr_tuple(_binding_0)) in fold_expr()
1424 crate::Expr::Unary(f.fold_expr_unary(_binding_0)) in fold_expr()
1427 crate::Expr::Unsafe(full!(f.fold_expr_unsafe(_binding_0))) in fold_expr()
1430 crate::Expr::Verbatim(f.fold_token_stream(_binding_0)) in fold_expr()
1433 crate::Expr::While(full!(f.fold_expr_while(_binding_0))) in fold_expr()
1436 crate::Expr::Yield(full!(f.fold_expr_yield(_binding_0))) 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()
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()
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()
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()
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()
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()
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()
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()
1569 inputs: crate::punctuated::fold(node.inputs, f, F::fold_pat), 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()
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()
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()
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()
1622 pat: Box::new(f.fold_pat(*node.pat)), 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()
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()
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()
1652 .map(|it| ((it).0, Box::new(f.fold_expr(*(it).1)))), 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()
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()
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()
1688 pat: Box::new(f.fold_pat(*node.pat)), 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()
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()
1737 expr: Box::new(f.fold_expr(*node.expr)), in fold_expr_match()
1739 arms: fold_vec(node.arms, f, F::fold_arm), in fold_expr_match()
1745 f: &mut F, 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()
1755 method: f.fold_ident(node.method), in fold_expr_method_call()
1757 .map(|it| f.fold_angle_bracketed_generic_arguments(it)), 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()
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()
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()
1816 f: &mut F, in fold_expr_reference()
1823 attrs: f.fold_attributes(node.attrs), 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()
1838 expr: Box::new(f.fold_expr(*node.expr)), 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()
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()
1866 fields: crate::punctuated::fold(node.fields, f, F::fold_field_value), 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()
1886 f: &mut F, in fold_expr_try_block()
1893 attrs: f.fold_attributes(node.attrs), 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()
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()
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()
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()
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()
1972 ty: f.fold_type(node.ty), in fold_field()
1978 f: &mut F, 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()
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()
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()
2022 crate::Fields::Named(f.fold_fields_named(_binding_0)) in fold_fields()
2025 crate::Fields::Unnamed(f.fold_fields_unnamed(_binding_0)) in fold_fields()
2032 pub fn fold_fields_named<F>(f: &mut F, node: crate::FieldsNamed) -> crate::FieldsNamed in fold_fields_named()
2038 named: crate::punctuated::fold(node.named, f, F::fold_field), in fold_fields_named()
2044 f: &mut F, 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()
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()
2075 crate::FnArg::Receiver(f.fold_receiver(_binding_0)) in fold_fn_arg()
2078 crate::FnArg::Typed(f.fold_pat_type(_binding_0)) in fold_fn_arg()
2084 pub fn fold_foreign_item<F>(f: &mut F, node: crate::ForeignItem) -> crate::ForeignItem in fold_foreign_item()
2090 crate::ForeignItem::Fn(f.fold_foreign_item_fn(_binding_0)) in fold_foreign_item()
2093 crate::ForeignItem::Static(f.fold_foreign_item_static(_binding_0)) in fold_foreign_item()
2096 crate::ForeignItem::Type(f.fold_foreign_item_type(_binding_0)) in fold_foreign_item()
2099 crate::ForeignItem::Macro(f.fold_foreign_item_macro(_binding_0)) in fold_foreign_item()
2102 crate::ForeignItem::Verbatim(f.fold_token_stream(_binding_0)) in fold_foreign_item()
2109 f: &mut F, 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()
2125 f: &mut F, 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()
2140 f: &mut F, 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()
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()
2153 ty: Box::new(f.fold_type(*node.ty)), in fold_foreign_item_static()
2160 f: &mut F, 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()
2170 ident: f.fold_ident(node.ident), in fold_foreign_item_type()
2171 generics: f.fold_generics(node.generics), in fold_foreign_item_type()
2178 f: &mut F, in fold_generic_argument()
2186 crate::GenericArgument::Lifetime(f.fold_lifetime(_binding_0)) in fold_generic_argument()
2189 crate::GenericArgument::Type(f.fold_type(_binding_0)) in fold_generic_argument()
2192 crate::GenericArgument::Const(f.fold_expr(_binding_0)) in fold_generic_argument()
2195 crate::GenericArgument::AssocType(f.fold_assoc_type(_binding_0)) in fold_generic_argument()
2198 crate::GenericArgument::AssocConst(f.fold_assoc_const(_binding_0)) in fold_generic_argument()
2201 crate::GenericArgument::Constraint(f.fold_constraint(_binding_0)) in fold_generic_argument()
2207 pub fn fold_generic_param<F>(f: &mut F, node: crate::GenericParam) -> crate::GenericParam in fold_generic_param()
2213 crate::GenericParam::Lifetime(f.fold_lifetime_param(_binding_0)) in fold_generic_param()
2216 crate::GenericParam::Type(f.fold_type_param(_binding_0)) in fold_generic_param()
2219 crate::GenericParam::Const(f.fold_const_param(_binding_0)) in fold_generic_param()
2225 pub fn fold_generics<F>(f: &mut F, node: crate::Generics) -> crate::Generics in fold_generics()
2231 params: crate::punctuated::fold(node.params, f, F::fold_generic_param), 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()
2241 let span = f.fold_span(node.span()); in fold_ident()
2247 pub fn fold_impl_item<F>(f: &mut F, node: crate::ImplItem) -> crate::ImplItem in fold_impl_item()
2253 crate::ImplItem::Const(f.fold_impl_item_const(_binding_0)) in fold_impl_item()
2256 crate::ImplItem::Fn(f.fold_impl_item_fn(_binding_0)) in fold_impl_item()
2259 crate::ImplItem::Type(f.fold_impl_item_type(_binding_0)) in fold_impl_item()
2262 crate::ImplItem::Macro(f.fold_impl_item_macro(_binding_0)) in fold_impl_item()
2265 crate::ImplItem::Verbatim(f.fold_token_stream(_binding_0)) in fold_impl_item()
2272 f: &mut F, 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()
2283 ident: f.fold_ident(node.ident), in fold_impl_item_const()
2284 generics: f.fold_generics(node.generics), in fold_impl_item_const()
2286 ty: f.fold_type(node.ty), in fold_impl_item_const()
2288 expr: f.fold_expr(node.expr), 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()
2302 sig: f.fold_signature(node.sig), in fold_impl_item_fn()
2303 block: f.fold_block(node.block), in fold_impl_item_fn()
2309 f: &mut F, 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()
2324 f: &mut F, 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()
2335 ident: f.fold_ident(node.ident), in fold_impl_item_type()
2336 generics: f.fold_generics(node.generics), in fold_impl_item_type()
2338 ty: f.fold_type(node.ty), in fold_impl_item_type()
2345 f: &mut F, in fold_impl_restriction()
2355 pub fn fold_index<F>(f: &mut F, node: crate::Index) -> crate::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()
2372 crate::Item::Const(f.fold_item_const(_binding_0)) in fold_item()
2374 crate::Item::Enum(_binding_0) => crate::Item::Enum(f.fold_item_enum(_binding_0)), in fold_item()
2376 crate::Item::ExternCrate(f.fold_item_extern_crate(_binding_0)) in fold_item()
2378 crate::Item::Fn(_binding_0) => crate::Item::Fn(f.fold_item_fn(_binding_0)), in fold_item()
2380 crate::Item::ForeignMod(f.fold_item_foreign_mod(_binding_0)) in fold_item()
2382 crate::Item::Impl(_binding_0) => crate::Item::Impl(f.fold_item_impl(_binding_0)), in fold_item()
2384 crate::Item::Macro(f.fold_item_macro(_binding_0)) in fold_item()
2386 crate::Item::Mod(_binding_0) => crate::Item::Mod(f.fold_item_mod(_binding_0)), in fold_item()
2388 crate::Item::Static(f.fold_item_static(_binding_0)) in fold_item()
2391 crate::Item::Struct(f.fold_item_struct(_binding_0)) in fold_item()
2394 crate::Item::Trait(f.fold_item_trait(_binding_0)) in fold_item()
2397 crate::Item::TraitAlias(f.fold_item_trait_alias(_binding_0)) in fold_item()
2399 crate::Item::Type(_binding_0) => crate::Item::Type(f.fold_item_type(_binding_0)), in fold_item()
2401 crate::Item::Union(f.fold_item_union(_binding_0)) in fold_item()
2403 crate::Item::Use(_binding_0) => crate::Item::Use(f.fold_item_use(_binding_0)), in fold_item()
2405 crate::Item::Verbatim(f.fold_token_stream(_binding_0)) 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()
2419 ident: f.fold_ident(node.ident), in fold_item_const()
2420 generics: f.fold_generics(node.generics), in fold_item_const()
2422 ty: Box::new(f.fold_type(*node.ty)), in fold_item_const()
2424 expr: Box::new(f.fold_expr(*node.expr)), 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()
2438 ident: f.fold_ident(node.ident), in fold_item_enum()
2439 generics: f.fold_generics(node.generics), in fold_item_enum()
2441 variants: crate::punctuated::fold(node.variants, f, F::fold_variant), in fold_item_enum()
2447 f: &mut F, 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()
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()
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()
2479 f: &mut F, in fold_item_foreign_mod()
2486 attrs: f.fold_attributes(node.attrs), in fold_item_foreign_mod()
2488 abi: f.fold_abi(node.abi), 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()
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()
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()
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()
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()
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()
2550 mutability: f.fold_static_mutability(node.mutability), in fold_item_static()
2551 ident: f.fold_ident(node.ident), in fold_item_static()
2553 ty: Box::new(f.fold_type(*node.ty)), in fold_item_static()
2555 expr: Box::new(f.fold_expr(*node.expr)), 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()
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()
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()
2586 restriction: (node.restriction).map(|it| f.fold_impl_restriction(it)), 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()
2593 f, in fold_item_trait()
2597 items: fold_vec(node.items, f, F::fold_trait_item), in fold_item_trait()
2603 f: &mut F, 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()
2613 ident: f.fold_ident(node.ident), in fold_item_trait_alias()
2614 generics: f.fold_generics(node.generics), in fold_item_trait_alias()
2616 bounds: crate::punctuated::fold(node.bounds, f, F::fold_type_param_bound), 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()
2630 ident: f.fold_ident(node.ident), in fold_item_type()
2631 generics: f.fold_generics(node.generics), in fold_item_type()
2633 ty: Box::new(f.fold_type(*node.ty)), 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()
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()
2663 tree: f.fold_use_tree(node.tree), 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()
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()
2690 f: &mut F, 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()
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()
2708 crate::Lit::Str(_binding_0) => crate::Lit::Str(f.fold_lit_str(_binding_0)), in fold_lit()
2710 crate::Lit::ByteStr(f.fold_lit_byte_str(_binding_0)) in fold_lit()
2712 crate::Lit::CStr(_binding_0) => crate::Lit::CStr(f.fold_lit_cstr(_binding_0)), in fold_lit()
2713 crate::Lit::Byte(_binding_0) => crate::Lit::Byte(f.fold_lit_byte(_binding_0)), in fold_lit()
2714 crate::Lit::Char(_binding_0) => crate::Lit::Char(f.fold_lit_char(_binding_0)), in fold_lit()
2715 crate::Lit::Int(_binding_0) => crate::Lit::Int(f.fold_lit_int(_binding_0)), in fold_lit()
2716 crate::Lit::Float(_binding_0) => crate::Lit::Float(f.fold_lit_float(_binding_0)), in fold_lit()
2717 crate::Lit::Bool(_binding_0) => crate::Lit::Bool(f.fold_lit_bool(_binding_0)), in fold_lit()
2721 pub fn fold_lit_bool<F>(f: &mut F, node: crate::LitBool) -> crate::LitBool 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()
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()
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()
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()
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()
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()
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()
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()
2802 pat: f.fold_pat(node.pat), in fold_local()
2803 init: (node.init).map(|it| f.fold_local_init(it)), in fold_local()
2809 pub fn fold_local_init<F>(f: &mut F, node: crate::LocalInit) -> crate::LocalInit 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()
2828 delimiter: f.fold_macro_delimiter(node.delimiter), in fold_macro()
2829 tokens: f.fold_token_stream(node.tokens), in fold_macro()
2835 f: &mut F, in fold_macro_delimiter()
2855 pub fn fold_member<F>(f: &mut F, node: crate::Member) -> crate::Member in fold_member()
2861 crate::Member::Named(f.fold_ident(_binding_0)) in fold_member()
2864 crate::Member::Unnamed(f.fold_index(_binding_0)) in fold_member()
2870 pub fn fold_meta<F>(f: &mut F, node: crate::Meta) -> crate::Meta in fold_meta()
2875 crate::Meta::Path(_binding_0) => crate::Meta::Path(f.fold_path(_binding_0)), in fold_meta()
2876 crate::Meta::List(_binding_0) => crate::Meta::List(f.fold_meta_list(_binding_0)), in fold_meta()
2878 crate::Meta::NameValue(f.fold_meta_name_value(_binding_0)) 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()
2897 f: &mut F, in fold_meta_name_value()
2904 path: f.fold_path(node.path), in fold_meta_name_value()
2906 value: f.fold_expr(node.value), in fold_meta_name_value()
2912 f: &mut F, 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()
2931 crate::Pat::Const(_binding_0) => crate::Pat::Const(f.fold_expr_const(_binding_0)), in fold_pat()
2932 crate::Pat::Ident(_binding_0) => crate::Pat::Ident(f.fold_pat_ident(_binding_0)), in fold_pat()
2933 crate::Pat::Lit(_binding_0) => crate::Pat::Lit(f.fold_expr_lit(_binding_0)), in fold_pat()
2934 crate::Pat::Macro(_binding_0) => crate::Pat::Macro(f.fold_expr_macro(_binding_0)), in fold_pat()
2935 crate::Pat::Or(_binding_0) => crate::Pat::Or(f.fold_pat_or(_binding_0)), in fold_pat()
2936 crate::Pat::Paren(_binding_0) => crate::Pat::Paren(f.fold_pat_paren(_binding_0)), in fold_pat()
2937 crate::Pat::Path(_binding_0) => crate::Pat::Path(f.fold_expr_path(_binding_0)), in fold_pat()
2938 crate::Pat::Range(_binding_0) => crate::Pat::Range(f.fold_expr_range(_binding_0)), in fold_pat()
2940 crate::Pat::Reference(f.fold_pat_reference(_binding_0)) in fold_pat()
2942 crate::Pat::Rest(_binding_0) => crate::Pat::Rest(f.fold_pat_rest(_binding_0)), in fold_pat()
2943 crate::Pat::Slice(_binding_0) => crate::Pat::Slice(f.fold_pat_slice(_binding_0)), in fold_pat()
2945 crate::Pat::Struct(f.fold_pat_struct(_binding_0)) in fold_pat()
2947 crate::Pat::Tuple(_binding_0) => crate::Pat::Tuple(f.fold_pat_tuple(_binding_0)), in fold_pat()
2949 crate::Pat::TupleStruct(f.fold_pat_tuple_struct(_binding_0)) in fold_pat()
2951 crate::Pat::Type(_binding_0) => crate::Pat::Type(f.fold_pat_type(_binding_0)), in fold_pat()
2953 crate::Pat::Verbatim(f.fold_token_stream(_binding_0)) in fold_pat()
2955 crate::Pat::Wild(_binding_0) => crate::Pat::Wild(f.fold_pat_wild(_binding_0)), 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()
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()
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()
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()
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()
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()
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()
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()
3056 elems: crate::punctuated::fold(node.elems, f, F::fold_pat), in fold_pat_tuple()
3062 f: &mut F, 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()
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()
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()
3102 pub fn fold_path<F>(f: &mut F, node: crate::Path) -> crate::Path in fold_path()
3108 segments: crate::punctuated::fold(node.segments, f, F::fold_path_segment), in fold_path()
3114 f: &mut F, in fold_path_arguments()
3124 f.fold_angle_bracketed_generic_arguments(_binding_0), in fold_path_arguments()
3129 f.fold_parenthesized_generic_arguments(_binding_0), 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()
3148 f: &mut F, in fold_pointer_mutability()
3166 f: &mut F, in fold_precise_capture()
3175 params: crate::punctuated::fold(node.params, f, F::fold_captured_param), in fold_precise_capture()
3182 f: &mut F, in fold_predicate_lifetime()
3189 lifetime: f.fold_lifetime(node.lifetime), in fold_predicate_lifetime()
3191 bounds: crate::punctuated::fold(node.bounds, f, F::fold_lifetime), in fold_predicate_lifetime()
3197 f: &mut F, 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()
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()
3218 ty: Box::new(f.fold_type(*node.ty)), in fold_qself()
3226 pub fn fold_range_limits<F>(f: &mut F, node: crate::RangeLimits) -> crate::RangeLimits 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()
3246 .map(|it| ((it).0, ((it).1).map(|it| f.fold_lifetime(it)))), 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()
3262 crate::ReturnType::Type(_binding_0, Box::new(f.fold_type(*_binding_1))) in fold_return_type()
3268 pub fn fold_signature<F>(f: &mut F, node: crate::Signature) -> crate::Signature in fold_signature()
3276 abi: (node.abi).map(|it| f.fold_abi(it)), in fold_signature()
3278 ident: f.fold_ident(node.ident), in fold_signature()
3279 generics: f.fold_generics(node.generics), 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()
3295 f: &mut F, in fold_static_mutability()
3310 pub fn fold_stmt<F>(f: &mut F, node: crate::Stmt) -> crate::Stmt in fold_stmt()
3315 crate::Stmt::Local(_binding_0) => crate::Stmt::Local(f.fold_local(_binding_0)), in fold_stmt()
3316 crate::Stmt::Item(_binding_0) => crate::Stmt::Item(f.fold_item(_binding_0)), in fold_stmt()
3318 crate::Stmt::Expr(f.fold_expr(_binding_0), _binding_1) in fold_stmt()
3321 crate::Stmt::Macro(f.fold_stmt_macro(_binding_0)) 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()
3339 pub fn fold_trait_bound<F>(f: &mut F, node: crate::TraitBound) -> crate::TraitBound 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()
3353 f: &mut F, in fold_trait_bound_modifier()
3368 pub fn fold_trait_item<F>(f: &mut F, node: crate::TraitItem) -> crate::TraitItem in fold_trait_item()
3374 crate::TraitItem::Const(f.fold_trait_item_const(_binding_0)) in fold_trait_item()
3377 crate::TraitItem::Fn(f.fold_trait_item_fn(_binding_0)) in fold_trait_item()
3380 crate::TraitItem::Type(f.fold_trait_item_type(_binding_0)) in fold_trait_item()
3383 crate::TraitItem::Macro(f.fold_trait_item_macro(_binding_0)) in fold_trait_item()
3386 crate::TraitItem::Verbatim(f.fold_token_stream(_binding_0)) in fold_trait_item()
3393 f: &mut F, in fold_trait_item_const()
3400 attrs: f.fold_attributes(node.attrs), 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()
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()
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()
3426 f: &mut F, 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()
3441 f: &mut F, in fold_trait_item_type()
3448 attrs: f.fold_attributes(node.attrs), 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()
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()
3460 pub fn fold_type<F>(f: &mut F, node: crate::Type) -> crate::Type in fold_type()
3466 crate::Type::Array(f.fold_type_array(_binding_0)) in fold_type()
3469 crate::Type::BareFn(f.fold_type_bare_fn(_binding_0)) in fold_type()
3472 crate::Type::Group(f.fold_type_group(_binding_0)) in fold_type()
3475 crate::Type::ImplTrait(f.fold_type_impl_trait(_binding_0)) in fold_type()
3478 crate::Type::Infer(f.fold_type_infer(_binding_0)) in fold_type()
3481 crate::Type::Macro(f.fold_type_macro(_binding_0)) in fold_type()
3484 crate::Type::Never(f.fold_type_never(_binding_0)) in fold_type()
3487 crate::Type::Paren(f.fold_type_paren(_binding_0)) in fold_type()
3489 crate::Type::Path(_binding_0) => crate::Type::Path(f.fold_type_path(_binding_0)), in fold_type()
3490 crate::Type::Ptr(_binding_0) => crate::Type::Ptr(f.fold_type_ptr(_binding_0)), in fold_type()
3492 crate::Type::Reference(f.fold_type_reference(_binding_0)) in fold_type()
3495 crate::Type::Slice(f.fold_type_slice(_binding_0)) in fold_type()
3498 crate::Type::TraitObject(f.fold_type_trait_object(_binding_0)) in fold_type()
3501 crate::Type::Tuple(f.fold_type_tuple(_binding_0)) in fold_type()
3504 crate::Type::Verbatim(f.fold_token_stream(_binding_0)) in fold_type()
3510 pub fn fold_type_array<F>(f: &mut F, node: crate::TypeArray) -> crate::TypeArray in fold_type_array()
3516 elem: Box::new(f.fold_type(*node.elem)), 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()
3530 abi: (node.abi).map(|it| f.fold_abi(it)), 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()
3546 elem: Box::new(f.fold_type(*node.elem)), in fold_type_group()
3552 f: &mut F, 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()
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()
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()
3603 bounds: crate::punctuated::fold(node.bounds, f, F::fold_type_param_bound), in fold_type_param()
3605 default: (node.default).map(|it| f.fold_type(it)), in fold_type_param()
3611 f: &mut F, in fold_type_param_bound()
3619 crate::TypeParamBound::Trait(f.fold_trait_bound(_binding_0)) in fold_type_param_bound()
3622 crate::TypeParamBound::Lifetime(f.fold_lifetime(_binding_0)) in fold_type_param_bound()
3626 full!(f.fold_precise_capture(_binding_0)), in fold_type_param_bound()
3630 crate::TypeParamBound::Verbatim(f.fold_token_stream(_binding_0)) in fold_type_param_bound()
3636 pub fn fold_type_paren<F>(f: &mut F, node: crate::TypeParen) -> crate::TypeParen 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()
3666 elem: Box::new(f.fold_type(*node.elem)), in fold_type_ptr()
3672 f: &mut F, in fold_type_reference()
3680 lifetime: (node.lifetime).map(|it| f.fold_lifetime(it)), 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()
3693 elem: Box::new(f.fold_type(*node.elem)), in fold_type_slice()
3699 f: &mut F, 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()
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()
3735 pub fn fold_use_glob<F>(f: &mut F, node: crate::UseGlob) -> crate::UseGlob in fold_use_glob()
3745 pub fn fold_use_group<F>(f: &mut F, node: crate::UseGroup) -> crate::UseGroup 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()
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()
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()
3796 crate::UseTree::Path(f.fold_use_path(_binding_0)) in fold_use_tree()
3799 crate::UseTree::Name(f.fold_use_name(_binding_0)) in fold_use_tree()
3802 crate::UseTree::Rename(f.fold_use_rename(_binding_0)) in fold_use_tree()
3805 crate::UseTree::Glob(f.fold_use_glob(_binding_0)) in fold_use_tree()
3808 crate::UseTree::Group(f.fold_use_group(_binding_0)) 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()
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()
3841 f: &mut F, 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()
3863 crate::Visibility::Restricted(f.fold_vis_restricted(_binding_0)) in fold_visibility()
3870 pub fn fold_where_clause<F>(f: &mut F, node: crate::WhereClause) -> crate::WhereClause in fold_where_clause()
3876 predicates: crate::punctuated::fold(node.predicates, f, F::fold_where_predicate), in fold_where_clause()
3882 f: &mut F, in fold_where_predicate()
3890 crate::WherePredicate::Lifetime(f.fold_predicate_lifetime(_binding_0)) in fold_where_predicate()
3893 crate::WherePredicate::Type(f.fold_predicate_type(_binding_0)) in fold_where_predicate()
3898 fn fold_vec<T, V, F>(vec: Vec<T>, fold: &mut V, mut f: F) -> Vec<T> in fold_vec()
3903 vec.into_iter().map(|it| f(fold, it)).collect() in fold_vec()