1// This file is @generated by syn-internal-codegen. 2// It is not intended for manual editing. 3 4#![allow(unused_variables)] 5#![allow(clippy::needless_pass_by_ref_mut)] 6#[cfg(any(feature = "full", feature = "derive"))] 7use crate::punctuated::Punctuated; 8use crate::*; 9use proc_macro2::Span; 10#[cfg(feature = "full")] 11macro_rules! full { 12 ($e:expr) => { 13 $e 14 }; 15} 16#[cfg(all(feature = "derive", not(feature = "full")))] 17macro_rules! full { 18 ($e:expr) => { 19 unreachable!() 20 }; 21} 22macro_rules! skip { 23 ($($tt:tt)*) => {}; 24} 25/// Syntax tree traversal to mutate an exclusive borrow of a syntax tree in 26/// place. 27/// 28/// See the [module documentation] for details. 29/// 30/// [module documentation]: self 31pub trait VisitMut { 32 #[cfg(any(feature = "derive", feature = "full"))] 33 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 34 fn visit_abi_mut(&mut self, i: &mut Abi) { 35 visit_abi_mut(self, i); 36 } 37 #[cfg(any(feature = "derive", feature = "full"))] 38 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 39 fn visit_angle_bracketed_generic_arguments_mut( 40 &mut self, 41 i: &mut AngleBracketedGenericArguments, 42 ) { 43 visit_angle_bracketed_generic_arguments_mut(self, i); 44 } 45 #[cfg(feature = "full")] 46 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 47 fn visit_arm_mut(&mut self, i: &mut Arm) { 48 visit_arm_mut(self, i); 49 } 50 #[cfg(any(feature = "derive", feature = "full"))] 51 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 52 fn visit_assoc_const_mut(&mut self, i: &mut AssocConst) { 53 visit_assoc_const_mut(self, i); 54 } 55 #[cfg(any(feature = "derive", feature = "full"))] 56 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 57 fn visit_assoc_type_mut(&mut self, i: &mut AssocType) { 58 visit_assoc_type_mut(self, i); 59 } 60 #[cfg(any(feature = "derive", feature = "full"))] 61 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 62 fn visit_attr_style_mut(&mut self, i: &mut AttrStyle) { 63 visit_attr_style_mut(self, i); 64 } 65 #[cfg(any(feature = "derive", feature = "full"))] 66 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 67 fn visit_attribute_mut(&mut self, i: &mut Attribute) { 68 visit_attribute_mut(self, i); 69 } 70 #[cfg(any(feature = "derive", feature = "full"))] 71 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 72 fn visit_bare_fn_arg_mut(&mut self, i: &mut BareFnArg) { 73 visit_bare_fn_arg_mut(self, i); 74 } 75 #[cfg(any(feature = "derive", feature = "full"))] 76 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 77 fn visit_bare_variadic_mut(&mut self, i: &mut BareVariadic) { 78 visit_bare_variadic_mut(self, i); 79 } 80 #[cfg(any(feature = "derive", feature = "full"))] 81 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 82 fn visit_bin_op_mut(&mut self, i: &mut BinOp) { 83 visit_bin_op_mut(self, i); 84 } 85 #[cfg(feature = "full")] 86 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 87 fn visit_block_mut(&mut self, i: &mut Block) { 88 visit_block_mut(self, i); 89 } 90 #[cfg(any(feature = "derive", feature = "full"))] 91 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 92 fn visit_bound_lifetimes_mut(&mut self, i: &mut BoundLifetimes) { 93 visit_bound_lifetimes_mut(self, i); 94 } 95 #[cfg(any(feature = "derive", feature = "full"))] 96 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 97 fn visit_const_param_mut(&mut self, i: &mut ConstParam) { 98 visit_const_param_mut(self, i); 99 } 100 #[cfg(any(feature = "derive", feature = "full"))] 101 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 102 fn visit_constraint_mut(&mut self, i: &mut Constraint) { 103 visit_constraint_mut(self, i); 104 } 105 #[cfg(feature = "derive")] 106 #[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))] 107 fn visit_data_mut(&mut self, i: &mut Data) { 108 visit_data_mut(self, i); 109 } 110 #[cfg(feature = "derive")] 111 #[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))] 112 fn visit_data_enum_mut(&mut self, i: &mut DataEnum) { 113 visit_data_enum_mut(self, i); 114 } 115 #[cfg(feature = "derive")] 116 #[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))] 117 fn visit_data_struct_mut(&mut self, i: &mut DataStruct) { 118 visit_data_struct_mut(self, i); 119 } 120 #[cfg(feature = "derive")] 121 #[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))] 122 fn visit_data_union_mut(&mut self, i: &mut DataUnion) { 123 visit_data_union_mut(self, i); 124 } 125 #[cfg(feature = "derive")] 126 #[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))] 127 fn visit_derive_input_mut(&mut self, i: &mut DeriveInput) { 128 visit_derive_input_mut(self, i); 129 } 130 #[cfg(any(feature = "derive", feature = "full"))] 131 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 132 fn visit_expr_mut(&mut self, i: &mut Expr) { 133 visit_expr_mut(self, i); 134 } 135 #[cfg(feature = "full")] 136 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 137 fn visit_expr_array_mut(&mut self, i: &mut ExprArray) { 138 visit_expr_array_mut(self, i); 139 } 140 #[cfg(feature = "full")] 141 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 142 fn visit_expr_assign_mut(&mut self, i: &mut ExprAssign) { 143 visit_expr_assign_mut(self, i); 144 } 145 #[cfg(feature = "full")] 146 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 147 fn visit_expr_async_mut(&mut self, i: &mut ExprAsync) { 148 visit_expr_async_mut(self, i); 149 } 150 #[cfg(feature = "full")] 151 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 152 fn visit_expr_await_mut(&mut self, i: &mut ExprAwait) { 153 visit_expr_await_mut(self, i); 154 } 155 #[cfg(any(feature = "derive", feature = "full"))] 156 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 157 fn visit_expr_binary_mut(&mut self, i: &mut ExprBinary) { 158 visit_expr_binary_mut(self, i); 159 } 160 #[cfg(feature = "full")] 161 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 162 fn visit_expr_block_mut(&mut self, i: &mut ExprBlock) { 163 visit_expr_block_mut(self, i); 164 } 165 #[cfg(feature = "full")] 166 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 167 fn visit_expr_break_mut(&mut self, i: &mut ExprBreak) { 168 visit_expr_break_mut(self, i); 169 } 170 #[cfg(any(feature = "derive", feature = "full"))] 171 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 172 fn visit_expr_call_mut(&mut self, i: &mut ExprCall) { 173 visit_expr_call_mut(self, i); 174 } 175 #[cfg(any(feature = "derive", feature = "full"))] 176 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 177 fn visit_expr_cast_mut(&mut self, i: &mut ExprCast) { 178 visit_expr_cast_mut(self, i); 179 } 180 #[cfg(feature = "full")] 181 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 182 fn visit_expr_closure_mut(&mut self, i: &mut ExprClosure) { 183 visit_expr_closure_mut(self, i); 184 } 185 #[cfg(feature = "full")] 186 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 187 fn visit_expr_const_mut(&mut self, i: &mut ExprConst) { 188 visit_expr_const_mut(self, i); 189 } 190 #[cfg(feature = "full")] 191 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 192 fn visit_expr_continue_mut(&mut self, i: &mut ExprContinue) { 193 visit_expr_continue_mut(self, i); 194 } 195 #[cfg(any(feature = "derive", feature = "full"))] 196 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 197 fn visit_expr_field_mut(&mut self, i: &mut ExprField) { 198 visit_expr_field_mut(self, i); 199 } 200 #[cfg(feature = "full")] 201 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 202 fn visit_expr_for_loop_mut(&mut self, i: &mut ExprForLoop) { 203 visit_expr_for_loop_mut(self, i); 204 } 205 #[cfg(any(feature = "derive", feature = "full"))] 206 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 207 fn visit_expr_group_mut(&mut self, i: &mut ExprGroup) { 208 visit_expr_group_mut(self, i); 209 } 210 #[cfg(feature = "full")] 211 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 212 fn visit_expr_if_mut(&mut self, i: &mut ExprIf) { 213 visit_expr_if_mut(self, i); 214 } 215 #[cfg(any(feature = "derive", feature = "full"))] 216 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 217 fn visit_expr_index_mut(&mut self, i: &mut ExprIndex) { 218 visit_expr_index_mut(self, i); 219 } 220 #[cfg(feature = "full")] 221 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 222 fn visit_expr_infer_mut(&mut self, i: &mut ExprInfer) { 223 visit_expr_infer_mut(self, i); 224 } 225 #[cfg(feature = "full")] 226 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 227 fn visit_expr_let_mut(&mut self, i: &mut ExprLet) { 228 visit_expr_let_mut(self, i); 229 } 230 #[cfg(any(feature = "derive", feature = "full"))] 231 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 232 fn visit_expr_lit_mut(&mut self, i: &mut ExprLit) { 233 visit_expr_lit_mut(self, i); 234 } 235 #[cfg(feature = "full")] 236 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 237 fn visit_expr_loop_mut(&mut self, i: &mut ExprLoop) { 238 visit_expr_loop_mut(self, i); 239 } 240 #[cfg(any(feature = "derive", feature = "full"))] 241 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 242 fn visit_expr_macro_mut(&mut self, i: &mut ExprMacro) { 243 visit_expr_macro_mut(self, i); 244 } 245 #[cfg(feature = "full")] 246 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 247 fn visit_expr_match_mut(&mut self, i: &mut ExprMatch) { 248 visit_expr_match_mut(self, i); 249 } 250 #[cfg(any(feature = "derive", feature = "full"))] 251 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 252 fn visit_expr_method_call_mut(&mut self, i: &mut ExprMethodCall) { 253 visit_expr_method_call_mut(self, i); 254 } 255 #[cfg(any(feature = "derive", feature = "full"))] 256 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 257 fn visit_expr_paren_mut(&mut self, i: &mut ExprParen) { 258 visit_expr_paren_mut(self, i); 259 } 260 #[cfg(any(feature = "derive", feature = "full"))] 261 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 262 fn visit_expr_path_mut(&mut self, i: &mut ExprPath) { 263 visit_expr_path_mut(self, i); 264 } 265 #[cfg(feature = "full")] 266 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 267 fn visit_expr_range_mut(&mut self, i: &mut ExprRange) { 268 visit_expr_range_mut(self, i); 269 } 270 #[cfg(any(feature = "derive", feature = "full"))] 271 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 272 fn visit_expr_reference_mut(&mut self, i: &mut ExprReference) { 273 visit_expr_reference_mut(self, i); 274 } 275 #[cfg(feature = "full")] 276 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 277 fn visit_expr_repeat_mut(&mut self, i: &mut ExprRepeat) { 278 visit_expr_repeat_mut(self, i); 279 } 280 #[cfg(feature = "full")] 281 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 282 fn visit_expr_return_mut(&mut self, i: &mut ExprReturn) { 283 visit_expr_return_mut(self, i); 284 } 285 #[cfg(any(feature = "derive", feature = "full"))] 286 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 287 fn visit_expr_struct_mut(&mut self, i: &mut ExprStruct) { 288 visit_expr_struct_mut(self, i); 289 } 290 #[cfg(feature = "full")] 291 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 292 fn visit_expr_try_mut(&mut self, i: &mut ExprTry) { 293 visit_expr_try_mut(self, i); 294 } 295 #[cfg(feature = "full")] 296 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 297 fn visit_expr_try_block_mut(&mut self, i: &mut ExprTryBlock) { 298 visit_expr_try_block_mut(self, i); 299 } 300 #[cfg(feature = "full")] 301 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 302 fn visit_expr_tuple_mut(&mut self, i: &mut ExprTuple) { 303 visit_expr_tuple_mut(self, i); 304 } 305 #[cfg(any(feature = "derive", feature = "full"))] 306 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 307 fn visit_expr_unary_mut(&mut self, i: &mut ExprUnary) { 308 visit_expr_unary_mut(self, i); 309 } 310 #[cfg(feature = "full")] 311 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 312 fn visit_expr_unsafe_mut(&mut self, i: &mut ExprUnsafe) { 313 visit_expr_unsafe_mut(self, i); 314 } 315 #[cfg(feature = "full")] 316 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 317 fn visit_expr_while_mut(&mut self, i: &mut ExprWhile) { 318 visit_expr_while_mut(self, i); 319 } 320 #[cfg(feature = "full")] 321 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 322 fn visit_expr_yield_mut(&mut self, i: &mut ExprYield) { 323 visit_expr_yield_mut(self, i); 324 } 325 #[cfg(any(feature = "derive", feature = "full"))] 326 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 327 fn visit_field_mut(&mut self, i: &mut Field) { 328 visit_field_mut(self, i); 329 } 330 #[cfg(any(feature = "derive", feature = "full"))] 331 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 332 fn visit_field_mutability_mut(&mut self, i: &mut FieldMutability) { 333 visit_field_mutability_mut(self, i); 334 } 335 #[cfg(feature = "full")] 336 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 337 fn visit_field_pat_mut(&mut self, i: &mut FieldPat) { 338 visit_field_pat_mut(self, i); 339 } 340 #[cfg(any(feature = "derive", feature = "full"))] 341 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 342 fn visit_field_value_mut(&mut self, i: &mut FieldValue) { 343 visit_field_value_mut(self, i); 344 } 345 #[cfg(any(feature = "derive", feature = "full"))] 346 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 347 fn visit_fields_mut(&mut self, i: &mut Fields) { 348 visit_fields_mut(self, i); 349 } 350 #[cfg(any(feature = "derive", feature = "full"))] 351 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 352 fn visit_fields_named_mut(&mut self, i: &mut FieldsNamed) { 353 visit_fields_named_mut(self, i); 354 } 355 #[cfg(any(feature = "derive", feature = "full"))] 356 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 357 fn visit_fields_unnamed_mut(&mut self, i: &mut FieldsUnnamed) { 358 visit_fields_unnamed_mut(self, i); 359 } 360 #[cfg(feature = "full")] 361 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 362 fn visit_file_mut(&mut self, i: &mut File) { 363 visit_file_mut(self, i); 364 } 365 #[cfg(feature = "full")] 366 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 367 fn visit_fn_arg_mut(&mut self, i: &mut FnArg) { 368 visit_fn_arg_mut(self, i); 369 } 370 #[cfg(feature = "full")] 371 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 372 fn visit_foreign_item_mut(&mut self, i: &mut ForeignItem) { 373 visit_foreign_item_mut(self, i); 374 } 375 #[cfg(feature = "full")] 376 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 377 fn visit_foreign_item_fn_mut(&mut self, i: &mut ForeignItemFn) { 378 visit_foreign_item_fn_mut(self, i); 379 } 380 #[cfg(feature = "full")] 381 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 382 fn visit_foreign_item_macro_mut(&mut self, i: &mut ForeignItemMacro) { 383 visit_foreign_item_macro_mut(self, i); 384 } 385 #[cfg(feature = "full")] 386 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 387 fn visit_foreign_item_static_mut(&mut self, i: &mut ForeignItemStatic) { 388 visit_foreign_item_static_mut(self, i); 389 } 390 #[cfg(feature = "full")] 391 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 392 fn visit_foreign_item_type_mut(&mut self, i: &mut ForeignItemType) { 393 visit_foreign_item_type_mut(self, i); 394 } 395 #[cfg(any(feature = "derive", feature = "full"))] 396 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 397 fn visit_generic_argument_mut(&mut self, i: &mut GenericArgument) { 398 visit_generic_argument_mut(self, i); 399 } 400 #[cfg(any(feature = "derive", feature = "full"))] 401 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 402 fn visit_generic_param_mut(&mut self, i: &mut GenericParam) { 403 visit_generic_param_mut(self, i); 404 } 405 #[cfg(any(feature = "derive", feature = "full"))] 406 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 407 fn visit_generics_mut(&mut self, i: &mut Generics) { 408 visit_generics_mut(self, i); 409 } 410 fn visit_ident_mut(&mut self, i: &mut Ident) { 411 visit_ident_mut(self, i); 412 } 413 #[cfg(feature = "full")] 414 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 415 fn visit_impl_item_mut(&mut self, i: &mut ImplItem) { 416 visit_impl_item_mut(self, i); 417 } 418 #[cfg(feature = "full")] 419 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 420 fn visit_impl_item_const_mut(&mut self, i: &mut ImplItemConst) { 421 visit_impl_item_const_mut(self, i); 422 } 423 #[cfg(feature = "full")] 424 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 425 fn visit_impl_item_fn_mut(&mut self, i: &mut ImplItemFn) { 426 visit_impl_item_fn_mut(self, i); 427 } 428 #[cfg(feature = "full")] 429 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 430 fn visit_impl_item_macro_mut(&mut self, i: &mut ImplItemMacro) { 431 visit_impl_item_macro_mut(self, i); 432 } 433 #[cfg(feature = "full")] 434 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 435 fn visit_impl_item_type_mut(&mut self, i: &mut ImplItemType) { 436 visit_impl_item_type_mut(self, i); 437 } 438 #[cfg(feature = "full")] 439 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 440 fn visit_impl_restriction_mut(&mut self, i: &mut ImplRestriction) { 441 visit_impl_restriction_mut(self, i); 442 } 443 #[cfg(any(feature = "derive", feature = "full"))] 444 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 445 fn visit_index_mut(&mut self, i: &mut Index) { 446 visit_index_mut(self, i); 447 } 448 #[cfg(feature = "full")] 449 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 450 fn visit_item_mut(&mut self, i: &mut Item) { 451 visit_item_mut(self, i); 452 } 453 #[cfg(feature = "full")] 454 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 455 fn visit_item_const_mut(&mut self, i: &mut ItemConst) { 456 visit_item_const_mut(self, i); 457 } 458 #[cfg(feature = "full")] 459 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 460 fn visit_item_enum_mut(&mut self, i: &mut ItemEnum) { 461 visit_item_enum_mut(self, i); 462 } 463 #[cfg(feature = "full")] 464 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 465 fn visit_item_extern_crate_mut(&mut self, i: &mut ItemExternCrate) { 466 visit_item_extern_crate_mut(self, i); 467 } 468 #[cfg(feature = "full")] 469 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 470 fn visit_item_fn_mut(&mut self, i: &mut ItemFn) { 471 visit_item_fn_mut(self, i); 472 } 473 #[cfg(feature = "full")] 474 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 475 fn visit_item_foreign_mod_mut(&mut self, i: &mut ItemForeignMod) { 476 visit_item_foreign_mod_mut(self, i); 477 } 478 #[cfg(feature = "full")] 479 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 480 fn visit_item_impl_mut(&mut self, i: &mut ItemImpl) { 481 visit_item_impl_mut(self, i); 482 } 483 #[cfg(feature = "full")] 484 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 485 fn visit_item_macro_mut(&mut self, i: &mut ItemMacro) { 486 visit_item_macro_mut(self, i); 487 } 488 #[cfg(feature = "full")] 489 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 490 fn visit_item_mod_mut(&mut self, i: &mut ItemMod) { 491 visit_item_mod_mut(self, i); 492 } 493 #[cfg(feature = "full")] 494 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 495 fn visit_item_static_mut(&mut self, i: &mut ItemStatic) { 496 visit_item_static_mut(self, i); 497 } 498 #[cfg(feature = "full")] 499 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 500 fn visit_item_struct_mut(&mut self, i: &mut ItemStruct) { 501 visit_item_struct_mut(self, i); 502 } 503 #[cfg(feature = "full")] 504 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 505 fn visit_item_trait_mut(&mut self, i: &mut ItemTrait) { 506 visit_item_trait_mut(self, i); 507 } 508 #[cfg(feature = "full")] 509 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 510 fn visit_item_trait_alias_mut(&mut self, i: &mut ItemTraitAlias) { 511 visit_item_trait_alias_mut(self, i); 512 } 513 #[cfg(feature = "full")] 514 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 515 fn visit_item_type_mut(&mut self, i: &mut ItemType) { 516 visit_item_type_mut(self, i); 517 } 518 #[cfg(feature = "full")] 519 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 520 fn visit_item_union_mut(&mut self, i: &mut ItemUnion) { 521 visit_item_union_mut(self, i); 522 } 523 #[cfg(feature = "full")] 524 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 525 fn visit_item_use_mut(&mut self, i: &mut ItemUse) { 526 visit_item_use_mut(self, i); 527 } 528 #[cfg(feature = "full")] 529 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 530 fn visit_label_mut(&mut self, i: &mut Label) { 531 visit_label_mut(self, i); 532 } 533 fn visit_lifetime_mut(&mut self, i: &mut Lifetime) { 534 visit_lifetime_mut(self, i); 535 } 536 #[cfg(any(feature = "derive", feature = "full"))] 537 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 538 fn visit_lifetime_param_mut(&mut self, i: &mut LifetimeParam) { 539 visit_lifetime_param_mut(self, i); 540 } 541 fn visit_lit_mut(&mut self, i: &mut Lit) { 542 visit_lit_mut(self, i); 543 } 544 fn visit_lit_bool_mut(&mut self, i: &mut LitBool) { 545 visit_lit_bool_mut(self, i); 546 } 547 fn visit_lit_byte_mut(&mut self, i: &mut LitByte) { 548 visit_lit_byte_mut(self, i); 549 } 550 fn visit_lit_byte_str_mut(&mut self, i: &mut LitByteStr) { 551 visit_lit_byte_str_mut(self, i); 552 } 553 fn visit_lit_char_mut(&mut self, i: &mut LitChar) { 554 visit_lit_char_mut(self, i); 555 } 556 fn visit_lit_float_mut(&mut self, i: &mut LitFloat) { 557 visit_lit_float_mut(self, i); 558 } 559 fn visit_lit_int_mut(&mut self, i: &mut LitInt) { 560 visit_lit_int_mut(self, i); 561 } 562 fn visit_lit_str_mut(&mut self, i: &mut LitStr) { 563 visit_lit_str_mut(self, i); 564 } 565 #[cfg(feature = "full")] 566 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 567 fn visit_local_mut(&mut self, i: &mut Local) { 568 visit_local_mut(self, i); 569 } 570 #[cfg(feature = "full")] 571 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 572 fn visit_local_init_mut(&mut self, i: &mut LocalInit) { 573 visit_local_init_mut(self, i); 574 } 575 #[cfg(any(feature = "derive", feature = "full"))] 576 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 577 fn visit_macro_mut(&mut self, i: &mut Macro) { 578 visit_macro_mut(self, i); 579 } 580 #[cfg(any(feature = "derive", feature = "full"))] 581 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 582 fn visit_macro_delimiter_mut(&mut self, i: &mut MacroDelimiter) { 583 visit_macro_delimiter_mut(self, i); 584 } 585 #[cfg(any(feature = "derive", feature = "full"))] 586 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 587 fn visit_member_mut(&mut self, i: &mut Member) { 588 visit_member_mut(self, i); 589 } 590 #[cfg(any(feature = "derive", feature = "full"))] 591 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 592 fn visit_meta_mut(&mut self, i: &mut Meta) { 593 visit_meta_mut(self, i); 594 } 595 #[cfg(any(feature = "derive", feature = "full"))] 596 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 597 fn visit_meta_list_mut(&mut self, i: &mut MetaList) { 598 visit_meta_list_mut(self, i); 599 } 600 #[cfg(any(feature = "derive", feature = "full"))] 601 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 602 fn visit_meta_name_value_mut(&mut self, i: &mut MetaNameValue) { 603 visit_meta_name_value_mut(self, i); 604 } 605 #[cfg(any(feature = "derive", feature = "full"))] 606 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 607 fn visit_parenthesized_generic_arguments_mut( 608 &mut self, 609 i: &mut ParenthesizedGenericArguments, 610 ) { 611 visit_parenthesized_generic_arguments_mut(self, i); 612 } 613 #[cfg(feature = "full")] 614 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 615 fn visit_pat_mut(&mut self, i: &mut Pat) { 616 visit_pat_mut(self, i); 617 } 618 #[cfg(feature = "full")] 619 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 620 fn visit_pat_ident_mut(&mut self, i: &mut PatIdent) { 621 visit_pat_ident_mut(self, i); 622 } 623 #[cfg(feature = "full")] 624 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 625 fn visit_pat_or_mut(&mut self, i: &mut PatOr) { 626 visit_pat_or_mut(self, i); 627 } 628 #[cfg(feature = "full")] 629 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 630 fn visit_pat_paren_mut(&mut self, i: &mut PatParen) { 631 visit_pat_paren_mut(self, i); 632 } 633 #[cfg(feature = "full")] 634 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 635 fn visit_pat_reference_mut(&mut self, i: &mut PatReference) { 636 visit_pat_reference_mut(self, i); 637 } 638 #[cfg(feature = "full")] 639 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 640 fn visit_pat_rest_mut(&mut self, i: &mut PatRest) { 641 visit_pat_rest_mut(self, i); 642 } 643 #[cfg(feature = "full")] 644 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 645 fn visit_pat_slice_mut(&mut self, i: &mut PatSlice) { 646 visit_pat_slice_mut(self, i); 647 } 648 #[cfg(feature = "full")] 649 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 650 fn visit_pat_struct_mut(&mut self, i: &mut PatStruct) { 651 visit_pat_struct_mut(self, i); 652 } 653 #[cfg(feature = "full")] 654 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 655 fn visit_pat_tuple_mut(&mut self, i: &mut PatTuple) { 656 visit_pat_tuple_mut(self, i); 657 } 658 #[cfg(feature = "full")] 659 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 660 fn visit_pat_tuple_struct_mut(&mut self, i: &mut PatTupleStruct) { 661 visit_pat_tuple_struct_mut(self, i); 662 } 663 #[cfg(feature = "full")] 664 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 665 fn visit_pat_type_mut(&mut self, i: &mut PatType) { 666 visit_pat_type_mut(self, i); 667 } 668 #[cfg(feature = "full")] 669 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 670 fn visit_pat_wild_mut(&mut self, i: &mut PatWild) { 671 visit_pat_wild_mut(self, i); 672 } 673 #[cfg(any(feature = "derive", feature = "full"))] 674 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 675 fn visit_path_mut(&mut self, i: &mut Path) { 676 visit_path_mut(self, i); 677 } 678 #[cfg(any(feature = "derive", feature = "full"))] 679 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 680 fn visit_path_arguments_mut(&mut self, i: &mut PathArguments) { 681 visit_path_arguments_mut(self, i); 682 } 683 #[cfg(any(feature = "derive", feature = "full"))] 684 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 685 fn visit_path_segment_mut(&mut self, i: &mut PathSegment) { 686 visit_path_segment_mut(self, i); 687 } 688 #[cfg(any(feature = "derive", feature = "full"))] 689 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 690 fn visit_predicate_lifetime_mut(&mut self, i: &mut PredicateLifetime) { 691 visit_predicate_lifetime_mut(self, i); 692 } 693 #[cfg(any(feature = "derive", feature = "full"))] 694 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 695 fn visit_predicate_type_mut(&mut self, i: &mut PredicateType) { 696 visit_predicate_type_mut(self, i); 697 } 698 #[cfg(any(feature = "derive", feature = "full"))] 699 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 700 fn visit_qself_mut(&mut self, i: &mut QSelf) { 701 visit_qself_mut(self, i); 702 } 703 #[cfg(feature = "full")] 704 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 705 fn visit_range_limits_mut(&mut self, i: &mut RangeLimits) { 706 visit_range_limits_mut(self, i); 707 } 708 #[cfg(feature = "full")] 709 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 710 fn visit_receiver_mut(&mut self, i: &mut Receiver) { 711 visit_receiver_mut(self, i); 712 } 713 #[cfg(any(feature = "derive", feature = "full"))] 714 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 715 fn visit_return_type_mut(&mut self, i: &mut ReturnType) { 716 visit_return_type_mut(self, i); 717 } 718 #[cfg(feature = "full")] 719 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 720 fn visit_signature_mut(&mut self, i: &mut Signature) { 721 visit_signature_mut(self, i); 722 } 723 fn visit_span_mut(&mut self, i: &mut Span) { 724 visit_span_mut(self, i); 725 } 726 #[cfg(feature = "full")] 727 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 728 fn visit_static_mutability_mut(&mut self, i: &mut StaticMutability) { 729 visit_static_mutability_mut(self, i); 730 } 731 #[cfg(feature = "full")] 732 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 733 fn visit_stmt_mut(&mut self, i: &mut Stmt) { 734 visit_stmt_mut(self, i); 735 } 736 #[cfg(feature = "full")] 737 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 738 fn visit_stmt_macro_mut(&mut self, i: &mut StmtMacro) { 739 visit_stmt_macro_mut(self, i); 740 } 741 #[cfg(any(feature = "derive", feature = "full"))] 742 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 743 fn visit_trait_bound_mut(&mut self, i: &mut TraitBound) { 744 visit_trait_bound_mut(self, i); 745 } 746 #[cfg(any(feature = "derive", feature = "full"))] 747 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 748 fn visit_trait_bound_modifier_mut(&mut self, i: &mut TraitBoundModifier) { 749 visit_trait_bound_modifier_mut(self, i); 750 } 751 #[cfg(feature = "full")] 752 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 753 fn visit_trait_item_mut(&mut self, i: &mut TraitItem) { 754 visit_trait_item_mut(self, i); 755 } 756 #[cfg(feature = "full")] 757 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 758 fn visit_trait_item_const_mut(&mut self, i: &mut TraitItemConst) { 759 visit_trait_item_const_mut(self, i); 760 } 761 #[cfg(feature = "full")] 762 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 763 fn visit_trait_item_fn_mut(&mut self, i: &mut TraitItemFn) { 764 visit_trait_item_fn_mut(self, i); 765 } 766 #[cfg(feature = "full")] 767 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 768 fn visit_trait_item_macro_mut(&mut self, i: &mut TraitItemMacro) { 769 visit_trait_item_macro_mut(self, i); 770 } 771 #[cfg(feature = "full")] 772 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 773 fn visit_trait_item_type_mut(&mut self, i: &mut TraitItemType) { 774 visit_trait_item_type_mut(self, i); 775 } 776 #[cfg(any(feature = "derive", feature = "full"))] 777 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 778 fn visit_type_mut(&mut self, i: &mut Type) { 779 visit_type_mut(self, i); 780 } 781 #[cfg(any(feature = "derive", feature = "full"))] 782 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 783 fn visit_type_array_mut(&mut self, i: &mut TypeArray) { 784 visit_type_array_mut(self, i); 785 } 786 #[cfg(any(feature = "derive", feature = "full"))] 787 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 788 fn visit_type_bare_fn_mut(&mut self, i: &mut TypeBareFn) { 789 visit_type_bare_fn_mut(self, i); 790 } 791 #[cfg(any(feature = "derive", feature = "full"))] 792 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 793 fn visit_type_group_mut(&mut self, i: &mut TypeGroup) { 794 visit_type_group_mut(self, i); 795 } 796 #[cfg(any(feature = "derive", feature = "full"))] 797 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 798 fn visit_type_impl_trait_mut(&mut self, i: &mut TypeImplTrait) { 799 visit_type_impl_trait_mut(self, i); 800 } 801 #[cfg(any(feature = "derive", feature = "full"))] 802 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 803 fn visit_type_infer_mut(&mut self, i: &mut TypeInfer) { 804 visit_type_infer_mut(self, i); 805 } 806 #[cfg(any(feature = "derive", feature = "full"))] 807 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 808 fn visit_type_macro_mut(&mut self, i: &mut TypeMacro) { 809 visit_type_macro_mut(self, i); 810 } 811 #[cfg(any(feature = "derive", feature = "full"))] 812 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 813 fn visit_type_never_mut(&mut self, i: &mut TypeNever) { 814 visit_type_never_mut(self, i); 815 } 816 #[cfg(any(feature = "derive", feature = "full"))] 817 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 818 fn visit_type_param_mut(&mut self, i: &mut TypeParam) { 819 visit_type_param_mut(self, i); 820 } 821 #[cfg(any(feature = "derive", feature = "full"))] 822 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 823 fn visit_type_param_bound_mut(&mut self, i: &mut TypeParamBound) { 824 visit_type_param_bound_mut(self, i); 825 } 826 #[cfg(any(feature = "derive", feature = "full"))] 827 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 828 fn visit_type_paren_mut(&mut self, i: &mut TypeParen) { 829 visit_type_paren_mut(self, i); 830 } 831 #[cfg(any(feature = "derive", feature = "full"))] 832 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 833 fn visit_type_path_mut(&mut self, i: &mut TypePath) { 834 visit_type_path_mut(self, i); 835 } 836 #[cfg(any(feature = "derive", feature = "full"))] 837 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 838 fn visit_type_ptr_mut(&mut self, i: &mut TypePtr) { 839 visit_type_ptr_mut(self, i); 840 } 841 #[cfg(any(feature = "derive", feature = "full"))] 842 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 843 fn visit_type_reference_mut(&mut self, i: &mut TypeReference) { 844 visit_type_reference_mut(self, i); 845 } 846 #[cfg(any(feature = "derive", feature = "full"))] 847 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 848 fn visit_type_slice_mut(&mut self, i: &mut TypeSlice) { 849 visit_type_slice_mut(self, i); 850 } 851 #[cfg(any(feature = "derive", feature = "full"))] 852 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 853 fn visit_type_trait_object_mut(&mut self, i: &mut TypeTraitObject) { 854 visit_type_trait_object_mut(self, i); 855 } 856 #[cfg(any(feature = "derive", feature = "full"))] 857 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 858 fn visit_type_tuple_mut(&mut self, i: &mut TypeTuple) { 859 visit_type_tuple_mut(self, i); 860 } 861 #[cfg(any(feature = "derive", feature = "full"))] 862 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 863 fn visit_un_op_mut(&mut self, i: &mut UnOp) { 864 visit_un_op_mut(self, i); 865 } 866 #[cfg(feature = "full")] 867 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 868 fn visit_use_glob_mut(&mut self, i: &mut UseGlob) { 869 visit_use_glob_mut(self, i); 870 } 871 #[cfg(feature = "full")] 872 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 873 fn visit_use_group_mut(&mut self, i: &mut UseGroup) { 874 visit_use_group_mut(self, i); 875 } 876 #[cfg(feature = "full")] 877 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 878 fn visit_use_name_mut(&mut self, i: &mut UseName) { 879 visit_use_name_mut(self, i); 880 } 881 #[cfg(feature = "full")] 882 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 883 fn visit_use_path_mut(&mut self, i: &mut UsePath) { 884 visit_use_path_mut(self, i); 885 } 886 #[cfg(feature = "full")] 887 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 888 fn visit_use_rename_mut(&mut self, i: &mut UseRename) { 889 visit_use_rename_mut(self, i); 890 } 891 #[cfg(feature = "full")] 892 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 893 fn visit_use_tree_mut(&mut self, i: &mut UseTree) { 894 visit_use_tree_mut(self, i); 895 } 896 #[cfg(feature = "full")] 897 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 898 fn visit_variadic_mut(&mut self, i: &mut Variadic) { 899 visit_variadic_mut(self, i); 900 } 901 #[cfg(any(feature = "derive", feature = "full"))] 902 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 903 fn visit_variant_mut(&mut self, i: &mut Variant) { 904 visit_variant_mut(self, i); 905 } 906 #[cfg(any(feature = "derive", feature = "full"))] 907 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 908 fn visit_vis_restricted_mut(&mut self, i: &mut VisRestricted) { 909 visit_vis_restricted_mut(self, i); 910 } 911 #[cfg(any(feature = "derive", feature = "full"))] 912 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 913 fn visit_visibility_mut(&mut self, i: &mut Visibility) { 914 visit_visibility_mut(self, i); 915 } 916 #[cfg(any(feature = "derive", feature = "full"))] 917 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 918 fn visit_where_clause_mut(&mut self, i: &mut WhereClause) { 919 visit_where_clause_mut(self, i); 920 } 921 #[cfg(any(feature = "derive", feature = "full"))] 922 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 923 fn visit_where_predicate_mut(&mut self, i: &mut WherePredicate) { 924 visit_where_predicate_mut(self, i); 925 } 926} 927#[cfg(any(feature = "derive", feature = "full"))] 928#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 929pub fn visit_abi_mut<V>(v: &mut V, node: &mut Abi) 930where 931 V: VisitMut + ?Sized, 932{ 933 skip!(node.extern_token); 934 if let Some(it) = &mut node.name { 935 v.visit_lit_str_mut(it); 936 } 937} 938#[cfg(any(feature = "derive", feature = "full"))] 939#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 940pub fn visit_angle_bracketed_generic_arguments_mut<V>( 941 v: &mut V, 942 node: &mut AngleBracketedGenericArguments, 943) 944where 945 V: VisitMut + ?Sized, 946{ 947 skip!(node.colon2_token); 948 skip!(node.lt_token); 949 for mut el in Punctuated::pairs_mut(&mut node.args) { 950 let it = el.value_mut(); 951 v.visit_generic_argument_mut(it); 952 } 953 skip!(node.gt_token); 954} 955#[cfg(feature = "full")] 956#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 957pub fn visit_arm_mut<V>(v: &mut V, node: &mut Arm) 958where 959 V: VisitMut + ?Sized, 960{ 961 for it in &mut node.attrs { 962 v.visit_attribute_mut(it); 963 } 964 v.visit_pat_mut(&mut node.pat); 965 if let Some(it) = &mut node.guard { 966 skip!((it).0); 967 v.visit_expr_mut(&mut *(it).1); 968 } 969 skip!(node.fat_arrow_token); 970 v.visit_expr_mut(&mut *node.body); 971 skip!(node.comma); 972} 973#[cfg(any(feature = "derive", feature = "full"))] 974#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 975pub fn visit_assoc_const_mut<V>(v: &mut V, node: &mut AssocConst) 976where 977 V: VisitMut + ?Sized, 978{ 979 v.visit_ident_mut(&mut node.ident); 980 if let Some(it) = &mut node.generics { 981 v.visit_angle_bracketed_generic_arguments_mut(it); 982 } 983 skip!(node.eq_token); 984 v.visit_expr_mut(&mut node.value); 985} 986#[cfg(any(feature = "derive", feature = "full"))] 987#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 988pub fn visit_assoc_type_mut<V>(v: &mut V, node: &mut AssocType) 989where 990 V: VisitMut + ?Sized, 991{ 992 v.visit_ident_mut(&mut node.ident); 993 if let Some(it) = &mut node.generics { 994 v.visit_angle_bracketed_generic_arguments_mut(it); 995 } 996 skip!(node.eq_token); 997 v.visit_type_mut(&mut node.ty); 998} 999#[cfg(any(feature = "derive", feature = "full"))] 1000#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 1001pub fn visit_attr_style_mut<V>(v: &mut V, node: &mut AttrStyle) 1002where 1003 V: VisitMut + ?Sized, 1004{ 1005 match node { 1006 AttrStyle::Outer => {} 1007 AttrStyle::Inner(_binding_0) => { 1008 skip!(_binding_0); 1009 } 1010 } 1011} 1012#[cfg(any(feature = "derive", feature = "full"))] 1013#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 1014pub fn visit_attribute_mut<V>(v: &mut V, node: &mut Attribute) 1015where 1016 V: VisitMut + ?Sized, 1017{ 1018 skip!(node.pound_token); 1019 v.visit_attr_style_mut(&mut node.style); 1020 skip!(node.bracket_token); 1021 v.visit_meta_mut(&mut node.meta); 1022} 1023#[cfg(any(feature = "derive", feature = "full"))] 1024#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 1025pub fn visit_bare_fn_arg_mut<V>(v: &mut V, node: &mut BareFnArg) 1026where 1027 V: VisitMut + ?Sized, 1028{ 1029 for it in &mut node.attrs { 1030 v.visit_attribute_mut(it); 1031 } 1032 if let Some(it) = &mut node.name { 1033 v.visit_ident_mut(&mut (it).0); 1034 skip!((it).1); 1035 } 1036 v.visit_type_mut(&mut node.ty); 1037} 1038#[cfg(any(feature = "derive", feature = "full"))] 1039#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 1040pub fn visit_bare_variadic_mut<V>(v: &mut V, node: &mut BareVariadic) 1041where 1042 V: VisitMut + ?Sized, 1043{ 1044 for it in &mut node.attrs { 1045 v.visit_attribute_mut(it); 1046 } 1047 if let Some(it) = &mut node.name { 1048 v.visit_ident_mut(&mut (it).0); 1049 skip!((it).1); 1050 } 1051 skip!(node.dots); 1052 skip!(node.comma); 1053} 1054#[cfg(any(feature = "derive", feature = "full"))] 1055#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 1056pub fn visit_bin_op_mut<V>(v: &mut V, node: &mut BinOp) 1057where 1058 V: VisitMut + ?Sized, 1059{ 1060 match node { 1061 BinOp::Add(_binding_0) => { 1062 skip!(_binding_0); 1063 } 1064 BinOp::Sub(_binding_0) => { 1065 skip!(_binding_0); 1066 } 1067 BinOp::Mul(_binding_0) => { 1068 skip!(_binding_0); 1069 } 1070 BinOp::Div(_binding_0) => { 1071 skip!(_binding_0); 1072 } 1073 BinOp::Rem(_binding_0) => { 1074 skip!(_binding_0); 1075 } 1076 BinOp::And(_binding_0) => { 1077 skip!(_binding_0); 1078 } 1079 BinOp::Or(_binding_0) => { 1080 skip!(_binding_0); 1081 } 1082 BinOp::BitXor(_binding_0) => { 1083 skip!(_binding_0); 1084 } 1085 BinOp::BitAnd(_binding_0) => { 1086 skip!(_binding_0); 1087 } 1088 BinOp::BitOr(_binding_0) => { 1089 skip!(_binding_0); 1090 } 1091 BinOp::Shl(_binding_0) => { 1092 skip!(_binding_0); 1093 } 1094 BinOp::Shr(_binding_0) => { 1095 skip!(_binding_0); 1096 } 1097 BinOp::Eq(_binding_0) => { 1098 skip!(_binding_0); 1099 } 1100 BinOp::Lt(_binding_0) => { 1101 skip!(_binding_0); 1102 } 1103 BinOp::Le(_binding_0) => { 1104 skip!(_binding_0); 1105 } 1106 BinOp::Ne(_binding_0) => { 1107 skip!(_binding_0); 1108 } 1109 BinOp::Ge(_binding_0) => { 1110 skip!(_binding_0); 1111 } 1112 BinOp::Gt(_binding_0) => { 1113 skip!(_binding_0); 1114 } 1115 BinOp::AddAssign(_binding_0) => { 1116 skip!(_binding_0); 1117 } 1118 BinOp::SubAssign(_binding_0) => { 1119 skip!(_binding_0); 1120 } 1121 BinOp::MulAssign(_binding_0) => { 1122 skip!(_binding_0); 1123 } 1124 BinOp::DivAssign(_binding_0) => { 1125 skip!(_binding_0); 1126 } 1127 BinOp::RemAssign(_binding_0) => { 1128 skip!(_binding_0); 1129 } 1130 BinOp::BitXorAssign(_binding_0) => { 1131 skip!(_binding_0); 1132 } 1133 BinOp::BitAndAssign(_binding_0) => { 1134 skip!(_binding_0); 1135 } 1136 BinOp::BitOrAssign(_binding_0) => { 1137 skip!(_binding_0); 1138 } 1139 BinOp::ShlAssign(_binding_0) => { 1140 skip!(_binding_0); 1141 } 1142 BinOp::ShrAssign(_binding_0) => { 1143 skip!(_binding_0); 1144 } 1145 } 1146} 1147#[cfg(feature = "full")] 1148#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 1149pub fn visit_block_mut<V>(v: &mut V, node: &mut Block) 1150where 1151 V: VisitMut + ?Sized, 1152{ 1153 skip!(node.brace_token); 1154 for it in &mut node.stmts { 1155 v.visit_stmt_mut(it); 1156 } 1157} 1158#[cfg(any(feature = "derive", feature = "full"))] 1159#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 1160pub fn visit_bound_lifetimes_mut<V>(v: &mut V, node: &mut BoundLifetimes) 1161where 1162 V: VisitMut + ?Sized, 1163{ 1164 skip!(node.for_token); 1165 skip!(node.lt_token); 1166 for mut el in Punctuated::pairs_mut(&mut node.lifetimes) { 1167 let it = el.value_mut(); 1168 v.visit_generic_param_mut(it); 1169 } 1170 skip!(node.gt_token); 1171} 1172#[cfg(any(feature = "derive", feature = "full"))] 1173#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 1174pub fn visit_const_param_mut<V>(v: &mut V, node: &mut ConstParam) 1175where 1176 V: VisitMut + ?Sized, 1177{ 1178 for it in &mut node.attrs { 1179 v.visit_attribute_mut(it); 1180 } 1181 skip!(node.const_token); 1182 v.visit_ident_mut(&mut node.ident); 1183 skip!(node.colon_token); 1184 v.visit_type_mut(&mut node.ty); 1185 skip!(node.eq_token); 1186 if let Some(it) = &mut node.default { 1187 v.visit_expr_mut(it); 1188 } 1189} 1190#[cfg(any(feature = "derive", feature = "full"))] 1191#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 1192pub fn visit_constraint_mut<V>(v: &mut V, node: &mut Constraint) 1193where 1194 V: VisitMut + ?Sized, 1195{ 1196 v.visit_ident_mut(&mut node.ident); 1197 if let Some(it) = &mut node.generics { 1198 v.visit_angle_bracketed_generic_arguments_mut(it); 1199 } 1200 skip!(node.colon_token); 1201 for mut el in Punctuated::pairs_mut(&mut node.bounds) { 1202 let it = el.value_mut(); 1203 v.visit_type_param_bound_mut(it); 1204 } 1205} 1206#[cfg(feature = "derive")] 1207#[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))] 1208pub fn visit_data_mut<V>(v: &mut V, node: &mut Data) 1209where 1210 V: VisitMut + ?Sized, 1211{ 1212 match node { 1213 Data::Struct(_binding_0) => { 1214 v.visit_data_struct_mut(_binding_0); 1215 } 1216 Data::Enum(_binding_0) => { 1217 v.visit_data_enum_mut(_binding_0); 1218 } 1219 Data::Union(_binding_0) => { 1220 v.visit_data_union_mut(_binding_0); 1221 } 1222 } 1223} 1224#[cfg(feature = "derive")] 1225#[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))] 1226pub fn visit_data_enum_mut<V>(v: &mut V, node: &mut DataEnum) 1227where 1228 V: VisitMut + ?Sized, 1229{ 1230 skip!(node.enum_token); 1231 skip!(node.brace_token); 1232 for mut el in Punctuated::pairs_mut(&mut node.variants) { 1233 let it = el.value_mut(); 1234 v.visit_variant_mut(it); 1235 } 1236} 1237#[cfg(feature = "derive")] 1238#[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))] 1239pub fn visit_data_struct_mut<V>(v: &mut V, node: &mut DataStruct) 1240where 1241 V: VisitMut + ?Sized, 1242{ 1243 skip!(node.struct_token); 1244 v.visit_fields_mut(&mut node.fields); 1245 skip!(node.semi_token); 1246} 1247#[cfg(feature = "derive")] 1248#[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))] 1249pub fn visit_data_union_mut<V>(v: &mut V, node: &mut DataUnion) 1250where 1251 V: VisitMut + ?Sized, 1252{ 1253 skip!(node.union_token); 1254 v.visit_fields_named_mut(&mut node.fields); 1255} 1256#[cfg(feature = "derive")] 1257#[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))] 1258pub fn visit_derive_input_mut<V>(v: &mut V, node: &mut DeriveInput) 1259where 1260 V: VisitMut + ?Sized, 1261{ 1262 for it in &mut node.attrs { 1263 v.visit_attribute_mut(it); 1264 } 1265 v.visit_visibility_mut(&mut node.vis); 1266 v.visit_ident_mut(&mut node.ident); 1267 v.visit_generics_mut(&mut node.generics); 1268 v.visit_data_mut(&mut node.data); 1269} 1270#[cfg(any(feature = "derive", feature = "full"))] 1271#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 1272pub fn visit_expr_mut<V>(v: &mut V, node: &mut Expr) 1273where 1274 V: VisitMut + ?Sized, 1275{ 1276 match node { 1277 Expr::Array(_binding_0) => { 1278 full!(v.visit_expr_array_mut(_binding_0)); 1279 } 1280 Expr::Assign(_binding_0) => { 1281 full!(v.visit_expr_assign_mut(_binding_0)); 1282 } 1283 Expr::Async(_binding_0) => { 1284 full!(v.visit_expr_async_mut(_binding_0)); 1285 } 1286 Expr::Await(_binding_0) => { 1287 full!(v.visit_expr_await_mut(_binding_0)); 1288 } 1289 Expr::Binary(_binding_0) => { 1290 v.visit_expr_binary_mut(_binding_0); 1291 } 1292 Expr::Block(_binding_0) => { 1293 full!(v.visit_expr_block_mut(_binding_0)); 1294 } 1295 Expr::Break(_binding_0) => { 1296 full!(v.visit_expr_break_mut(_binding_0)); 1297 } 1298 Expr::Call(_binding_0) => { 1299 v.visit_expr_call_mut(_binding_0); 1300 } 1301 Expr::Cast(_binding_0) => { 1302 v.visit_expr_cast_mut(_binding_0); 1303 } 1304 Expr::Closure(_binding_0) => { 1305 full!(v.visit_expr_closure_mut(_binding_0)); 1306 } 1307 Expr::Const(_binding_0) => { 1308 full!(v.visit_expr_const_mut(_binding_0)); 1309 } 1310 Expr::Continue(_binding_0) => { 1311 full!(v.visit_expr_continue_mut(_binding_0)); 1312 } 1313 Expr::Field(_binding_0) => { 1314 v.visit_expr_field_mut(_binding_0); 1315 } 1316 Expr::ForLoop(_binding_0) => { 1317 full!(v.visit_expr_for_loop_mut(_binding_0)); 1318 } 1319 Expr::Group(_binding_0) => { 1320 v.visit_expr_group_mut(_binding_0); 1321 } 1322 Expr::If(_binding_0) => { 1323 full!(v.visit_expr_if_mut(_binding_0)); 1324 } 1325 Expr::Index(_binding_0) => { 1326 v.visit_expr_index_mut(_binding_0); 1327 } 1328 Expr::Infer(_binding_0) => { 1329 full!(v.visit_expr_infer_mut(_binding_0)); 1330 } 1331 Expr::Let(_binding_0) => { 1332 full!(v.visit_expr_let_mut(_binding_0)); 1333 } 1334 Expr::Lit(_binding_0) => { 1335 v.visit_expr_lit_mut(_binding_0); 1336 } 1337 Expr::Loop(_binding_0) => { 1338 full!(v.visit_expr_loop_mut(_binding_0)); 1339 } 1340 Expr::Macro(_binding_0) => { 1341 v.visit_expr_macro_mut(_binding_0); 1342 } 1343 Expr::Match(_binding_0) => { 1344 full!(v.visit_expr_match_mut(_binding_0)); 1345 } 1346 Expr::MethodCall(_binding_0) => { 1347 v.visit_expr_method_call_mut(_binding_0); 1348 } 1349 Expr::Paren(_binding_0) => { 1350 v.visit_expr_paren_mut(_binding_0); 1351 } 1352 Expr::Path(_binding_0) => { 1353 v.visit_expr_path_mut(_binding_0); 1354 } 1355 Expr::Range(_binding_0) => { 1356 full!(v.visit_expr_range_mut(_binding_0)); 1357 } 1358 Expr::Reference(_binding_0) => { 1359 v.visit_expr_reference_mut(_binding_0); 1360 } 1361 Expr::Repeat(_binding_0) => { 1362 full!(v.visit_expr_repeat_mut(_binding_0)); 1363 } 1364 Expr::Return(_binding_0) => { 1365 full!(v.visit_expr_return_mut(_binding_0)); 1366 } 1367 Expr::Struct(_binding_0) => { 1368 v.visit_expr_struct_mut(_binding_0); 1369 } 1370 Expr::Try(_binding_0) => { 1371 full!(v.visit_expr_try_mut(_binding_0)); 1372 } 1373 Expr::TryBlock(_binding_0) => { 1374 full!(v.visit_expr_try_block_mut(_binding_0)); 1375 } 1376 Expr::Tuple(_binding_0) => { 1377 full!(v.visit_expr_tuple_mut(_binding_0)); 1378 } 1379 Expr::Unary(_binding_0) => { 1380 v.visit_expr_unary_mut(_binding_0); 1381 } 1382 Expr::Unsafe(_binding_0) => { 1383 full!(v.visit_expr_unsafe_mut(_binding_0)); 1384 } 1385 Expr::Verbatim(_binding_0) => { 1386 skip!(_binding_0); 1387 } 1388 Expr::While(_binding_0) => { 1389 full!(v.visit_expr_while_mut(_binding_0)); 1390 } 1391 Expr::Yield(_binding_0) => { 1392 full!(v.visit_expr_yield_mut(_binding_0)); 1393 } 1394 } 1395} 1396#[cfg(feature = "full")] 1397#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 1398pub fn visit_expr_array_mut<V>(v: &mut V, node: &mut ExprArray) 1399where 1400 V: VisitMut + ?Sized, 1401{ 1402 for it in &mut node.attrs { 1403 v.visit_attribute_mut(it); 1404 } 1405 skip!(node.bracket_token); 1406 for mut el in Punctuated::pairs_mut(&mut node.elems) { 1407 let it = el.value_mut(); 1408 v.visit_expr_mut(it); 1409 } 1410} 1411#[cfg(feature = "full")] 1412#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 1413pub fn visit_expr_assign_mut<V>(v: &mut V, node: &mut ExprAssign) 1414where 1415 V: VisitMut + ?Sized, 1416{ 1417 for it in &mut node.attrs { 1418 v.visit_attribute_mut(it); 1419 } 1420 v.visit_expr_mut(&mut *node.left); 1421 skip!(node.eq_token); 1422 v.visit_expr_mut(&mut *node.right); 1423} 1424#[cfg(feature = "full")] 1425#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 1426pub fn visit_expr_async_mut<V>(v: &mut V, node: &mut ExprAsync) 1427where 1428 V: VisitMut + ?Sized, 1429{ 1430 for it in &mut node.attrs { 1431 v.visit_attribute_mut(it); 1432 } 1433 skip!(node.async_token); 1434 skip!(node.capture); 1435 v.visit_block_mut(&mut node.block); 1436} 1437#[cfg(feature = "full")] 1438#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 1439pub fn visit_expr_await_mut<V>(v: &mut V, node: &mut ExprAwait) 1440where 1441 V: VisitMut + ?Sized, 1442{ 1443 for it in &mut node.attrs { 1444 v.visit_attribute_mut(it); 1445 } 1446 v.visit_expr_mut(&mut *node.base); 1447 skip!(node.dot_token); 1448 skip!(node.await_token); 1449} 1450#[cfg(any(feature = "derive", feature = "full"))] 1451#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 1452pub fn visit_expr_binary_mut<V>(v: &mut V, node: &mut ExprBinary) 1453where 1454 V: VisitMut + ?Sized, 1455{ 1456 for it in &mut node.attrs { 1457 v.visit_attribute_mut(it); 1458 } 1459 v.visit_expr_mut(&mut *node.left); 1460 v.visit_bin_op_mut(&mut node.op); 1461 v.visit_expr_mut(&mut *node.right); 1462} 1463#[cfg(feature = "full")] 1464#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 1465pub fn visit_expr_block_mut<V>(v: &mut V, node: &mut ExprBlock) 1466where 1467 V: VisitMut + ?Sized, 1468{ 1469 for it in &mut node.attrs { 1470 v.visit_attribute_mut(it); 1471 } 1472 if let Some(it) = &mut node.label { 1473 v.visit_label_mut(it); 1474 } 1475 v.visit_block_mut(&mut node.block); 1476} 1477#[cfg(feature = "full")] 1478#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 1479pub fn visit_expr_break_mut<V>(v: &mut V, node: &mut ExprBreak) 1480where 1481 V: VisitMut + ?Sized, 1482{ 1483 for it in &mut node.attrs { 1484 v.visit_attribute_mut(it); 1485 } 1486 skip!(node.break_token); 1487 if let Some(it) = &mut node.label { 1488 v.visit_lifetime_mut(it); 1489 } 1490 if let Some(it) = &mut node.expr { 1491 v.visit_expr_mut(&mut **it); 1492 } 1493} 1494#[cfg(any(feature = "derive", feature = "full"))] 1495#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 1496pub fn visit_expr_call_mut<V>(v: &mut V, node: &mut ExprCall) 1497where 1498 V: VisitMut + ?Sized, 1499{ 1500 for it in &mut node.attrs { 1501 v.visit_attribute_mut(it); 1502 } 1503 v.visit_expr_mut(&mut *node.func); 1504 skip!(node.paren_token); 1505 for mut el in Punctuated::pairs_mut(&mut node.args) { 1506 let it = el.value_mut(); 1507 v.visit_expr_mut(it); 1508 } 1509} 1510#[cfg(any(feature = "derive", feature = "full"))] 1511#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 1512pub fn visit_expr_cast_mut<V>(v: &mut V, node: &mut ExprCast) 1513where 1514 V: VisitMut + ?Sized, 1515{ 1516 for it in &mut node.attrs { 1517 v.visit_attribute_mut(it); 1518 } 1519 v.visit_expr_mut(&mut *node.expr); 1520 skip!(node.as_token); 1521 v.visit_type_mut(&mut *node.ty); 1522} 1523#[cfg(feature = "full")] 1524#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 1525pub fn visit_expr_closure_mut<V>(v: &mut V, node: &mut ExprClosure) 1526where 1527 V: VisitMut + ?Sized, 1528{ 1529 for it in &mut node.attrs { 1530 v.visit_attribute_mut(it); 1531 } 1532 if let Some(it) = &mut node.lifetimes { 1533 v.visit_bound_lifetimes_mut(it); 1534 } 1535 skip!(node.constness); 1536 skip!(node.movability); 1537 skip!(node.asyncness); 1538 skip!(node.capture); 1539 skip!(node.or1_token); 1540 for mut el in Punctuated::pairs_mut(&mut node.inputs) { 1541 let it = el.value_mut(); 1542 v.visit_pat_mut(it); 1543 } 1544 skip!(node.or2_token); 1545 v.visit_return_type_mut(&mut node.output); 1546 v.visit_expr_mut(&mut *node.body); 1547} 1548#[cfg(feature = "full")] 1549#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 1550pub fn visit_expr_const_mut<V>(v: &mut V, node: &mut ExprConst) 1551where 1552 V: VisitMut + ?Sized, 1553{ 1554 for it in &mut node.attrs { 1555 v.visit_attribute_mut(it); 1556 } 1557 skip!(node.const_token); 1558 v.visit_block_mut(&mut node.block); 1559} 1560#[cfg(feature = "full")] 1561#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 1562pub fn visit_expr_continue_mut<V>(v: &mut V, node: &mut ExprContinue) 1563where 1564 V: VisitMut + ?Sized, 1565{ 1566 for it in &mut node.attrs { 1567 v.visit_attribute_mut(it); 1568 } 1569 skip!(node.continue_token); 1570 if let Some(it) = &mut node.label { 1571 v.visit_lifetime_mut(it); 1572 } 1573} 1574#[cfg(any(feature = "derive", feature = "full"))] 1575#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 1576pub fn visit_expr_field_mut<V>(v: &mut V, node: &mut ExprField) 1577where 1578 V: VisitMut + ?Sized, 1579{ 1580 for it in &mut node.attrs { 1581 v.visit_attribute_mut(it); 1582 } 1583 v.visit_expr_mut(&mut *node.base); 1584 skip!(node.dot_token); 1585 v.visit_member_mut(&mut node.member); 1586} 1587#[cfg(feature = "full")] 1588#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 1589pub fn visit_expr_for_loop_mut<V>(v: &mut V, node: &mut ExprForLoop) 1590where 1591 V: VisitMut + ?Sized, 1592{ 1593 for it in &mut node.attrs { 1594 v.visit_attribute_mut(it); 1595 } 1596 if let Some(it) = &mut node.label { 1597 v.visit_label_mut(it); 1598 } 1599 skip!(node.for_token); 1600 v.visit_pat_mut(&mut *node.pat); 1601 skip!(node.in_token); 1602 v.visit_expr_mut(&mut *node.expr); 1603 v.visit_block_mut(&mut node.body); 1604} 1605#[cfg(any(feature = "derive", feature = "full"))] 1606#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 1607pub fn visit_expr_group_mut<V>(v: &mut V, node: &mut ExprGroup) 1608where 1609 V: VisitMut + ?Sized, 1610{ 1611 for it in &mut node.attrs { 1612 v.visit_attribute_mut(it); 1613 } 1614 skip!(node.group_token); 1615 v.visit_expr_mut(&mut *node.expr); 1616} 1617#[cfg(feature = "full")] 1618#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 1619pub fn visit_expr_if_mut<V>(v: &mut V, node: &mut ExprIf) 1620where 1621 V: VisitMut + ?Sized, 1622{ 1623 for it in &mut node.attrs { 1624 v.visit_attribute_mut(it); 1625 } 1626 skip!(node.if_token); 1627 v.visit_expr_mut(&mut *node.cond); 1628 v.visit_block_mut(&mut node.then_branch); 1629 if let Some(it) = &mut node.else_branch { 1630 skip!((it).0); 1631 v.visit_expr_mut(&mut *(it).1); 1632 } 1633} 1634#[cfg(any(feature = "derive", feature = "full"))] 1635#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 1636pub fn visit_expr_index_mut<V>(v: &mut V, node: &mut ExprIndex) 1637where 1638 V: VisitMut + ?Sized, 1639{ 1640 for it in &mut node.attrs { 1641 v.visit_attribute_mut(it); 1642 } 1643 v.visit_expr_mut(&mut *node.expr); 1644 skip!(node.bracket_token); 1645 v.visit_expr_mut(&mut *node.index); 1646} 1647#[cfg(feature = "full")] 1648#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 1649pub fn visit_expr_infer_mut<V>(v: &mut V, node: &mut ExprInfer) 1650where 1651 V: VisitMut + ?Sized, 1652{ 1653 for it in &mut node.attrs { 1654 v.visit_attribute_mut(it); 1655 } 1656 skip!(node.underscore_token); 1657} 1658#[cfg(feature = "full")] 1659#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 1660pub fn visit_expr_let_mut<V>(v: &mut V, node: &mut ExprLet) 1661where 1662 V: VisitMut + ?Sized, 1663{ 1664 for it in &mut node.attrs { 1665 v.visit_attribute_mut(it); 1666 } 1667 skip!(node.let_token); 1668 v.visit_pat_mut(&mut *node.pat); 1669 skip!(node.eq_token); 1670 v.visit_expr_mut(&mut *node.expr); 1671} 1672#[cfg(any(feature = "derive", feature = "full"))] 1673#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 1674pub fn visit_expr_lit_mut<V>(v: &mut V, node: &mut ExprLit) 1675where 1676 V: VisitMut + ?Sized, 1677{ 1678 for it in &mut node.attrs { 1679 v.visit_attribute_mut(it); 1680 } 1681 v.visit_lit_mut(&mut node.lit); 1682} 1683#[cfg(feature = "full")] 1684#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 1685pub fn visit_expr_loop_mut<V>(v: &mut V, node: &mut ExprLoop) 1686where 1687 V: VisitMut + ?Sized, 1688{ 1689 for it in &mut node.attrs { 1690 v.visit_attribute_mut(it); 1691 } 1692 if let Some(it) = &mut node.label { 1693 v.visit_label_mut(it); 1694 } 1695 skip!(node.loop_token); 1696 v.visit_block_mut(&mut node.body); 1697} 1698#[cfg(any(feature = "derive", feature = "full"))] 1699#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 1700pub fn visit_expr_macro_mut<V>(v: &mut V, node: &mut ExprMacro) 1701where 1702 V: VisitMut + ?Sized, 1703{ 1704 for it in &mut node.attrs { 1705 v.visit_attribute_mut(it); 1706 } 1707 v.visit_macro_mut(&mut node.mac); 1708} 1709#[cfg(feature = "full")] 1710#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 1711pub fn visit_expr_match_mut<V>(v: &mut V, node: &mut ExprMatch) 1712where 1713 V: VisitMut + ?Sized, 1714{ 1715 for it in &mut node.attrs { 1716 v.visit_attribute_mut(it); 1717 } 1718 skip!(node.match_token); 1719 v.visit_expr_mut(&mut *node.expr); 1720 skip!(node.brace_token); 1721 for it in &mut node.arms { 1722 v.visit_arm_mut(it); 1723 } 1724} 1725#[cfg(any(feature = "derive", feature = "full"))] 1726#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 1727pub fn visit_expr_method_call_mut<V>(v: &mut V, node: &mut ExprMethodCall) 1728where 1729 V: VisitMut + ?Sized, 1730{ 1731 for it in &mut node.attrs { 1732 v.visit_attribute_mut(it); 1733 } 1734 v.visit_expr_mut(&mut *node.receiver); 1735 skip!(node.dot_token); 1736 v.visit_ident_mut(&mut node.method); 1737 if let Some(it) = &mut node.turbofish { 1738 v.visit_angle_bracketed_generic_arguments_mut(it); 1739 } 1740 skip!(node.paren_token); 1741 for mut el in Punctuated::pairs_mut(&mut node.args) { 1742 let it = el.value_mut(); 1743 v.visit_expr_mut(it); 1744 } 1745} 1746#[cfg(any(feature = "derive", feature = "full"))] 1747#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 1748pub fn visit_expr_paren_mut<V>(v: &mut V, node: &mut ExprParen) 1749where 1750 V: VisitMut + ?Sized, 1751{ 1752 for it in &mut node.attrs { 1753 v.visit_attribute_mut(it); 1754 } 1755 skip!(node.paren_token); 1756 v.visit_expr_mut(&mut *node.expr); 1757} 1758#[cfg(any(feature = "derive", feature = "full"))] 1759#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 1760pub fn visit_expr_path_mut<V>(v: &mut V, node: &mut ExprPath) 1761where 1762 V: VisitMut + ?Sized, 1763{ 1764 for it in &mut node.attrs { 1765 v.visit_attribute_mut(it); 1766 } 1767 if let Some(it) = &mut node.qself { 1768 v.visit_qself_mut(it); 1769 } 1770 v.visit_path_mut(&mut node.path); 1771} 1772#[cfg(feature = "full")] 1773#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 1774pub fn visit_expr_range_mut<V>(v: &mut V, node: &mut ExprRange) 1775where 1776 V: VisitMut + ?Sized, 1777{ 1778 for it in &mut node.attrs { 1779 v.visit_attribute_mut(it); 1780 } 1781 if let Some(it) = &mut node.start { 1782 v.visit_expr_mut(&mut **it); 1783 } 1784 v.visit_range_limits_mut(&mut node.limits); 1785 if let Some(it) = &mut node.end { 1786 v.visit_expr_mut(&mut **it); 1787 } 1788} 1789#[cfg(any(feature = "derive", feature = "full"))] 1790#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 1791pub fn visit_expr_reference_mut<V>(v: &mut V, node: &mut ExprReference) 1792where 1793 V: VisitMut + ?Sized, 1794{ 1795 for it in &mut node.attrs { 1796 v.visit_attribute_mut(it); 1797 } 1798 skip!(node.and_token); 1799 skip!(node.mutability); 1800 v.visit_expr_mut(&mut *node.expr); 1801} 1802#[cfg(feature = "full")] 1803#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 1804pub fn visit_expr_repeat_mut<V>(v: &mut V, node: &mut ExprRepeat) 1805where 1806 V: VisitMut + ?Sized, 1807{ 1808 for it in &mut node.attrs { 1809 v.visit_attribute_mut(it); 1810 } 1811 skip!(node.bracket_token); 1812 v.visit_expr_mut(&mut *node.expr); 1813 skip!(node.semi_token); 1814 v.visit_expr_mut(&mut *node.len); 1815} 1816#[cfg(feature = "full")] 1817#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 1818pub fn visit_expr_return_mut<V>(v: &mut V, node: &mut ExprReturn) 1819where 1820 V: VisitMut + ?Sized, 1821{ 1822 for it in &mut node.attrs { 1823 v.visit_attribute_mut(it); 1824 } 1825 skip!(node.return_token); 1826 if let Some(it) = &mut node.expr { 1827 v.visit_expr_mut(&mut **it); 1828 } 1829} 1830#[cfg(any(feature = "derive", feature = "full"))] 1831#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 1832pub fn visit_expr_struct_mut<V>(v: &mut V, node: &mut ExprStruct) 1833where 1834 V: VisitMut + ?Sized, 1835{ 1836 for it in &mut node.attrs { 1837 v.visit_attribute_mut(it); 1838 } 1839 if let Some(it) = &mut node.qself { 1840 v.visit_qself_mut(it); 1841 } 1842 v.visit_path_mut(&mut node.path); 1843 skip!(node.brace_token); 1844 for mut el in Punctuated::pairs_mut(&mut node.fields) { 1845 let it = el.value_mut(); 1846 v.visit_field_value_mut(it); 1847 } 1848 skip!(node.dot2_token); 1849 if let Some(it) = &mut node.rest { 1850 v.visit_expr_mut(&mut **it); 1851 } 1852} 1853#[cfg(feature = "full")] 1854#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 1855pub fn visit_expr_try_mut<V>(v: &mut V, node: &mut ExprTry) 1856where 1857 V: VisitMut + ?Sized, 1858{ 1859 for it in &mut node.attrs { 1860 v.visit_attribute_mut(it); 1861 } 1862 v.visit_expr_mut(&mut *node.expr); 1863 skip!(node.question_token); 1864} 1865#[cfg(feature = "full")] 1866#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 1867pub fn visit_expr_try_block_mut<V>(v: &mut V, node: &mut ExprTryBlock) 1868where 1869 V: VisitMut + ?Sized, 1870{ 1871 for it in &mut node.attrs { 1872 v.visit_attribute_mut(it); 1873 } 1874 skip!(node.try_token); 1875 v.visit_block_mut(&mut node.block); 1876} 1877#[cfg(feature = "full")] 1878#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 1879pub fn visit_expr_tuple_mut<V>(v: &mut V, node: &mut ExprTuple) 1880where 1881 V: VisitMut + ?Sized, 1882{ 1883 for it in &mut node.attrs { 1884 v.visit_attribute_mut(it); 1885 } 1886 skip!(node.paren_token); 1887 for mut el in Punctuated::pairs_mut(&mut node.elems) { 1888 let it = el.value_mut(); 1889 v.visit_expr_mut(it); 1890 } 1891} 1892#[cfg(any(feature = "derive", feature = "full"))] 1893#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 1894pub fn visit_expr_unary_mut<V>(v: &mut V, node: &mut ExprUnary) 1895where 1896 V: VisitMut + ?Sized, 1897{ 1898 for it in &mut node.attrs { 1899 v.visit_attribute_mut(it); 1900 } 1901 v.visit_un_op_mut(&mut node.op); 1902 v.visit_expr_mut(&mut *node.expr); 1903} 1904#[cfg(feature = "full")] 1905#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 1906pub fn visit_expr_unsafe_mut<V>(v: &mut V, node: &mut ExprUnsafe) 1907where 1908 V: VisitMut + ?Sized, 1909{ 1910 for it in &mut node.attrs { 1911 v.visit_attribute_mut(it); 1912 } 1913 skip!(node.unsafe_token); 1914 v.visit_block_mut(&mut node.block); 1915} 1916#[cfg(feature = "full")] 1917#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 1918pub fn visit_expr_while_mut<V>(v: &mut V, node: &mut ExprWhile) 1919where 1920 V: VisitMut + ?Sized, 1921{ 1922 for it in &mut node.attrs { 1923 v.visit_attribute_mut(it); 1924 } 1925 if let Some(it) = &mut node.label { 1926 v.visit_label_mut(it); 1927 } 1928 skip!(node.while_token); 1929 v.visit_expr_mut(&mut *node.cond); 1930 v.visit_block_mut(&mut node.body); 1931} 1932#[cfg(feature = "full")] 1933#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 1934pub fn visit_expr_yield_mut<V>(v: &mut V, node: &mut ExprYield) 1935where 1936 V: VisitMut + ?Sized, 1937{ 1938 for it in &mut node.attrs { 1939 v.visit_attribute_mut(it); 1940 } 1941 skip!(node.yield_token); 1942 if let Some(it) = &mut node.expr { 1943 v.visit_expr_mut(&mut **it); 1944 } 1945} 1946#[cfg(any(feature = "derive", feature = "full"))] 1947#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 1948pub fn visit_field_mut<V>(v: &mut V, node: &mut Field) 1949where 1950 V: VisitMut + ?Sized, 1951{ 1952 for it in &mut node.attrs { 1953 v.visit_attribute_mut(it); 1954 } 1955 v.visit_visibility_mut(&mut node.vis); 1956 v.visit_field_mutability_mut(&mut node.mutability); 1957 if let Some(it) = &mut node.ident { 1958 v.visit_ident_mut(it); 1959 } 1960 skip!(node.colon_token); 1961 v.visit_type_mut(&mut node.ty); 1962} 1963#[cfg(any(feature = "derive", feature = "full"))] 1964#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 1965pub fn visit_field_mutability_mut<V>(v: &mut V, node: &mut FieldMutability) 1966where 1967 V: VisitMut + ?Sized, 1968{ 1969 match node { 1970 FieldMutability::None => {} 1971 } 1972} 1973#[cfg(feature = "full")] 1974#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 1975pub fn visit_field_pat_mut<V>(v: &mut V, node: &mut FieldPat) 1976where 1977 V: VisitMut + ?Sized, 1978{ 1979 for it in &mut node.attrs { 1980 v.visit_attribute_mut(it); 1981 } 1982 v.visit_member_mut(&mut node.member); 1983 skip!(node.colon_token); 1984 v.visit_pat_mut(&mut *node.pat); 1985} 1986#[cfg(any(feature = "derive", feature = "full"))] 1987#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 1988pub fn visit_field_value_mut<V>(v: &mut V, node: &mut FieldValue) 1989where 1990 V: VisitMut + ?Sized, 1991{ 1992 for it in &mut node.attrs { 1993 v.visit_attribute_mut(it); 1994 } 1995 v.visit_member_mut(&mut node.member); 1996 skip!(node.colon_token); 1997 v.visit_expr_mut(&mut node.expr); 1998} 1999#[cfg(any(feature = "derive", feature = "full"))] 2000#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 2001pub fn visit_fields_mut<V>(v: &mut V, node: &mut Fields) 2002where 2003 V: VisitMut + ?Sized, 2004{ 2005 match node { 2006 Fields::Named(_binding_0) => { 2007 v.visit_fields_named_mut(_binding_0); 2008 } 2009 Fields::Unnamed(_binding_0) => { 2010 v.visit_fields_unnamed_mut(_binding_0); 2011 } 2012 Fields::Unit => {} 2013 } 2014} 2015#[cfg(any(feature = "derive", feature = "full"))] 2016#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 2017pub fn visit_fields_named_mut<V>(v: &mut V, node: &mut FieldsNamed) 2018where 2019 V: VisitMut + ?Sized, 2020{ 2021 skip!(node.brace_token); 2022 for mut el in Punctuated::pairs_mut(&mut node.named) { 2023 let it = el.value_mut(); 2024 v.visit_field_mut(it); 2025 } 2026} 2027#[cfg(any(feature = "derive", feature = "full"))] 2028#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 2029pub fn visit_fields_unnamed_mut<V>(v: &mut V, node: &mut FieldsUnnamed) 2030where 2031 V: VisitMut + ?Sized, 2032{ 2033 skip!(node.paren_token); 2034 for mut el in Punctuated::pairs_mut(&mut node.unnamed) { 2035 let it = el.value_mut(); 2036 v.visit_field_mut(it); 2037 } 2038} 2039#[cfg(feature = "full")] 2040#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 2041pub fn visit_file_mut<V>(v: &mut V, node: &mut File) 2042where 2043 V: VisitMut + ?Sized, 2044{ 2045 skip!(node.shebang); 2046 for it in &mut node.attrs { 2047 v.visit_attribute_mut(it); 2048 } 2049 for it in &mut node.items { 2050 v.visit_item_mut(it); 2051 } 2052} 2053#[cfg(feature = "full")] 2054#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 2055pub fn visit_fn_arg_mut<V>(v: &mut V, node: &mut FnArg) 2056where 2057 V: VisitMut + ?Sized, 2058{ 2059 match node { 2060 FnArg::Receiver(_binding_0) => { 2061 v.visit_receiver_mut(_binding_0); 2062 } 2063 FnArg::Typed(_binding_0) => { 2064 v.visit_pat_type_mut(_binding_0); 2065 } 2066 } 2067} 2068#[cfg(feature = "full")] 2069#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 2070pub fn visit_foreign_item_mut<V>(v: &mut V, node: &mut ForeignItem) 2071where 2072 V: VisitMut + ?Sized, 2073{ 2074 match node { 2075 ForeignItem::Fn(_binding_0) => { 2076 v.visit_foreign_item_fn_mut(_binding_0); 2077 } 2078 ForeignItem::Static(_binding_0) => { 2079 v.visit_foreign_item_static_mut(_binding_0); 2080 } 2081 ForeignItem::Type(_binding_0) => { 2082 v.visit_foreign_item_type_mut(_binding_0); 2083 } 2084 ForeignItem::Macro(_binding_0) => { 2085 v.visit_foreign_item_macro_mut(_binding_0); 2086 } 2087 ForeignItem::Verbatim(_binding_0) => { 2088 skip!(_binding_0); 2089 } 2090 } 2091} 2092#[cfg(feature = "full")] 2093#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 2094pub fn visit_foreign_item_fn_mut<V>(v: &mut V, node: &mut ForeignItemFn) 2095where 2096 V: VisitMut + ?Sized, 2097{ 2098 for it in &mut node.attrs { 2099 v.visit_attribute_mut(it); 2100 } 2101 v.visit_visibility_mut(&mut node.vis); 2102 v.visit_signature_mut(&mut node.sig); 2103 skip!(node.semi_token); 2104} 2105#[cfg(feature = "full")] 2106#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 2107pub fn visit_foreign_item_macro_mut<V>(v: &mut V, node: &mut ForeignItemMacro) 2108where 2109 V: VisitMut + ?Sized, 2110{ 2111 for it in &mut node.attrs { 2112 v.visit_attribute_mut(it); 2113 } 2114 v.visit_macro_mut(&mut node.mac); 2115 skip!(node.semi_token); 2116} 2117#[cfg(feature = "full")] 2118#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 2119pub fn visit_foreign_item_static_mut<V>(v: &mut V, node: &mut ForeignItemStatic) 2120where 2121 V: VisitMut + ?Sized, 2122{ 2123 for it in &mut node.attrs { 2124 v.visit_attribute_mut(it); 2125 } 2126 v.visit_visibility_mut(&mut node.vis); 2127 skip!(node.static_token); 2128 v.visit_static_mutability_mut(&mut node.mutability); 2129 v.visit_ident_mut(&mut node.ident); 2130 skip!(node.colon_token); 2131 v.visit_type_mut(&mut *node.ty); 2132 skip!(node.semi_token); 2133} 2134#[cfg(feature = "full")] 2135#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 2136pub fn visit_foreign_item_type_mut<V>(v: &mut V, node: &mut ForeignItemType) 2137where 2138 V: VisitMut + ?Sized, 2139{ 2140 for it in &mut node.attrs { 2141 v.visit_attribute_mut(it); 2142 } 2143 v.visit_visibility_mut(&mut node.vis); 2144 skip!(node.type_token); 2145 v.visit_ident_mut(&mut node.ident); 2146 v.visit_generics_mut(&mut node.generics); 2147 skip!(node.semi_token); 2148} 2149#[cfg(any(feature = "derive", feature = "full"))] 2150#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 2151pub fn visit_generic_argument_mut<V>(v: &mut V, node: &mut GenericArgument) 2152where 2153 V: VisitMut + ?Sized, 2154{ 2155 match node { 2156 GenericArgument::Lifetime(_binding_0) => { 2157 v.visit_lifetime_mut(_binding_0); 2158 } 2159 GenericArgument::Type(_binding_0) => { 2160 v.visit_type_mut(_binding_0); 2161 } 2162 GenericArgument::Const(_binding_0) => { 2163 v.visit_expr_mut(_binding_0); 2164 } 2165 GenericArgument::AssocType(_binding_0) => { 2166 v.visit_assoc_type_mut(_binding_0); 2167 } 2168 GenericArgument::AssocConst(_binding_0) => { 2169 v.visit_assoc_const_mut(_binding_0); 2170 } 2171 GenericArgument::Constraint(_binding_0) => { 2172 v.visit_constraint_mut(_binding_0); 2173 } 2174 } 2175} 2176#[cfg(any(feature = "derive", feature = "full"))] 2177#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 2178pub fn visit_generic_param_mut<V>(v: &mut V, node: &mut GenericParam) 2179where 2180 V: VisitMut + ?Sized, 2181{ 2182 match node { 2183 GenericParam::Lifetime(_binding_0) => { 2184 v.visit_lifetime_param_mut(_binding_0); 2185 } 2186 GenericParam::Type(_binding_0) => { 2187 v.visit_type_param_mut(_binding_0); 2188 } 2189 GenericParam::Const(_binding_0) => { 2190 v.visit_const_param_mut(_binding_0); 2191 } 2192 } 2193} 2194#[cfg(any(feature = "derive", feature = "full"))] 2195#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 2196pub fn visit_generics_mut<V>(v: &mut V, node: &mut Generics) 2197where 2198 V: VisitMut + ?Sized, 2199{ 2200 skip!(node.lt_token); 2201 for mut el in Punctuated::pairs_mut(&mut node.params) { 2202 let it = el.value_mut(); 2203 v.visit_generic_param_mut(it); 2204 } 2205 skip!(node.gt_token); 2206 if let Some(it) = &mut node.where_clause { 2207 v.visit_where_clause_mut(it); 2208 } 2209} 2210pub fn visit_ident_mut<V>(v: &mut V, node: &mut Ident) 2211where 2212 V: VisitMut + ?Sized, 2213{ 2214 let mut span = node.span(); 2215 v.visit_span_mut(&mut span); 2216 node.set_span(span); 2217} 2218#[cfg(feature = "full")] 2219#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 2220pub fn visit_impl_item_mut<V>(v: &mut V, node: &mut ImplItem) 2221where 2222 V: VisitMut + ?Sized, 2223{ 2224 match node { 2225 ImplItem::Const(_binding_0) => { 2226 v.visit_impl_item_const_mut(_binding_0); 2227 } 2228 ImplItem::Fn(_binding_0) => { 2229 v.visit_impl_item_fn_mut(_binding_0); 2230 } 2231 ImplItem::Type(_binding_0) => { 2232 v.visit_impl_item_type_mut(_binding_0); 2233 } 2234 ImplItem::Macro(_binding_0) => { 2235 v.visit_impl_item_macro_mut(_binding_0); 2236 } 2237 ImplItem::Verbatim(_binding_0) => { 2238 skip!(_binding_0); 2239 } 2240 } 2241} 2242#[cfg(feature = "full")] 2243#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 2244pub fn visit_impl_item_const_mut<V>(v: &mut V, node: &mut ImplItemConst) 2245where 2246 V: VisitMut + ?Sized, 2247{ 2248 for it in &mut node.attrs { 2249 v.visit_attribute_mut(it); 2250 } 2251 v.visit_visibility_mut(&mut node.vis); 2252 skip!(node.defaultness); 2253 skip!(node.const_token); 2254 v.visit_ident_mut(&mut node.ident); 2255 v.visit_generics_mut(&mut node.generics); 2256 skip!(node.colon_token); 2257 v.visit_type_mut(&mut node.ty); 2258 skip!(node.eq_token); 2259 v.visit_expr_mut(&mut node.expr); 2260 skip!(node.semi_token); 2261} 2262#[cfg(feature = "full")] 2263#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 2264pub fn visit_impl_item_fn_mut<V>(v: &mut V, node: &mut ImplItemFn) 2265where 2266 V: VisitMut + ?Sized, 2267{ 2268 for it in &mut node.attrs { 2269 v.visit_attribute_mut(it); 2270 } 2271 v.visit_visibility_mut(&mut node.vis); 2272 skip!(node.defaultness); 2273 v.visit_signature_mut(&mut node.sig); 2274 v.visit_block_mut(&mut node.block); 2275} 2276#[cfg(feature = "full")] 2277#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 2278pub fn visit_impl_item_macro_mut<V>(v: &mut V, node: &mut ImplItemMacro) 2279where 2280 V: VisitMut + ?Sized, 2281{ 2282 for it in &mut node.attrs { 2283 v.visit_attribute_mut(it); 2284 } 2285 v.visit_macro_mut(&mut node.mac); 2286 skip!(node.semi_token); 2287} 2288#[cfg(feature = "full")] 2289#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 2290pub fn visit_impl_item_type_mut<V>(v: &mut V, node: &mut ImplItemType) 2291where 2292 V: VisitMut + ?Sized, 2293{ 2294 for it in &mut node.attrs { 2295 v.visit_attribute_mut(it); 2296 } 2297 v.visit_visibility_mut(&mut node.vis); 2298 skip!(node.defaultness); 2299 skip!(node.type_token); 2300 v.visit_ident_mut(&mut node.ident); 2301 v.visit_generics_mut(&mut node.generics); 2302 skip!(node.eq_token); 2303 v.visit_type_mut(&mut node.ty); 2304 skip!(node.semi_token); 2305} 2306#[cfg(feature = "full")] 2307#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 2308pub fn visit_impl_restriction_mut<V>(v: &mut V, node: &mut ImplRestriction) 2309where 2310 V: VisitMut + ?Sized, 2311{ 2312 match *node {} 2313} 2314#[cfg(any(feature = "derive", feature = "full"))] 2315#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 2316pub fn visit_index_mut<V>(v: &mut V, node: &mut Index) 2317where 2318 V: VisitMut + ?Sized, 2319{ 2320 skip!(node.index); 2321 v.visit_span_mut(&mut node.span); 2322} 2323#[cfg(feature = "full")] 2324#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 2325pub fn visit_item_mut<V>(v: &mut V, node: &mut Item) 2326where 2327 V: VisitMut + ?Sized, 2328{ 2329 match node { 2330 Item::Const(_binding_0) => { 2331 v.visit_item_const_mut(_binding_0); 2332 } 2333 Item::Enum(_binding_0) => { 2334 v.visit_item_enum_mut(_binding_0); 2335 } 2336 Item::ExternCrate(_binding_0) => { 2337 v.visit_item_extern_crate_mut(_binding_0); 2338 } 2339 Item::Fn(_binding_0) => { 2340 v.visit_item_fn_mut(_binding_0); 2341 } 2342 Item::ForeignMod(_binding_0) => { 2343 v.visit_item_foreign_mod_mut(_binding_0); 2344 } 2345 Item::Impl(_binding_0) => { 2346 v.visit_item_impl_mut(_binding_0); 2347 } 2348 Item::Macro(_binding_0) => { 2349 v.visit_item_macro_mut(_binding_0); 2350 } 2351 Item::Mod(_binding_0) => { 2352 v.visit_item_mod_mut(_binding_0); 2353 } 2354 Item::Static(_binding_0) => { 2355 v.visit_item_static_mut(_binding_0); 2356 } 2357 Item::Struct(_binding_0) => { 2358 v.visit_item_struct_mut(_binding_0); 2359 } 2360 Item::Trait(_binding_0) => { 2361 v.visit_item_trait_mut(_binding_0); 2362 } 2363 Item::TraitAlias(_binding_0) => { 2364 v.visit_item_trait_alias_mut(_binding_0); 2365 } 2366 Item::Type(_binding_0) => { 2367 v.visit_item_type_mut(_binding_0); 2368 } 2369 Item::Union(_binding_0) => { 2370 v.visit_item_union_mut(_binding_0); 2371 } 2372 Item::Use(_binding_0) => { 2373 v.visit_item_use_mut(_binding_0); 2374 } 2375 Item::Verbatim(_binding_0) => { 2376 skip!(_binding_0); 2377 } 2378 } 2379} 2380#[cfg(feature = "full")] 2381#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 2382pub fn visit_item_const_mut<V>(v: &mut V, node: &mut ItemConst) 2383where 2384 V: VisitMut + ?Sized, 2385{ 2386 for it in &mut node.attrs { 2387 v.visit_attribute_mut(it); 2388 } 2389 v.visit_visibility_mut(&mut node.vis); 2390 skip!(node.const_token); 2391 v.visit_ident_mut(&mut node.ident); 2392 v.visit_generics_mut(&mut node.generics); 2393 skip!(node.colon_token); 2394 v.visit_type_mut(&mut *node.ty); 2395 skip!(node.eq_token); 2396 v.visit_expr_mut(&mut *node.expr); 2397 skip!(node.semi_token); 2398} 2399#[cfg(feature = "full")] 2400#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 2401pub fn visit_item_enum_mut<V>(v: &mut V, node: &mut ItemEnum) 2402where 2403 V: VisitMut + ?Sized, 2404{ 2405 for it in &mut node.attrs { 2406 v.visit_attribute_mut(it); 2407 } 2408 v.visit_visibility_mut(&mut node.vis); 2409 skip!(node.enum_token); 2410 v.visit_ident_mut(&mut node.ident); 2411 v.visit_generics_mut(&mut node.generics); 2412 skip!(node.brace_token); 2413 for mut el in Punctuated::pairs_mut(&mut node.variants) { 2414 let it = el.value_mut(); 2415 v.visit_variant_mut(it); 2416 } 2417} 2418#[cfg(feature = "full")] 2419#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 2420pub fn visit_item_extern_crate_mut<V>(v: &mut V, node: &mut ItemExternCrate) 2421where 2422 V: VisitMut + ?Sized, 2423{ 2424 for it in &mut node.attrs { 2425 v.visit_attribute_mut(it); 2426 } 2427 v.visit_visibility_mut(&mut node.vis); 2428 skip!(node.extern_token); 2429 skip!(node.crate_token); 2430 v.visit_ident_mut(&mut node.ident); 2431 if let Some(it) = &mut node.rename { 2432 skip!((it).0); 2433 v.visit_ident_mut(&mut (it).1); 2434 } 2435 skip!(node.semi_token); 2436} 2437#[cfg(feature = "full")] 2438#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 2439pub fn visit_item_fn_mut<V>(v: &mut V, node: &mut ItemFn) 2440where 2441 V: VisitMut + ?Sized, 2442{ 2443 for it in &mut node.attrs { 2444 v.visit_attribute_mut(it); 2445 } 2446 v.visit_visibility_mut(&mut node.vis); 2447 v.visit_signature_mut(&mut node.sig); 2448 v.visit_block_mut(&mut *node.block); 2449} 2450#[cfg(feature = "full")] 2451#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 2452pub fn visit_item_foreign_mod_mut<V>(v: &mut V, node: &mut ItemForeignMod) 2453where 2454 V: VisitMut + ?Sized, 2455{ 2456 for it in &mut node.attrs { 2457 v.visit_attribute_mut(it); 2458 } 2459 skip!(node.unsafety); 2460 v.visit_abi_mut(&mut node.abi); 2461 skip!(node.brace_token); 2462 for it in &mut node.items { 2463 v.visit_foreign_item_mut(it); 2464 } 2465} 2466#[cfg(feature = "full")] 2467#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 2468pub fn visit_item_impl_mut<V>(v: &mut V, node: &mut ItemImpl) 2469where 2470 V: VisitMut + ?Sized, 2471{ 2472 for it in &mut node.attrs { 2473 v.visit_attribute_mut(it); 2474 } 2475 skip!(node.defaultness); 2476 skip!(node.unsafety); 2477 skip!(node.impl_token); 2478 v.visit_generics_mut(&mut node.generics); 2479 if let Some(it) = &mut node.trait_ { 2480 skip!((it).0); 2481 v.visit_path_mut(&mut (it).1); 2482 skip!((it).2); 2483 } 2484 v.visit_type_mut(&mut *node.self_ty); 2485 skip!(node.brace_token); 2486 for it in &mut node.items { 2487 v.visit_impl_item_mut(it); 2488 } 2489} 2490#[cfg(feature = "full")] 2491#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 2492pub fn visit_item_macro_mut<V>(v: &mut V, node: &mut ItemMacro) 2493where 2494 V: VisitMut + ?Sized, 2495{ 2496 for it in &mut node.attrs { 2497 v.visit_attribute_mut(it); 2498 } 2499 if let Some(it) = &mut node.ident { 2500 v.visit_ident_mut(it); 2501 } 2502 v.visit_macro_mut(&mut node.mac); 2503 skip!(node.semi_token); 2504} 2505#[cfg(feature = "full")] 2506#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 2507pub fn visit_item_mod_mut<V>(v: &mut V, node: &mut ItemMod) 2508where 2509 V: VisitMut + ?Sized, 2510{ 2511 for it in &mut node.attrs { 2512 v.visit_attribute_mut(it); 2513 } 2514 v.visit_visibility_mut(&mut node.vis); 2515 skip!(node.unsafety); 2516 skip!(node.mod_token); 2517 v.visit_ident_mut(&mut node.ident); 2518 if let Some(it) = &mut node.content { 2519 skip!((it).0); 2520 for it in &mut (it).1 { 2521 v.visit_item_mut(it); 2522 } 2523 } 2524 skip!(node.semi); 2525} 2526#[cfg(feature = "full")] 2527#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 2528pub fn visit_item_static_mut<V>(v: &mut V, node: &mut ItemStatic) 2529where 2530 V: VisitMut + ?Sized, 2531{ 2532 for it in &mut node.attrs { 2533 v.visit_attribute_mut(it); 2534 } 2535 v.visit_visibility_mut(&mut node.vis); 2536 skip!(node.static_token); 2537 v.visit_static_mutability_mut(&mut node.mutability); 2538 v.visit_ident_mut(&mut node.ident); 2539 skip!(node.colon_token); 2540 v.visit_type_mut(&mut *node.ty); 2541 skip!(node.eq_token); 2542 v.visit_expr_mut(&mut *node.expr); 2543 skip!(node.semi_token); 2544} 2545#[cfg(feature = "full")] 2546#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 2547pub fn visit_item_struct_mut<V>(v: &mut V, node: &mut ItemStruct) 2548where 2549 V: VisitMut + ?Sized, 2550{ 2551 for it in &mut node.attrs { 2552 v.visit_attribute_mut(it); 2553 } 2554 v.visit_visibility_mut(&mut node.vis); 2555 skip!(node.struct_token); 2556 v.visit_ident_mut(&mut node.ident); 2557 v.visit_generics_mut(&mut node.generics); 2558 v.visit_fields_mut(&mut node.fields); 2559 skip!(node.semi_token); 2560} 2561#[cfg(feature = "full")] 2562#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 2563pub fn visit_item_trait_mut<V>(v: &mut V, node: &mut ItemTrait) 2564where 2565 V: VisitMut + ?Sized, 2566{ 2567 for it in &mut node.attrs { 2568 v.visit_attribute_mut(it); 2569 } 2570 v.visit_visibility_mut(&mut node.vis); 2571 skip!(node.unsafety); 2572 skip!(node.auto_token); 2573 if let Some(it) = &mut node.restriction { 2574 v.visit_impl_restriction_mut(it); 2575 } 2576 skip!(node.trait_token); 2577 v.visit_ident_mut(&mut node.ident); 2578 v.visit_generics_mut(&mut node.generics); 2579 skip!(node.colon_token); 2580 for mut el in Punctuated::pairs_mut(&mut node.supertraits) { 2581 let it = el.value_mut(); 2582 v.visit_type_param_bound_mut(it); 2583 } 2584 skip!(node.brace_token); 2585 for it in &mut node.items { 2586 v.visit_trait_item_mut(it); 2587 } 2588} 2589#[cfg(feature = "full")] 2590#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 2591pub fn visit_item_trait_alias_mut<V>(v: &mut V, node: &mut ItemTraitAlias) 2592where 2593 V: VisitMut + ?Sized, 2594{ 2595 for it in &mut node.attrs { 2596 v.visit_attribute_mut(it); 2597 } 2598 v.visit_visibility_mut(&mut node.vis); 2599 skip!(node.trait_token); 2600 v.visit_ident_mut(&mut node.ident); 2601 v.visit_generics_mut(&mut node.generics); 2602 skip!(node.eq_token); 2603 for mut el in Punctuated::pairs_mut(&mut node.bounds) { 2604 let it = el.value_mut(); 2605 v.visit_type_param_bound_mut(it); 2606 } 2607 skip!(node.semi_token); 2608} 2609#[cfg(feature = "full")] 2610#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 2611pub fn visit_item_type_mut<V>(v: &mut V, node: &mut ItemType) 2612where 2613 V: VisitMut + ?Sized, 2614{ 2615 for it in &mut node.attrs { 2616 v.visit_attribute_mut(it); 2617 } 2618 v.visit_visibility_mut(&mut node.vis); 2619 skip!(node.type_token); 2620 v.visit_ident_mut(&mut node.ident); 2621 v.visit_generics_mut(&mut node.generics); 2622 skip!(node.eq_token); 2623 v.visit_type_mut(&mut *node.ty); 2624 skip!(node.semi_token); 2625} 2626#[cfg(feature = "full")] 2627#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 2628pub fn visit_item_union_mut<V>(v: &mut V, node: &mut ItemUnion) 2629where 2630 V: VisitMut + ?Sized, 2631{ 2632 for it in &mut node.attrs { 2633 v.visit_attribute_mut(it); 2634 } 2635 v.visit_visibility_mut(&mut node.vis); 2636 skip!(node.union_token); 2637 v.visit_ident_mut(&mut node.ident); 2638 v.visit_generics_mut(&mut node.generics); 2639 v.visit_fields_named_mut(&mut node.fields); 2640} 2641#[cfg(feature = "full")] 2642#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 2643pub fn visit_item_use_mut<V>(v: &mut V, node: &mut ItemUse) 2644where 2645 V: VisitMut + ?Sized, 2646{ 2647 for it in &mut node.attrs { 2648 v.visit_attribute_mut(it); 2649 } 2650 v.visit_visibility_mut(&mut node.vis); 2651 skip!(node.use_token); 2652 skip!(node.leading_colon); 2653 v.visit_use_tree_mut(&mut node.tree); 2654 skip!(node.semi_token); 2655} 2656#[cfg(feature = "full")] 2657#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 2658pub fn visit_label_mut<V>(v: &mut V, node: &mut Label) 2659where 2660 V: VisitMut + ?Sized, 2661{ 2662 v.visit_lifetime_mut(&mut node.name); 2663 skip!(node.colon_token); 2664} 2665pub fn visit_lifetime_mut<V>(v: &mut V, node: &mut Lifetime) 2666where 2667 V: VisitMut + ?Sized, 2668{ 2669 v.visit_span_mut(&mut node.apostrophe); 2670 v.visit_ident_mut(&mut node.ident); 2671} 2672#[cfg(any(feature = "derive", feature = "full"))] 2673#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 2674pub fn visit_lifetime_param_mut<V>(v: &mut V, node: &mut LifetimeParam) 2675where 2676 V: VisitMut + ?Sized, 2677{ 2678 for it in &mut node.attrs { 2679 v.visit_attribute_mut(it); 2680 } 2681 v.visit_lifetime_mut(&mut node.lifetime); 2682 skip!(node.colon_token); 2683 for mut el in Punctuated::pairs_mut(&mut node.bounds) { 2684 let it = el.value_mut(); 2685 v.visit_lifetime_mut(it); 2686 } 2687} 2688pub fn visit_lit_mut<V>(v: &mut V, node: &mut Lit) 2689where 2690 V: VisitMut + ?Sized, 2691{ 2692 match node { 2693 Lit::Str(_binding_0) => { 2694 v.visit_lit_str_mut(_binding_0); 2695 } 2696 Lit::ByteStr(_binding_0) => { 2697 v.visit_lit_byte_str_mut(_binding_0); 2698 } 2699 Lit::Byte(_binding_0) => { 2700 v.visit_lit_byte_mut(_binding_0); 2701 } 2702 Lit::Char(_binding_0) => { 2703 v.visit_lit_char_mut(_binding_0); 2704 } 2705 Lit::Int(_binding_0) => { 2706 v.visit_lit_int_mut(_binding_0); 2707 } 2708 Lit::Float(_binding_0) => { 2709 v.visit_lit_float_mut(_binding_0); 2710 } 2711 Lit::Bool(_binding_0) => { 2712 v.visit_lit_bool_mut(_binding_0); 2713 } 2714 Lit::Verbatim(_binding_0) => { 2715 skip!(_binding_0); 2716 } 2717 } 2718} 2719pub fn visit_lit_bool_mut<V>(v: &mut V, node: &mut LitBool) 2720where 2721 V: VisitMut + ?Sized, 2722{ 2723 skip!(node.value); 2724 v.visit_span_mut(&mut node.span); 2725} 2726pub fn visit_lit_byte_mut<V>(v: &mut V, node: &mut LitByte) 2727where 2728 V: VisitMut + ?Sized, 2729{} 2730pub fn visit_lit_byte_str_mut<V>(v: &mut V, node: &mut LitByteStr) 2731where 2732 V: VisitMut + ?Sized, 2733{} 2734pub fn visit_lit_char_mut<V>(v: &mut V, node: &mut LitChar) 2735where 2736 V: VisitMut + ?Sized, 2737{} 2738pub fn visit_lit_float_mut<V>(v: &mut V, node: &mut LitFloat) 2739where 2740 V: VisitMut + ?Sized, 2741{} 2742pub fn visit_lit_int_mut<V>(v: &mut V, node: &mut LitInt) 2743where 2744 V: VisitMut + ?Sized, 2745{} 2746pub fn visit_lit_str_mut<V>(v: &mut V, node: &mut LitStr) 2747where 2748 V: VisitMut + ?Sized, 2749{} 2750#[cfg(feature = "full")] 2751#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 2752pub fn visit_local_mut<V>(v: &mut V, node: &mut Local) 2753where 2754 V: VisitMut + ?Sized, 2755{ 2756 for it in &mut node.attrs { 2757 v.visit_attribute_mut(it); 2758 } 2759 skip!(node.let_token); 2760 v.visit_pat_mut(&mut node.pat); 2761 if let Some(it) = &mut node.init { 2762 v.visit_local_init_mut(it); 2763 } 2764 skip!(node.semi_token); 2765} 2766#[cfg(feature = "full")] 2767#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 2768pub fn visit_local_init_mut<V>(v: &mut V, node: &mut LocalInit) 2769where 2770 V: VisitMut + ?Sized, 2771{ 2772 skip!(node.eq_token); 2773 v.visit_expr_mut(&mut *node.expr); 2774 if let Some(it) = &mut node.diverge { 2775 skip!((it).0); 2776 v.visit_expr_mut(&mut *(it).1); 2777 } 2778} 2779#[cfg(any(feature = "derive", feature = "full"))] 2780#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 2781pub fn visit_macro_mut<V>(v: &mut V, node: &mut Macro) 2782where 2783 V: VisitMut + ?Sized, 2784{ 2785 v.visit_path_mut(&mut node.path); 2786 skip!(node.bang_token); 2787 v.visit_macro_delimiter_mut(&mut node.delimiter); 2788 skip!(node.tokens); 2789} 2790#[cfg(any(feature = "derive", feature = "full"))] 2791#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 2792pub fn visit_macro_delimiter_mut<V>(v: &mut V, node: &mut MacroDelimiter) 2793where 2794 V: VisitMut + ?Sized, 2795{ 2796 match node { 2797 MacroDelimiter::Paren(_binding_0) => { 2798 skip!(_binding_0); 2799 } 2800 MacroDelimiter::Brace(_binding_0) => { 2801 skip!(_binding_0); 2802 } 2803 MacroDelimiter::Bracket(_binding_0) => { 2804 skip!(_binding_0); 2805 } 2806 } 2807} 2808#[cfg(any(feature = "derive", feature = "full"))] 2809#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 2810pub fn visit_member_mut<V>(v: &mut V, node: &mut Member) 2811where 2812 V: VisitMut + ?Sized, 2813{ 2814 match node { 2815 Member::Named(_binding_0) => { 2816 v.visit_ident_mut(_binding_0); 2817 } 2818 Member::Unnamed(_binding_0) => { 2819 v.visit_index_mut(_binding_0); 2820 } 2821 } 2822} 2823#[cfg(any(feature = "derive", feature = "full"))] 2824#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 2825pub fn visit_meta_mut<V>(v: &mut V, node: &mut Meta) 2826where 2827 V: VisitMut + ?Sized, 2828{ 2829 match node { 2830 Meta::Path(_binding_0) => { 2831 v.visit_path_mut(_binding_0); 2832 } 2833 Meta::List(_binding_0) => { 2834 v.visit_meta_list_mut(_binding_0); 2835 } 2836 Meta::NameValue(_binding_0) => { 2837 v.visit_meta_name_value_mut(_binding_0); 2838 } 2839 } 2840} 2841#[cfg(any(feature = "derive", feature = "full"))] 2842#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 2843pub fn visit_meta_list_mut<V>(v: &mut V, node: &mut MetaList) 2844where 2845 V: VisitMut + ?Sized, 2846{ 2847 v.visit_path_mut(&mut node.path); 2848 v.visit_macro_delimiter_mut(&mut node.delimiter); 2849 skip!(node.tokens); 2850} 2851#[cfg(any(feature = "derive", feature = "full"))] 2852#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 2853pub fn visit_meta_name_value_mut<V>(v: &mut V, node: &mut MetaNameValue) 2854where 2855 V: VisitMut + ?Sized, 2856{ 2857 v.visit_path_mut(&mut node.path); 2858 skip!(node.eq_token); 2859 v.visit_expr_mut(&mut node.value); 2860} 2861#[cfg(any(feature = "derive", feature = "full"))] 2862#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 2863pub fn visit_parenthesized_generic_arguments_mut<V>( 2864 v: &mut V, 2865 node: &mut ParenthesizedGenericArguments, 2866) 2867where 2868 V: VisitMut + ?Sized, 2869{ 2870 skip!(node.paren_token); 2871 for mut el in Punctuated::pairs_mut(&mut node.inputs) { 2872 let it = el.value_mut(); 2873 v.visit_type_mut(it); 2874 } 2875 v.visit_return_type_mut(&mut node.output); 2876} 2877#[cfg(feature = "full")] 2878#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 2879pub fn visit_pat_mut<V>(v: &mut V, node: &mut Pat) 2880where 2881 V: VisitMut + ?Sized, 2882{ 2883 match node { 2884 Pat::Const(_binding_0) => { 2885 v.visit_expr_const_mut(_binding_0); 2886 } 2887 Pat::Ident(_binding_0) => { 2888 v.visit_pat_ident_mut(_binding_0); 2889 } 2890 Pat::Lit(_binding_0) => { 2891 v.visit_expr_lit_mut(_binding_0); 2892 } 2893 Pat::Macro(_binding_0) => { 2894 v.visit_expr_macro_mut(_binding_0); 2895 } 2896 Pat::Or(_binding_0) => { 2897 v.visit_pat_or_mut(_binding_0); 2898 } 2899 Pat::Paren(_binding_0) => { 2900 v.visit_pat_paren_mut(_binding_0); 2901 } 2902 Pat::Path(_binding_0) => { 2903 v.visit_expr_path_mut(_binding_0); 2904 } 2905 Pat::Range(_binding_0) => { 2906 v.visit_expr_range_mut(_binding_0); 2907 } 2908 Pat::Reference(_binding_0) => { 2909 v.visit_pat_reference_mut(_binding_0); 2910 } 2911 Pat::Rest(_binding_0) => { 2912 v.visit_pat_rest_mut(_binding_0); 2913 } 2914 Pat::Slice(_binding_0) => { 2915 v.visit_pat_slice_mut(_binding_0); 2916 } 2917 Pat::Struct(_binding_0) => { 2918 v.visit_pat_struct_mut(_binding_0); 2919 } 2920 Pat::Tuple(_binding_0) => { 2921 v.visit_pat_tuple_mut(_binding_0); 2922 } 2923 Pat::TupleStruct(_binding_0) => { 2924 v.visit_pat_tuple_struct_mut(_binding_0); 2925 } 2926 Pat::Type(_binding_0) => { 2927 v.visit_pat_type_mut(_binding_0); 2928 } 2929 Pat::Verbatim(_binding_0) => { 2930 skip!(_binding_0); 2931 } 2932 Pat::Wild(_binding_0) => { 2933 v.visit_pat_wild_mut(_binding_0); 2934 } 2935 } 2936} 2937#[cfg(feature = "full")] 2938#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 2939pub fn visit_pat_ident_mut<V>(v: &mut V, node: &mut PatIdent) 2940where 2941 V: VisitMut + ?Sized, 2942{ 2943 for it in &mut node.attrs { 2944 v.visit_attribute_mut(it); 2945 } 2946 skip!(node.by_ref); 2947 skip!(node.mutability); 2948 v.visit_ident_mut(&mut node.ident); 2949 if let Some(it) = &mut node.subpat { 2950 skip!((it).0); 2951 v.visit_pat_mut(&mut *(it).1); 2952 } 2953} 2954#[cfg(feature = "full")] 2955#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 2956pub fn visit_pat_or_mut<V>(v: &mut V, node: &mut PatOr) 2957where 2958 V: VisitMut + ?Sized, 2959{ 2960 for it in &mut node.attrs { 2961 v.visit_attribute_mut(it); 2962 } 2963 skip!(node.leading_vert); 2964 for mut el in Punctuated::pairs_mut(&mut node.cases) { 2965 let it = el.value_mut(); 2966 v.visit_pat_mut(it); 2967 } 2968} 2969#[cfg(feature = "full")] 2970#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 2971pub fn visit_pat_paren_mut<V>(v: &mut V, node: &mut PatParen) 2972where 2973 V: VisitMut + ?Sized, 2974{ 2975 for it in &mut node.attrs { 2976 v.visit_attribute_mut(it); 2977 } 2978 skip!(node.paren_token); 2979 v.visit_pat_mut(&mut *node.pat); 2980} 2981#[cfg(feature = "full")] 2982#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 2983pub fn visit_pat_reference_mut<V>(v: &mut V, node: &mut PatReference) 2984where 2985 V: VisitMut + ?Sized, 2986{ 2987 for it in &mut node.attrs { 2988 v.visit_attribute_mut(it); 2989 } 2990 skip!(node.and_token); 2991 skip!(node.mutability); 2992 v.visit_pat_mut(&mut *node.pat); 2993} 2994#[cfg(feature = "full")] 2995#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 2996pub fn visit_pat_rest_mut<V>(v: &mut V, node: &mut PatRest) 2997where 2998 V: VisitMut + ?Sized, 2999{ 3000 for it in &mut node.attrs { 3001 v.visit_attribute_mut(it); 3002 } 3003 skip!(node.dot2_token); 3004} 3005#[cfg(feature = "full")] 3006#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 3007pub fn visit_pat_slice_mut<V>(v: &mut V, node: &mut PatSlice) 3008where 3009 V: VisitMut + ?Sized, 3010{ 3011 for it in &mut node.attrs { 3012 v.visit_attribute_mut(it); 3013 } 3014 skip!(node.bracket_token); 3015 for mut el in Punctuated::pairs_mut(&mut node.elems) { 3016 let it = el.value_mut(); 3017 v.visit_pat_mut(it); 3018 } 3019} 3020#[cfg(feature = "full")] 3021#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 3022pub fn visit_pat_struct_mut<V>(v: &mut V, node: &mut PatStruct) 3023where 3024 V: VisitMut + ?Sized, 3025{ 3026 for it in &mut node.attrs { 3027 v.visit_attribute_mut(it); 3028 } 3029 if let Some(it) = &mut node.qself { 3030 v.visit_qself_mut(it); 3031 } 3032 v.visit_path_mut(&mut node.path); 3033 skip!(node.brace_token); 3034 for mut el in Punctuated::pairs_mut(&mut node.fields) { 3035 let it = el.value_mut(); 3036 v.visit_field_pat_mut(it); 3037 } 3038 if let Some(it) = &mut node.rest { 3039 v.visit_pat_rest_mut(it); 3040 } 3041} 3042#[cfg(feature = "full")] 3043#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 3044pub fn visit_pat_tuple_mut<V>(v: &mut V, node: &mut PatTuple) 3045where 3046 V: VisitMut + ?Sized, 3047{ 3048 for it in &mut node.attrs { 3049 v.visit_attribute_mut(it); 3050 } 3051 skip!(node.paren_token); 3052 for mut el in Punctuated::pairs_mut(&mut node.elems) { 3053 let it = el.value_mut(); 3054 v.visit_pat_mut(it); 3055 } 3056} 3057#[cfg(feature = "full")] 3058#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 3059pub fn visit_pat_tuple_struct_mut<V>(v: &mut V, node: &mut PatTupleStruct) 3060where 3061 V: VisitMut + ?Sized, 3062{ 3063 for it in &mut node.attrs { 3064 v.visit_attribute_mut(it); 3065 } 3066 if let Some(it) = &mut node.qself { 3067 v.visit_qself_mut(it); 3068 } 3069 v.visit_path_mut(&mut node.path); 3070 skip!(node.paren_token); 3071 for mut el in Punctuated::pairs_mut(&mut node.elems) { 3072 let it = el.value_mut(); 3073 v.visit_pat_mut(it); 3074 } 3075} 3076#[cfg(feature = "full")] 3077#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 3078pub fn visit_pat_type_mut<V>(v: &mut V, node: &mut PatType) 3079where 3080 V: VisitMut + ?Sized, 3081{ 3082 for it in &mut node.attrs { 3083 v.visit_attribute_mut(it); 3084 } 3085 v.visit_pat_mut(&mut *node.pat); 3086 skip!(node.colon_token); 3087 v.visit_type_mut(&mut *node.ty); 3088} 3089#[cfg(feature = "full")] 3090#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 3091pub fn visit_pat_wild_mut<V>(v: &mut V, node: &mut PatWild) 3092where 3093 V: VisitMut + ?Sized, 3094{ 3095 for it in &mut node.attrs { 3096 v.visit_attribute_mut(it); 3097 } 3098 skip!(node.underscore_token); 3099} 3100#[cfg(any(feature = "derive", feature = "full"))] 3101#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 3102pub fn visit_path_mut<V>(v: &mut V, node: &mut Path) 3103where 3104 V: VisitMut + ?Sized, 3105{ 3106 skip!(node.leading_colon); 3107 for mut el in Punctuated::pairs_mut(&mut node.segments) { 3108 let it = el.value_mut(); 3109 v.visit_path_segment_mut(it); 3110 } 3111} 3112#[cfg(any(feature = "derive", feature = "full"))] 3113#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 3114pub fn visit_path_arguments_mut<V>(v: &mut V, node: &mut PathArguments) 3115where 3116 V: VisitMut + ?Sized, 3117{ 3118 match node { 3119 PathArguments::None => {} 3120 PathArguments::AngleBracketed(_binding_0) => { 3121 v.visit_angle_bracketed_generic_arguments_mut(_binding_0); 3122 } 3123 PathArguments::Parenthesized(_binding_0) => { 3124 v.visit_parenthesized_generic_arguments_mut(_binding_0); 3125 } 3126 } 3127} 3128#[cfg(any(feature = "derive", feature = "full"))] 3129#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 3130pub fn visit_path_segment_mut<V>(v: &mut V, node: &mut PathSegment) 3131where 3132 V: VisitMut + ?Sized, 3133{ 3134 v.visit_ident_mut(&mut node.ident); 3135 v.visit_path_arguments_mut(&mut node.arguments); 3136} 3137#[cfg(any(feature = "derive", feature = "full"))] 3138#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 3139pub fn visit_predicate_lifetime_mut<V>(v: &mut V, node: &mut PredicateLifetime) 3140where 3141 V: VisitMut + ?Sized, 3142{ 3143 v.visit_lifetime_mut(&mut node.lifetime); 3144 skip!(node.colon_token); 3145 for mut el in Punctuated::pairs_mut(&mut node.bounds) { 3146 let it = el.value_mut(); 3147 v.visit_lifetime_mut(it); 3148 } 3149} 3150#[cfg(any(feature = "derive", feature = "full"))] 3151#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 3152pub fn visit_predicate_type_mut<V>(v: &mut V, node: &mut PredicateType) 3153where 3154 V: VisitMut + ?Sized, 3155{ 3156 if let Some(it) = &mut node.lifetimes { 3157 v.visit_bound_lifetimes_mut(it); 3158 } 3159 v.visit_type_mut(&mut node.bounded_ty); 3160 skip!(node.colon_token); 3161 for mut el in Punctuated::pairs_mut(&mut node.bounds) { 3162 let it = el.value_mut(); 3163 v.visit_type_param_bound_mut(it); 3164 } 3165} 3166#[cfg(any(feature = "derive", feature = "full"))] 3167#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 3168pub fn visit_qself_mut<V>(v: &mut V, node: &mut QSelf) 3169where 3170 V: VisitMut + ?Sized, 3171{ 3172 skip!(node.lt_token); 3173 v.visit_type_mut(&mut *node.ty); 3174 skip!(node.position); 3175 skip!(node.as_token); 3176 skip!(node.gt_token); 3177} 3178#[cfg(feature = "full")] 3179#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 3180pub fn visit_range_limits_mut<V>(v: &mut V, node: &mut RangeLimits) 3181where 3182 V: VisitMut + ?Sized, 3183{ 3184 match node { 3185 RangeLimits::HalfOpen(_binding_0) => { 3186 skip!(_binding_0); 3187 } 3188 RangeLimits::Closed(_binding_0) => { 3189 skip!(_binding_0); 3190 } 3191 } 3192} 3193#[cfg(feature = "full")] 3194#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 3195pub fn visit_receiver_mut<V>(v: &mut V, node: &mut Receiver) 3196where 3197 V: VisitMut + ?Sized, 3198{ 3199 for it in &mut node.attrs { 3200 v.visit_attribute_mut(it); 3201 } 3202 if let Some(it) = &mut node.reference { 3203 skip!((it).0); 3204 if let Some(it) = &mut (it).1 { 3205 v.visit_lifetime_mut(it); 3206 } 3207 } 3208 skip!(node.mutability); 3209 skip!(node.self_token); 3210 skip!(node.colon_token); 3211 v.visit_type_mut(&mut *node.ty); 3212} 3213#[cfg(any(feature = "derive", feature = "full"))] 3214#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 3215pub fn visit_return_type_mut<V>(v: &mut V, node: &mut ReturnType) 3216where 3217 V: VisitMut + ?Sized, 3218{ 3219 match node { 3220 ReturnType::Default => {} 3221 ReturnType::Type(_binding_0, _binding_1) => { 3222 skip!(_binding_0); 3223 v.visit_type_mut(&mut **_binding_1); 3224 } 3225 } 3226} 3227#[cfg(feature = "full")] 3228#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 3229pub fn visit_signature_mut<V>(v: &mut V, node: &mut Signature) 3230where 3231 V: VisitMut + ?Sized, 3232{ 3233 skip!(node.constness); 3234 skip!(node.asyncness); 3235 skip!(node.unsafety); 3236 if let Some(it) = &mut node.abi { 3237 v.visit_abi_mut(it); 3238 } 3239 skip!(node.fn_token); 3240 v.visit_ident_mut(&mut node.ident); 3241 v.visit_generics_mut(&mut node.generics); 3242 skip!(node.paren_token); 3243 for mut el in Punctuated::pairs_mut(&mut node.inputs) { 3244 let it = el.value_mut(); 3245 v.visit_fn_arg_mut(it); 3246 } 3247 if let Some(it) = &mut node.variadic { 3248 v.visit_variadic_mut(it); 3249 } 3250 v.visit_return_type_mut(&mut node.output); 3251} 3252pub fn visit_span_mut<V>(v: &mut V, node: &mut Span) 3253where 3254 V: VisitMut + ?Sized, 3255{} 3256#[cfg(feature = "full")] 3257#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 3258pub fn visit_static_mutability_mut<V>(v: &mut V, node: &mut StaticMutability) 3259where 3260 V: VisitMut + ?Sized, 3261{ 3262 match node { 3263 StaticMutability::Mut(_binding_0) => { 3264 skip!(_binding_0); 3265 } 3266 StaticMutability::None => {} 3267 } 3268} 3269#[cfg(feature = "full")] 3270#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 3271pub fn visit_stmt_mut<V>(v: &mut V, node: &mut Stmt) 3272where 3273 V: VisitMut + ?Sized, 3274{ 3275 match node { 3276 Stmt::Local(_binding_0) => { 3277 v.visit_local_mut(_binding_0); 3278 } 3279 Stmt::Item(_binding_0) => { 3280 v.visit_item_mut(_binding_0); 3281 } 3282 Stmt::Expr(_binding_0, _binding_1) => { 3283 v.visit_expr_mut(_binding_0); 3284 skip!(_binding_1); 3285 } 3286 Stmt::Macro(_binding_0) => { 3287 v.visit_stmt_macro_mut(_binding_0); 3288 } 3289 } 3290} 3291#[cfg(feature = "full")] 3292#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 3293pub fn visit_stmt_macro_mut<V>(v: &mut V, node: &mut StmtMacro) 3294where 3295 V: VisitMut + ?Sized, 3296{ 3297 for it in &mut node.attrs { 3298 v.visit_attribute_mut(it); 3299 } 3300 v.visit_macro_mut(&mut node.mac); 3301 skip!(node.semi_token); 3302} 3303#[cfg(any(feature = "derive", feature = "full"))] 3304#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 3305pub fn visit_trait_bound_mut<V>(v: &mut V, node: &mut TraitBound) 3306where 3307 V: VisitMut + ?Sized, 3308{ 3309 skip!(node.paren_token); 3310 v.visit_trait_bound_modifier_mut(&mut node.modifier); 3311 if let Some(it) = &mut node.lifetimes { 3312 v.visit_bound_lifetimes_mut(it); 3313 } 3314 v.visit_path_mut(&mut node.path); 3315} 3316#[cfg(any(feature = "derive", feature = "full"))] 3317#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 3318pub fn visit_trait_bound_modifier_mut<V>(v: &mut V, node: &mut TraitBoundModifier) 3319where 3320 V: VisitMut + ?Sized, 3321{ 3322 match node { 3323 TraitBoundModifier::None => {} 3324 TraitBoundModifier::Maybe(_binding_0) => { 3325 skip!(_binding_0); 3326 } 3327 } 3328} 3329#[cfg(feature = "full")] 3330#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 3331pub fn visit_trait_item_mut<V>(v: &mut V, node: &mut TraitItem) 3332where 3333 V: VisitMut + ?Sized, 3334{ 3335 match node { 3336 TraitItem::Const(_binding_0) => { 3337 v.visit_trait_item_const_mut(_binding_0); 3338 } 3339 TraitItem::Fn(_binding_0) => { 3340 v.visit_trait_item_fn_mut(_binding_0); 3341 } 3342 TraitItem::Type(_binding_0) => { 3343 v.visit_trait_item_type_mut(_binding_0); 3344 } 3345 TraitItem::Macro(_binding_0) => { 3346 v.visit_trait_item_macro_mut(_binding_0); 3347 } 3348 TraitItem::Verbatim(_binding_0) => { 3349 skip!(_binding_0); 3350 } 3351 } 3352} 3353#[cfg(feature = "full")] 3354#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 3355pub fn visit_trait_item_const_mut<V>(v: &mut V, node: &mut TraitItemConst) 3356where 3357 V: VisitMut + ?Sized, 3358{ 3359 for it in &mut node.attrs { 3360 v.visit_attribute_mut(it); 3361 } 3362 skip!(node.const_token); 3363 v.visit_ident_mut(&mut node.ident); 3364 v.visit_generics_mut(&mut node.generics); 3365 skip!(node.colon_token); 3366 v.visit_type_mut(&mut node.ty); 3367 if let Some(it) = &mut node.default { 3368 skip!((it).0); 3369 v.visit_expr_mut(&mut (it).1); 3370 } 3371 skip!(node.semi_token); 3372} 3373#[cfg(feature = "full")] 3374#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 3375pub fn visit_trait_item_fn_mut<V>(v: &mut V, node: &mut TraitItemFn) 3376where 3377 V: VisitMut + ?Sized, 3378{ 3379 for it in &mut node.attrs { 3380 v.visit_attribute_mut(it); 3381 } 3382 v.visit_signature_mut(&mut node.sig); 3383 if let Some(it) = &mut node.default { 3384 v.visit_block_mut(it); 3385 } 3386 skip!(node.semi_token); 3387} 3388#[cfg(feature = "full")] 3389#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 3390pub fn visit_trait_item_macro_mut<V>(v: &mut V, node: &mut TraitItemMacro) 3391where 3392 V: VisitMut + ?Sized, 3393{ 3394 for it in &mut node.attrs { 3395 v.visit_attribute_mut(it); 3396 } 3397 v.visit_macro_mut(&mut node.mac); 3398 skip!(node.semi_token); 3399} 3400#[cfg(feature = "full")] 3401#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 3402pub fn visit_trait_item_type_mut<V>(v: &mut V, node: &mut TraitItemType) 3403where 3404 V: VisitMut + ?Sized, 3405{ 3406 for it in &mut node.attrs { 3407 v.visit_attribute_mut(it); 3408 } 3409 skip!(node.type_token); 3410 v.visit_ident_mut(&mut node.ident); 3411 v.visit_generics_mut(&mut node.generics); 3412 skip!(node.colon_token); 3413 for mut el in Punctuated::pairs_mut(&mut node.bounds) { 3414 let it = el.value_mut(); 3415 v.visit_type_param_bound_mut(it); 3416 } 3417 if let Some(it) = &mut node.default { 3418 skip!((it).0); 3419 v.visit_type_mut(&mut (it).1); 3420 } 3421 skip!(node.semi_token); 3422} 3423#[cfg(any(feature = "derive", feature = "full"))] 3424#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 3425pub fn visit_type_mut<V>(v: &mut V, node: &mut Type) 3426where 3427 V: VisitMut + ?Sized, 3428{ 3429 match node { 3430 Type::Array(_binding_0) => { 3431 v.visit_type_array_mut(_binding_0); 3432 } 3433 Type::BareFn(_binding_0) => { 3434 v.visit_type_bare_fn_mut(_binding_0); 3435 } 3436 Type::Group(_binding_0) => { 3437 v.visit_type_group_mut(_binding_0); 3438 } 3439 Type::ImplTrait(_binding_0) => { 3440 v.visit_type_impl_trait_mut(_binding_0); 3441 } 3442 Type::Infer(_binding_0) => { 3443 v.visit_type_infer_mut(_binding_0); 3444 } 3445 Type::Macro(_binding_0) => { 3446 v.visit_type_macro_mut(_binding_0); 3447 } 3448 Type::Never(_binding_0) => { 3449 v.visit_type_never_mut(_binding_0); 3450 } 3451 Type::Paren(_binding_0) => { 3452 v.visit_type_paren_mut(_binding_0); 3453 } 3454 Type::Path(_binding_0) => { 3455 v.visit_type_path_mut(_binding_0); 3456 } 3457 Type::Ptr(_binding_0) => { 3458 v.visit_type_ptr_mut(_binding_0); 3459 } 3460 Type::Reference(_binding_0) => { 3461 v.visit_type_reference_mut(_binding_0); 3462 } 3463 Type::Slice(_binding_0) => { 3464 v.visit_type_slice_mut(_binding_0); 3465 } 3466 Type::TraitObject(_binding_0) => { 3467 v.visit_type_trait_object_mut(_binding_0); 3468 } 3469 Type::Tuple(_binding_0) => { 3470 v.visit_type_tuple_mut(_binding_0); 3471 } 3472 Type::Verbatim(_binding_0) => { 3473 skip!(_binding_0); 3474 } 3475 } 3476} 3477#[cfg(any(feature = "derive", feature = "full"))] 3478#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 3479pub fn visit_type_array_mut<V>(v: &mut V, node: &mut TypeArray) 3480where 3481 V: VisitMut + ?Sized, 3482{ 3483 skip!(node.bracket_token); 3484 v.visit_type_mut(&mut *node.elem); 3485 skip!(node.semi_token); 3486 v.visit_expr_mut(&mut node.len); 3487} 3488#[cfg(any(feature = "derive", feature = "full"))] 3489#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 3490pub fn visit_type_bare_fn_mut<V>(v: &mut V, node: &mut TypeBareFn) 3491where 3492 V: VisitMut + ?Sized, 3493{ 3494 if let Some(it) = &mut node.lifetimes { 3495 v.visit_bound_lifetimes_mut(it); 3496 } 3497 skip!(node.unsafety); 3498 if let Some(it) = &mut node.abi { 3499 v.visit_abi_mut(it); 3500 } 3501 skip!(node.fn_token); 3502 skip!(node.paren_token); 3503 for mut el in Punctuated::pairs_mut(&mut node.inputs) { 3504 let it = el.value_mut(); 3505 v.visit_bare_fn_arg_mut(it); 3506 } 3507 if let Some(it) = &mut node.variadic { 3508 v.visit_bare_variadic_mut(it); 3509 } 3510 v.visit_return_type_mut(&mut node.output); 3511} 3512#[cfg(any(feature = "derive", feature = "full"))] 3513#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 3514pub fn visit_type_group_mut<V>(v: &mut V, node: &mut TypeGroup) 3515where 3516 V: VisitMut + ?Sized, 3517{ 3518 skip!(node.group_token); 3519 v.visit_type_mut(&mut *node.elem); 3520} 3521#[cfg(any(feature = "derive", feature = "full"))] 3522#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 3523pub fn visit_type_impl_trait_mut<V>(v: &mut V, node: &mut TypeImplTrait) 3524where 3525 V: VisitMut + ?Sized, 3526{ 3527 skip!(node.impl_token); 3528 for mut el in Punctuated::pairs_mut(&mut node.bounds) { 3529 let it = el.value_mut(); 3530 v.visit_type_param_bound_mut(it); 3531 } 3532} 3533#[cfg(any(feature = "derive", feature = "full"))] 3534#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 3535pub fn visit_type_infer_mut<V>(v: &mut V, node: &mut TypeInfer) 3536where 3537 V: VisitMut + ?Sized, 3538{ 3539 skip!(node.underscore_token); 3540} 3541#[cfg(any(feature = "derive", feature = "full"))] 3542#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 3543pub fn visit_type_macro_mut<V>(v: &mut V, node: &mut TypeMacro) 3544where 3545 V: VisitMut + ?Sized, 3546{ 3547 v.visit_macro_mut(&mut node.mac); 3548} 3549#[cfg(any(feature = "derive", feature = "full"))] 3550#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 3551pub fn visit_type_never_mut<V>(v: &mut V, node: &mut TypeNever) 3552where 3553 V: VisitMut + ?Sized, 3554{ 3555 skip!(node.bang_token); 3556} 3557#[cfg(any(feature = "derive", feature = "full"))] 3558#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 3559pub fn visit_type_param_mut<V>(v: &mut V, node: &mut TypeParam) 3560where 3561 V: VisitMut + ?Sized, 3562{ 3563 for it in &mut node.attrs { 3564 v.visit_attribute_mut(it); 3565 } 3566 v.visit_ident_mut(&mut node.ident); 3567 skip!(node.colon_token); 3568 for mut el in Punctuated::pairs_mut(&mut node.bounds) { 3569 let it = el.value_mut(); 3570 v.visit_type_param_bound_mut(it); 3571 } 3572 skip!(node.eq_token); 3573 if let Some(it) = &mut node.default { 3574 v.visit_type_mut(it); 3575 } 3576} 3577#[cfg(any(feature = "derive", feature = "full"))] 3578#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 3579pub fn visit_type_param_bound_mut<V>(v: &mut V, node: &mut TypeParamBound) 3580where 3581 V: VisitMut + ?Sized, 3582{ 3583 match node { 3584 TypeParamBound::Trait(_binding_0) => { 3585 v.visit_trait_bound_mut(_binding_0); 3586 } 3587 TypeParamBound::Lifetime(_binding_0) => { 3588 v.visit_lifetime_mut(_binding_0); 3589 } 3590 TypeParamBound::Verbatim(_binding_0) => { 3591 skip!(_binding_0); 3592 } 3593 } 3594} 3595#[cfg(any(feature = "derive", feature = "full"))] 3596#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 3597pub fn visit_type_paren_mut<V>(v: &mut V, node: &mut TypeParen) 3598where 3599 V: VisitMut + ?Sized, 3600{ 3601 skip!(node.paren_token); 3602 v.visit_type_mut(&mut *node.elem); 3603} 3604#[cfg(any(feature = "derive", feature = "full"))] 3605#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 3606pub fn visit_type_path_mut<V>(v: &mut V, node: &mut TypePath) 3607where 3608 V: VisitMut + ?Sized, 3609{ 3610 if let Some(it) = &mut node.qself { 3611 v.visit_qself_mut(it); 3612 } 3613 v.visit_path_mut(&mut node.path); 3614} 3615#[cfg(any(feature = "derive", feature = "full"))] 3616#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 3617pub fn visit_type_ptr_mut<V>(v: &mut V, node: &mut TypePtr) 3618where 3619 V: VisitMut + ?Sized, 3620{ 3621 skip!(node.star_token); 3622 skip!(node.const_token); 3623 skip!(node.mutability); 3624 v.visit_type_mut(&mut *node.elem); 3625} 3626#[cfg(any(feature = "derive", feature = "full"))] 3627#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 3628pub fn visit_type_reference_mut<V>(v: &mut V, node: &mut TypeReference) 3629where 3630 V: VisitMut + ?Sized, 3631{ 3632 skip!(node.and_token); 3633 if let Some(it) = &mut node.lifetime { 3634 v.visit_lifetime_mut(it); 3635 } 3636 skip!(node.mutability); 3637 v.visit_type_mut(&mut *node.elem); 3638} 3639#[cfg(any(feature = "derive", feature = "full"))] 3640#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 3641pub fn visit_type_slice_mut<V>(v: &mut V, node: &mut TypeSlice) 3642where 3643 V: VisitMut + ?Sized, 3644{ 3645 skip!(node.bracket_token); 3646 v.visit_type_mut(&mut *node.elem); 3647} 3648#[cfg(any(feature = "derive", feature = "full"))] 3649#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 3650pub fn visit_type_trait_object_mut<V>(v: &mut V, node: &mut TypeTraitObject) 3651where 3652 V: VisitMut + ?Sized, 3653{ 3654 skip!(node.dyn_token); 3655 for mut el in Punctuated::pairs_mut(&mut node.bounds) { 3656 let it = el.value_mut(); 3657 v.visit_type_param_bound_mut(it); 3658 } 3659} 3660#[cfg(any(feature = "derive", feature = "full"))] 3661#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 3662pub fn visit_type_tuple_mut<V>(v: &mut V, node: &mut TypeTuple) 3663where 3664 V: VisitMut + ?Sized, 3665{ 3666 skip!(node.paren_token); 3667 for mut el in Punctuated::pairs_mut(&mut node.elems) { 3668 let it = el.value_mut(); 3669 v.visit_type_mut(it); 3670 } 3671} 3672#[cfg(any(feature = "derive", feature = "full"))] 3673#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 3674pub fn visit_un_op_mut<V>(v: &mut V, node: &mut UnOp) 3675where 3676 V: VisitMut + ?Sized, 3677{ 3678 match node { 3679 UnOp::Deref(_binding_0) => { 3680 skip!(_binding_0); 3681 } 3682 UnOp::Not(_binding_0) => { 3683 skip!(_binding_0); 3684 } 3685 UnOp::Neg(_binding_0) => { 3686 skip!(_binding_0); 3687 } 3688 } 3689} 3690#[cfg(feature = "full")] 3691#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 3692pub fn visit_use_glob_mut<V>(v: &mut V, node: &mut UseGlob) 3693where 3694 V: VisitMut + ?Sized, 3695{ 3696 skip!(node.star_token); 3697} 3698#[cfg(feature = "full")] 3699#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 3700pub fn visit_use_group_mut<V>(v: &mut V, node: &mut UseGroup) 3701where 3702 V: VisitMut + ?Sized, 3703{ 3704 skip!(node.brace_token); 3705 for mut el in Punctuated::pairs_mut(&mut node.items) { 3706 let it = el.value_mut(); 3707 v.visit_use_tree_mut(it); 3708 } 3709} 3710#[cfg(feature = "full")] 3711#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 3712pub fn visit_use_name_mut<V>(v: &mut V, node: &mut UseName) 3713where 3714 V: VisitMut + ?Sized, 3715{ 3716 v.visit_ident_mut(&mut node.ident); 3717} 3718#[cfg(feature = "full")] 3719#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 3720pub fn visit_use_path_mut<V>(v: &mut V, node: &mut UsePath) 3721where 3722 V: VisitMut + ?Sized, 3723{ 3724 v.visit_ident_mut(&mut node.ident); 3725 skip!(node.colon2_token); 3726 v.visit_use_tree_mut(&mut *node.tree); 3727} 3728#[cfg(feature = "full")] 3729#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 3730pub fn visit_use_rename_mut<V>(v: &mut V, node: &mut UseRename) 3731where 3732 V: VisitMut + ?Sized, 3733{ 3734 v.visit_ident_mut(&mut node.ident); 3735 skip!(node.as_token); 3736 v.visit_ident_mut(&mut node.rename); 3737} 3738#[cfg(feature = "full")] 3739#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 3740pub fn visit_use_tree_mut<V>(v: &mut V, node: &mut UseTree) 3741where 3742 V: VisitMut + ?Sized, 3743{ 3744 match node { 3745 UseTree::Path(_binding_0) => { 3746 v.visit_use_path_mut(_binding_0); 3747 } 3748 UseTree::Name(_binding_0) => { 3749 v.visit_use_name_mut(_binding_0); 3750 } 3751 UseTree::Rename(_binding_0) => { 3752 v.visit_use_rename_mut(_binding_0); 3753 } 3754 UseTree::Glob(_binding_0) => { 3755 v.visit_use_glob_mut(_binding_0); 3756 } 3757 UseTree::Group(_binding_0) => { 3758 v.visit_use_group_mut(_binding_0); 3759 } 3760 } 3761} 3762#[cfg(feature = "full")] 3763#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] 3764pub fn visit_variadic_mut<V>(v: &mut V, node: &mut Variadic) 3765where 3766 V: VisitMut + ?Sized, 3767{ 3768 for it in &mut node.attrs { 3769 v.visit_attribute_mut(it); 3770 } 3771 if let Some(it) = &mut node.pat { 3772 v.visit_pat_mut(&mut *(it).0); 3773 skip!((it).1); 3774 } 3775 skip!(node.dots); 3776 skip!(node.comma); 3777} 3778#[cfg(any(feature = "derive", feature = "full"))] 3779#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 3780pub fn visit_variant_mut<V>(v: &mut V, node: &mut Variant) 3781where 3782 V: VisitMut + ?Sized, 3783{ 3784 for it in &mut node.attrs { 3785 v.visit_attribute_mut(it); 3786 } 3787 v.visit_ident_mut(&mut node.ident); 3788 v.visit_fields_mut(&mut node.fields); 3789 if let Some(it) = &mut node.discriminant { 3790 skip!((it).0); 3791 v.visit_expr_mut(&mut (it).1); 3792 } 3793} 3794#[cfg(any(feature = "derive", feature = "full"))] 3795#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 3796pub fn visit_vis_restricted_mut<V>(v: &mut V, node: &mut VisRestricted) 3797where 3798 V: VisitMut + ?Sized, 3799{ 3800 skip!(node.pub_token); 3801 skip!(node.paren_token); 3802 skip!(node.in_token); 3803 v.visit_path_mut(&mut *node.path); 3804} 3805#[cfg(any(feature = "derive", feature = "full"))] 3806#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 3807pub fn visit_visibility_mut<V>(v: &mut V, node: &mut Visibility) 3808where 3809 V: VisitMut + ?Sized, 3810{ 3811 match node { 3812 Visibility::Public(_binding_0) => { 3813 skip!(_binding_0); 3814 } 3815 Visibility::Restricted(_binding_0) => { 3816 v.visit_vis_restricted_mut(_binding_0); 3817 } 3818 Visibility::Inherited => {} 3819 } 3820} 3821#[cfg(any(feature = "derive", feature = "full"))] 3822#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 3823pub fn visit_where_clause_mut<V>(v: &mut V, node: &mut WhereClause) 3824where 3825 V: VisitMut + ?Sized, 3826{ 3827 skip!(node.where_token); 3828 for mut el in Punctuated::pairs_mut(&mut node.predicates) { 3829 let it = el.value_mut(); 3830 v.visit_where_predicate_mut(it); 3831 } 3832} 3833#[cfg(any(feature = "derive", feature = "full"))] 3834#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))] 3835pub fn visit_where_predicate_mut<V>(v: &mut V, node: &mut WherePredicate) 3836where 3837 V: VisitMut + ?Sized, 3838{ 3839 match node { 3840 WherePredicate::Lifetime(_binding_0) => { 3841 v.visit_predicate_lifetime_mut(_binding_0); 3842 } 3843 WherePredicate::Type(_binding_0) => { 3844 v.visit_predicate_type_mut(_binding_0); 3845 } 3846 } 3847} 3848