1 // This file is @generated by syn-internal-codegen. 2 // It is not intended for manual editing. 3 4 use crate::*; 5 use std::fmt::{self, Debug}; 6 #[cfg(any(feature = "derive", feature = "full"))] 7 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 8 impl Debug for Abi { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result9 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 10 let mut formatter = formatter.debug_struct("Abi"); 11 formatter.field("extern_token", &self.extern_token); 12 formatter.field("name", &self.name); 13 formatter.finish() 14 } 15 } 16 #[cfg(any(feature = "derive", feature = "full"))] 17 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 18 impl Debug for AngleBracketedGenericArguments { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result19 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 20 let mut formatter = formatter.debug_struct("AngleBracketedGenericArguments"); 21 formatter.field("colon2_token", &self.colon2_token); 22 formatter.field("lt_token", &self.lt_token); 23 formatter.field("args", &self.args); 24 formatter.field("gt_token", &self.gt_token); 25 formatter.finish() 26 } 27 } 28 #[cfg(feature = "full")] 29 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 30 impl Debug for Arm { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result31 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 32 let mut formatter = formatter.debug_struct("Arm"); 33 formatter.field("attrs", &self.attrs); 34 formatter.field("pat", &self.pat); 35 formatter.field("guard", &self.guard); 36 formatter.field("fat_arrow_token", &self.fat_arrow_token); 37 formatter.field("body", &self.body); 38 formatter.field("comma", &self.comma); 39 formatter.finish() 40 } 41 } 42 #[cfg(any(feature = "derive", feature = "full"))] 43 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 44 impl Debug for AttrStyle { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result45 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 46 match self { 47 AttrStyle::Outer => formatter.write_str("Outer"), 48 AttrStyle::Inner(v0) => { 49 let mut formatter = formatter.debug_tuple("Inner"); 50 formatter.field(v0); 51 formatter.finish() 52 } 53 } 54 } 55 } 56 #[cfg(any(feature = "derive", feature = "full"))] 57 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 58 impl Debug for Attribute { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result59 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 60 let mut formatter = formatter.debug_struct("Attribute"); 61 formatter.field("pound_token", &self.pound_token); 62 formatter.field("style", &self.style); 63 formatter.field("bracket_token", &self.bracket_token); 64 formatter.field("path", &self.path); 65 formatter.field("tokens", &self.tokens); 66 formatter.finish() 67 } 68 } 69 #[cfg(any(feature = "derive", feature = "full"))] 70 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 71 impl Debug for BareFnArg { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result72 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 73 let mut formatter = formatter.debug_struct("BareFnArg"); 74 formatter.field("attrs", &self.attrs); 75 formatter.field("name", &self.name); 76 formatter.field("ty", &self.ty); 77 formatter.finish() 78 } 79 } 80 #[cfg(any(feature = "derive", feature = "full"))] 81 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 82 impl Debug for BinOp { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result83 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 84 match self { 85 BinOp::Add(v0) => { 86 let mut formatter = formatter.debug_tuple("Add"); 87 formatter.field(v0); 88 formatter.finish() 89 } 90 BinOp::Sub(v0) => { 91 let mut formatter = formatter.debug_tuple("Sub"); 92 formatter.field(v0); 93 formatter.finish() 94 } 95 BinOp::Mul(v0) => { 96 let mut formatter = formatter.debug_tuple("Mul"); 97 formatter.field(v0); 98 formatter.finish() 99 } 100 BinOp::Div(v0) => { 101 let mut formatter = formatter.debug_tuple("Div"); 102 formatter.field(v0); 103 formatter.finish() 104 } 105 BinOp::Rem(v0) => { 106 let mut formatter = formatter.debug_tuple("Rem"); 107 formatter.field(v0); 108 formatter.finish() 109 } 110 BinOp::And(v0) => { 111 let mut formatter = formatter.debug_tuple("And"); 112 formatter.field(v0); 113 formatter.finish() 114 } 115 BinOp::Or(v0) => { 116 let mut formatter = formatter.debug_tuple("Or"); 117 formatter.field(v0); 118 formatter.finish() 119 } 120 BinOp::BitXor(v0) => { 121 let mut formatter = formatter.debug_tuple("BitXor"); 122 formatter.field(v0); 123 formatter.finish() 124 } 125 BinOp::BitAnd(v0) => { 126 let mut formatter = formatter.debug_tuple("BitAnd"); 127 formatter.field(v0); 128 formatter.finish() 129 } 130 BinOp::BitOr(v0) => { 131 let mut formatter = formatter.debug_tuple("BitOr"); 132 formatter.field(v0); 133 formatter.finish() 134 } 135 BinOp::Shl(v0) => { 136 let mut formatter = formatter.debug_tuple("Shl"); 137 formatter.field(v0); 138 formatter.finish() 139 } 140 BinOp::Shr(v0) => { 141 let mut formatter = formatter.debug_tuple("Shr"); 142 formatter.field(v0); 143 formatter.finish() 144 } 145 BinOp::Eq(v0) => { 146 let mut formatter = formatter.debug_tuple("Eq"); 147 formatter.field(v0); 148 formatter.finish() 149 } 150 BinOp::Lt(v0) => { 151 let mut formatter = formatter.debug_tuple("Lt"); 152 formatter.field(v0); 153 formatter.finish() 154 } 155 BinOp::Le(v0) => { 156 let mut formatter = formatter.debug_tuple("Le"); 157 formatter.field(v0); 158 formatter.finish() 159 } 160 BinOp::Ne(v0) => { 161 let mut formatter = formatter.debug_tuple("Ne"); 162 formatter.field(v0); 163 formatter.finish() 164 } 165 BinOp::Ge(v0) => { 166 let mut formatter = formatter.debug_tuple("Ge"); 167 formatter.field(v0); 168 formatter.finish() 169 } 170 BinOp::Gt(v0) => { 171 let mut formatter = formatter.debug_tuple("Gt"); 172 formatter.field(v0); 173 formatter.finish() 174 } 175 BinOp::AddEq(v0) => { 176 let mut formatter = formatter.debug_tuple("AddEq"); 177 formatter.field(v0); 178 formatter.finish() 179 } 180 BinOp::SubEq(v0) => { 181 let mut formatter = formatter.debug_tuple("SubEq"); 182 formatter.field(v0); 183 formatter.finish() 184 } 185 BinOp::MulEq(v0) => { 186 let mut formatter = formatter.debug_tuple("MulEq"); 187 formatter.field(v0); 188 formatter.finish() 189 } 190 BinOp::DivEq(v0) => { 191 let mut formatter = formatter.debug_tuple("DivEq"); 192 formatter.field(v0); 193 formatter.finish() 194 } 195 BinOp::RemEq(v0) => { 196 let mut formatter = formatter.debug_tuple("RemEq"); 197 formatter.field(v0); 198 formatter.finish() 199 } 200 BinOp::BitXorEq(v0) => { 201 let mut formatter = formatter.debug_tuple("BitXorEq"); 202 formatter.field(v0); 203 formatter.finish() 204 } 205 BinOp::BitAndEq(v0) => { 206 let mut formatter = formatter.debug_tuple("BitAndEq"); 207 formatter.field(v0); 208 formatter.finish() 209 } 210 BinOp::BitOrEq(v0) => { 211 let mut formatter = formatter.debug_tuple("BitOrEq"); 212 formatter.field(v0); 213 formatter.finish() 214 } 215 BinOp::ShlEq(v0) => { 216 let mut formatter = formatter.debug_tuple("ShlEq"); 217 formatter.field(v0); 218 formatter.finish() 219 } 220 BinOp::ShrEq(v0) => { 221 let mut formatter = formatter.debug_tuple("ShrEq"); 222 formatter.field(v0); 223 formatter.finish() 224 } 225 } 226 } 227 } 228 #[cfg(any(feature = "derive", feature = "full"))] 229 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 230 impl Debug for Binding { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result231 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 232 let mut formatter = formatter.debug_struct("Binding"); 233 formatter.field("ident", &self.ident); 234 formatter.field("eq_token", &self.eq_token); 235 formatter.field("ty", &self.ty); 236 formatter.finish() 237 } 238 } 239 #[cfg(feature = "full")] 240 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 241 impl Debug for Block { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result242 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 243 let mut formatter = formatter.debug_struct("Block"); 244 formatter.field("brace_token", &self.brace_token); 245 formatter.field("stmts", &self.stmts); 246 formatter.finish() 247 } 248 } 249 #[cfg(any(feature = "derive", feature = "full"))] 250 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 251 impl Debug for BoundLifetimes { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result252 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 253 let mut formatter = formatter.debug_struct("BoundLifetimes"); 254 formatter.field("for_token", &self.for_token); 255 formatter.field("lt_token", &self.lt_token); 256 formatter.field("lifetimes", &self.lifetimes); 257 formatter.field("gt_token", &self.gt_token); 258 formatter.finish() 259 } 260 } 261 #[cfg(any(feature = "derive", feature = "full"))] 262 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 263 impl Debug for ConstParam { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result264 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 265 let mut formatter = formatter.debug_struct("ConstParam"); 266 formatter.field("attrs", &self.attrs); 267 formatter.field("const_token", &self.const_token); 268 formatter.field("ident", &self.ident); 269 formatter.field("colon_token", &self.colon_token); 270 formatter.field("ty", &self.ty); 271 formatter.field("eq_token", &self.eq_token); 272 formatter.field("default", &self.default); 273 formatter.finish() 274 } 275 } 276 #[cfg(any(feature = "derive", feature = "full"))] 277 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 278 impl Debug for Constraint { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result279 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 280 let mut formatter = formatter.debug_struct("Constraint"); 281 formatter.field("ident", &self.ident); 282 formatter.field("colon_token", &self.colon_token); 283 formatter.field("bounds", &self.bounds); 284 formatter.finish() 285 } 286 } 287 #[cfg(feature = "derive")] 288 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 289 impl Debug for Data { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result290 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 291 match self { 292 Data::Struct(v0) => { 293 let mut formatter = formatter.debug_tuple("Struct"); 294 formatter.field(v0); 295 formatter.finish() 296 } 297 Data::Enum(v0) => { 298 let mut formatter = formatter.debug_tuple("Enum"); 299 formatter.field(v0); 300 formatter.finish() 301 } 302 Data::Union(v0) => { 303 let mut formatter = formatter.debug_tuple("Union"); 304 formatter.field(v0); 305 formatter.finish() 306 } 307 } 308 } 309 } 310 #[cfg(feature = "derive")] 311 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 312 impl Debug for DataEnum { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result313 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 314 let mut formatter = formatter.debug_struct("DataEnum"); 315 formatter.field("enum_token", &self.enum_token); 316 formatter.field("brace_token", &self.brace_token); 317 formatter.field("variants", &self.variants); 318 formatter.finish() 319 } 320 } 321 #[cfg(feature = "derive")] 322 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 323 impl Debug for DataStruct { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result324 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 325 let mut formatter = formatter.debug_struct("DataStruct"); 326 formatter.field("struct_token", &self.struct_token); 327 formatter.field("fields", &self.fields); 328 formatter.field("semi_token", &self.semi_token); 329 formatter.finish() 330 } 331 } 332 #[cfg(feature = "derive")] 333 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 334 impl Debug for DataUnion { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result335 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 336 let mut formatter = formatter.debug_struct("DataUnion"); 337 formatter.field("union_token", &self.union_token); 338 formatter.field("fields", &self.fields); 339 formatter.finish() 340 } 341 } 342 #[cfg(feature = "derive")] 343 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 344 impl Debug for DeriveInput { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result345 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 346 let mut formatter = formatter.debug_struct("DeriveInput"); 347 formatter.field("attrs", &self.attrs); 348 formatter.field("vis", &self.vis); 349 formatter.field("ident", &self.ident); 350 formatter.field("generics", &self.generics); 351 formatter.field("data", &self.data); 352 formatter.finish() 353 } 354 } 355 #[cfg(any(feature = "derive", feature = "full"))] 356 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 357 impl Debug for Expr { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result358 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 359 match self { 360 #[cfg(feature = "full")] 361 Expr::Array(v0) => { 362 let mut formatter = formatter.debug_tuple("Array"); 363 formatter.field(v0); 364 formatter.finish() 365 } 366 #[cfg(feature = "full")] 367 Expr::Assign(v0) => { 368 let mut formatter = formatter.debug_tuple("Assign"); 369 formatter.field(v0); 370 formatter.finish() 371 } 372 #[cfg(feature = "full")] 373 Expr::AssignOp(v0) => { 374 let mut formatter = formatter.debug_tuple("AssignOp"); 375 formatter.field(v0); 376 formatter.finish() 377 } 378 #[cfg(feature = "full")] 379 Expr::Async(v0) => { 380 let mut formatter = formatter.debug_tuple("Async"); 381 formatter.field(v0); 382 formatter.finish() 383 } 384 #[cfg(feature = "full")] 385 Expr::Await(v0) => { 386 let mut formatter = formatter.debug_tuple("Await"); 387 formatter.field(v0); 388 formatter.finish() 389 } 390 Expr::Binary(v0) => { 391 let mut formatter = formatter.debug_tuple("Binary"); 392 formatter.field(v0); 393 formatter.finish() 394 } 395 #[cfg(feature = "full")] 396 Expr::Block(v0) => { 397 let mut formatter = formatter.debug_tuple("Block"); 398 formatter.field(v0); 399 formatter.finish() 400 } 401 #[cfg(feature = "full")] 402 Expr::Box(v0) => { 403 let mut formatter = formatter.debug_tuple("Box"); 404 formatter.field(v0); 405 formatter.finish() 406 } 407 #[cfg(feature = "full")] 408 Expr::Break(v0) => { 409 let mut formatter = formatter.debug_tuple("Break"); 410 formatter.field(v0); 411 formatter.finish() 412 } 413 Expr::Call(v0) => { 414 let mut formatter = formatter.debug_tuple("Call"); 415 formatter.field(v0); 416 formatter.finish() 417 } 418 Expr::Cast(v0) => { 419 let mut formatter = formatter.debug_tuple("Cast"); 420 formatter.field(v0); 421 formatter.finish() 422 } 423 #[cfg(feature = "full")] 424 Expr::Closure(v0) => { 425 let mut formatter = formatter.debug_tuple("Closure"); 426 formatter.field(v0); 427 formatter.finish() 428 } 429 #[cfg(feature = "full")] 430 Expr::Continue(v0) => { 431 let mut formatter = formatter.debug_tuple("Continue"); 432 formatter.field(v0); 433 formatter.finish() 434 } 435 Expr::Field(v0) => { 436 let mut formatter = formatter.debug_tuple("Field"); 437 formatter.field(v0); 438 formatter.finish() 439 } 440 #[cfg(feature = "full")] 441 Expr::ForLoop(v0) => { 442 let mut formatter = formatter.debug_tuple("ForLoop"); 443 formatter.field(v0); 444 formatter.finish() 445 } 446 #[cfg(feature = "full")] 447 Expr::Group(v0) => { 448 let mut formatter = formatter.debug_tuple("Group"); 449 formatter.field(v0); 450 formatter.finish() 451 } 452 #[cfg(feature = "full")] 453 Expr::If(v0) => { 454 let mut formatter = formatter.debug_tuple("If"); 455 formatter.field(v0); 456 formatter.finish() 457 } 458 Expr::Index(v0) => { 459 let mut formatter = formatter.debug_tuple("Index"); 460 formatter.field(v0); 461 formatter.finish() 462 } 463 #[cfg(feature = "full")] 464 Expr::Let(v0) => { 465 let mut formatter = formatter.debug_tuple("Let"); 466 formatter.field(v0); 467 formatter.finish() 468 } 469 Expr::Lit(v0) => { 470 let mut formatter = formatter.debug_tuple("Lit"); 471 formatter.field(v0); 472 formatter.finish() 473 } 474 #[cfg(feature = "full")] 475 Expr::Loop(v0) => { 476 let mut formatter = formatter.debug_tuple("Loop"); 477 formatter.field(v0); 478 formatter.finish() 479 } 480 #[cfg(feature = "full")] 481 Expr::Macro(v0) => { 482 let mut formatter = formatter.debug_tuple("Macro"); 483 formatter.field(v0); 484 formatter.finish() 485 } 486 #[cfg(feature = "full")] 487 Expr::Match(v0) => { 488 let mut formatter = formatter.debug_tuple("Match"); 489 formatter.field(v0); 490 formatter.finish() 491 } 492 #[cfg(feature = "full")] 493 Expr::MethodCall(v0) => { 494 let mut formatter = formatter.debug_tuple("MethodCall"); 495 formatter.field(v0); 496 formatter.finish() 497 } 498 Expr::Paren(v0) => { 499 let mut formatter = formatter.debug_tuple("Paren"); 500 formatter.field(v0); 501 formatter.finish() 502 } 503 Expr::Path(v0) => { 504 let mut formatter = formatter.debug_tuple("Path"); 505 formatter.field(v0); 506 formatter.finish() 507 } 508 #[cfg(feature = "full")] 509 Expr::Range(v0) => { 510 let mut formatter = formatter.debug_tuple("Range"); 511 formatter.field(v0); 512 formatter.finish() 513 } 514 #[cfg(feature = "full")] 515 Expr::Reference(v0) => { 516 let mut formatter = formatter.debug_tuple("Reference"); 517 formatter.field(v0); 518 formatter.finish() 519 } 520 #[cfg(feature = "full")] 521 Expr::Repeat(v0) => { 522 let mut formatter = formatter.debug_tuple("Repeat"); 523 formatter.field(v0); 524 formatter.finish() 525 } 526 #[cfg(feature = "full")] 527 Expr::Return(v0) => { 528 let mut formatter = formatter.debug_tuple("Return"); 529 formatter.field(v0); 530 formatter.finish() 531 } 532 #[cfg(feature = "full")] 533 Expr::Struct(v0) => { 534 let mut formatter = formatter.debug_tuple("Struct"); 535 formatter.field(v0); 536 formatter.finish() 537 } 538 #[cfg(feature = "full")] 539 Expr::Try(v0) => { 540 let mut formatter = formatter.debug_tuple("Try"); 541 formatter.field(v0); 542 formatter.finish() 543 } 544 #[cfg(feature = "full")] 545 Expr::TryBlock(v0) => { 546 let mut formatter = formatter.debug_tuple("TryBlock"); 547 formatter.field(v0); 548 formatter.finish() 549 } 550 #[cfg(feature = "full")] 551 Expr::Tuple(v0) => { 552 let mut formatter = formatter.debug_tuple("Tuple"); 553 formatter.field(v0); 554 formatter.finish() 555 } 556 #[cfg(feature = "full")] 557 Expr::Type(v0) => { 558 let mut formatter = formatter.debug_tuple("Type"); 559 formatter.field(v0); 560 formatter.finish() 561 } 562 Expr::Unary(v0) => { 563 let mut formatter = formatter.debug_tuple("Unary"); 564 formatter.field(v0); 565 formatter.finish() 566 } 567 #[cfg(feature = "full")] 568 Expr::Unsafe(v0) => { 569 let mut formatter = formatter.debug_tuple("Unsafe"); 570 formatter.field(v0); 571 formatter.finish() 572 } 573 Expr::Verbatim(v0) => { 574 let mut formatter = formatter.debug_tuple("Verbatim"); 575 formatter.field(v0); 576 formatter.finish() 577 } 578 #[cfg(feature = "full")] 579 Expr::While(v0) => { 580 let mut formatter = formatter.debug_tuple("While"); 581 formatter.field(v0); 582 formatter.finish() 583 } 584 #[cfg(feature = "full")] 585 Expr::Yield(v0) => { 586 let mut formatter = formatter.debug_tuple("Yield"); 587 formatter.field(v0); 588 formatter.finish() 589 } 590 #[cfg(any(syn_no_non_exhaustive, not(feature = "full")))] 591 _ => unreachable!(), 592 } 593 } 594 } 595 #[cfg(feature = "full")] 596 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 597 impl Debug for ExprArray { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result598 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 599 let mut formatter = formatter.debug_struct("ExprArray"); 600 formatter.field("attrs", &self.attrs); 601 formatter.field("bracket_token", &self.bracket_token); 602 formatter.field("elems", &self.elems); 603 formatter.finish() 604 } 605 } 606 #[cfg(feature = "full")] 607 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 608 impl Debug for ExprAssign { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result609 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 610 let mut formatter = formatter.debug_struct("ExprAssign"); 611 formatter.field("attrs", &self.attrs); 612 formatter.field("left", &self.left); 613 formatter.field("eq_token", &self.eq_token); 614 formatter.field("right", &self.right); 615 formatter.finish() 616 } 617 } 618 #[cfg(feature = "full")] 619 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 620 impl Debug for ExprAssignOp { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result621 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 622 let mut formatter = formatter.debug_struct("ExprAssignOp"); 623 formatter.field("attrs", &self.attrs); 624 formatter.field("left", &self.left); 625 formatter.field("op", &self.op); 626 formatter.field("right", &self.right); 627 formatter.finish() 628 } 629 } 630 #[cfg(feature = "full")] 631 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 632 impl Debug for ExprAsync { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result633 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 634 let mut formatter = formatter.debug_struct("ExprAsync"); 635 formatter.field("attrs", &self.attrs); 636 formatter.field("async_token", &self.async_token); 637 formatter.field("capture", &self.capture); 638 formatter.field("block", &self.block); 639 formatter.finish() 640 } 641 } 642 #[cfg(feature = "full")] 643 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 644 impl Debug for ExprAwait { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result645 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 646 let mut formatter = formatter.debug_struct("ExprAwait"); 647 formatter.field("attrs", &self.attrs); 648 formatter.field("base", &self.base); 649 formatter.field("dot_token", &self.dot_token); 650 formatter.field("await_token", &self.await_token); 651 formatter.finish() 652 } 653 } 654 #[cfg(any(feature = "derive", feature = "full"))] 655 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 656 impl Debug for ExprBinary { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result657 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 658 let mut formatter = formatter.debug_struct("ExprBinary"); 659 formatter.field("attrs", &self.attrs); 660 formatter.field("left", &self.left); 661 formatter.field("op", &self.op); 662 formatter.field("right", &self.right); 663 formatter.finish() 664 } 665 } 666 #[cfg(feature = "full")] 667 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 668 impl Debug for ExprBlock { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result669 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 670 let mut formatter = formatter.debug_struct("ExprBlock"); 671 formatter.field("attrs", &self.attrs); 672 formatter.field("label", &self.label); 673 formatter.field("block", &self.block); 674 formatter.finish() 675 } 676 } 677 #[cfg(feature = "full")] 678 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 679 impl Debug for ExprBox { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result680 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 681 let mut formatter = formatter.debug_struct("ExprBox"); 682 formatter.field("attrs", &self.attrs); 683 formatter.field("box_token", &self.box_token); 684 formatter.field("expr", &self.expr); 685 formatter.finish() 686 } 687 } 688 #[cfg(feature = "full")] 689 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 690 impl Debug for ExprBreak { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result691 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 692 let mut formatter = formatter.debug_struct("ExprBreak"); 693 formatter.field("attrs", &self.attrs); 694 formatter.field("break_token", &self.break_token); 695 formatter.field("label", &self.label); 696 formatter.field("expr", &self.expr); 697 formatter.finish() 698 } 699 } 700 #[cfg(any(feature = "derive", feature = "full"))] 701 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 702 impl Debug for ExprCall { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result703 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 704 let mut formatter = formatter.debug_struct("ExprCall"); 705 formatter.field("attrs", &self.attrs); 706 formatter.field("func", &self.func); 707 formatter.field("paren_token", &self.paren_token); 708 formatter.field("args", &self.args); 709 formatter.finish() 710 } 711 } 712 #[cfg(any(feature = "derive", feature = "full"))] 713 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 714 impl Debug for ExprCast { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result715 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 716 let mut formatter = formatter.debug_struct("ExprCast"); 717 formatter.field("attrs", &self.attrs); 718 formatter.field("expr", &self.expr); 719 formatter.field("as_token", &self.as_token); 720 formatter.field("ty", &self.ty); 721 formatter.finish() 722 } 723 } 724 #[cfg(feature = "full")] 725 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 726 impl Debug for ExprClosure { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result727 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 728 let mut formatter = formatter.debug_struct("ExprClosure"); 729 formatter.field("attrs", &self.attrs); 730 formatter.field("movability", &self.movability); 731 formatter.field("asyncness", &self.asyncness); 732 formatter.field("capture", &self.capture); 733 formatter.field("or1_token", &self.or1_token); 734 formatter.field("inputs", &self.inputs); 735 formatter.field("or2_token", &self.or2_token); 736 formatter.field("output", &self.output); 737 formatter.field("body", &self.body); 738 formatter.finish() 739 } 740 } 741 #[cfg(feature = "full")] 742 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 743 impl Debug for ExprContinue { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result744 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 745 let mut formatter = formatter.debug_struct("ExprContinue"); 746 formatter.field("attrs", &self.attrs); 747 formatter.field("continue_token", &self.continue_token); 748 formatter.field("label", &self.label); 749 formatter.finish() 750 } 751 } 752 #[cfg(any(feature = "derive", feature = "full"))] 753 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 754 impl Debug for ExprField { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result755 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 756 let mut formatter = formatter.debug_struct("ExprField"); 757 formatter.field("attrs", &self.attrs); 758 formatter.field("base", &self.base); 759 formatter.field("dot_token", &self.dot_token); 760 formatter.field("member", &self.member); 761 formatter.finish() 762 } 763 } 764 #[cfg(feature = "full")] 765 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 766 impl Debug for ExprForLoop { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result767 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 768 let mut formatter = formatter.debug_struct("ExprForLoop"); 769 formatter.field("attrs", &self.attrs); 770 formatter.field("label", &self.label); 771 formatter.field("for_token", &self.for_token); 772 formatter.field("pat", &self.pat); 773 formatter.field("in_token", &self.in_token); 774 formatter.field("expr", &self.expr); 775 formatter.field("body", &self.body); 776 formatter.finish() 777 } 778 } 779 #[cfg(feature = "full")] 780 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 781 impl Debug for ExprGroup { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result782 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 783 let mut formatter = formatter.debug_struct("ExprGroup"); 784 formatter.field("attrs", &self.attrs); 785 formatter.field("group_token", &self.group_token); 786 formatter.field("expr", &self.expr); 787 formatter.finish() 788 } 789 } 790 #[cfg(feature = "full")] 791 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 792 impl Debug for ExprIf { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result793 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 794 let mut formatter = formatter.debug_struct("ExprIf"); 795 formatter.field("attrs", &self.attrs); 796 formatter.field("if_token", &self.if_token); 797 formatter.field("cond", &self.cond); 798 formatter.field("then_branch", &self.then_branch); 799 formatter.field("else_branch", &self.else_branch); 800 formatter.finish() 801 } 802 } 803 #[cfg(any(feature = "derive", feature = "full"))] 804 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 805 impl Debug for ExprIndex { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result806 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 807 let mut formatter = formatter.debug_struct("ExprIndex"); 808 formatter.field("attrs", &self.attrs); 809 formatter.field("expr", &self.expr); 810 formatter.field("bracket_token", &self.bracket_token); 811 formatter.field("index", &self.index); 812 formatter.finish() 813 } 814 } 815 #[cfg(feature = "full")] 816 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 817 impl Debug for ExprLet { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result818 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 819 let mut formatter = formatter.debug_struct("ExprLet"); 820 formatter.field("attrs", &self.attrs); 821 formatter.field("let_token", &self.let_token); 822 formatter.field("pat", &self.pat); 823 formatter.field("eq_token", &self.eq_token); 824 formatter.field("expr", &self.expr); 825 formatter.finish() 826 } 827 } 828 #[cfg(any(feature = "derive", feature = "full"))] 829 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 830 impl Debug for ExprLit { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result831 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 832 let mut formatter = formatter.debug_struct("ExprLit"); 833 formatter.field("attrs", &self.attrs); 834 formatter.field("lit", &self.lit); 835 formatter.finish() 836 } 837 } 838 #[cfg(feature = "full")] 839 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 840 impl Debug for ExprLoop { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result841 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 842 let mut formatter = formatter.debug_struct("ExprLoop"); 843 formatter.field("attrs", &self.attrs); 844 formatter.field("label", &self.label); 845 formatter.field("loop_token", &self.loop_token); 846 formatter.field("body", &self.body); 847 formatter.finish() 848 } 849 } 850 #[cfg(feature = "full")] 851 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 852 impl Debug for ExprMacro { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result853 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 854 let mut formatter = formatter.debug_struct("ExprMacro"); 855 formatter.field("attrs", &self.attrs); 856 formatter.field("mac", &self.mac); 857 formatter.finish() 858 } 859 } 860 #[cfg(feature = "full")] 861 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 862 impl Debug for ExprMatch { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result863 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 864 let mut formatter = formatter.debug_struct("ExprMatch"); 865 formatter.field("attrs", &self.attrs); 866 formatter.field("match_token", &self.match_token); 867 formatter.field("expr", &self.expr); 868 formatter.field("brace_token", &self.brace_token); 869 formatter.field("arms", &self.arms); 870 formatter.finish() 871 } 872 } 873 #[cfg(feature = "full")] 874 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 875 impl Debug for ExprMethodCall { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result876 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 877 let mut formatter = formatter.debug_struct("ExprMethodCall"); 878 formatter.field("attrs", &self.attrs); 879 formatter.field("receiver", &self.receiver); 880 formatter.field("dot_token", &self.dot_token); 881 formatter.field("method", &self.method); 882 formatter.field("turbofish", &self.turbofish); 883 formatter.field("paren_token", &self.paren_token); 884 formatter.field("args", &self.args); 885 formatter.finish() 886 } 887 } 888 #[cfg(any(feature = "derive", feature = "full"))] 889 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 890 impl Debug for ExprParen { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result891 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 892 let mut formatter = formatter.debug_struct("ExprParen"); 893 formatter.field("attrs", &self.attrs); 894 formatter.field("paren_token", &self.paren_token); 895 formatter.field("expr", &self.expr); 896 formatter.finish() 897 } 898 } 899 #[cfg(any(feature = "derive", feature = "full"))] 900 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 901 impl Debug for ExprPath { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result902 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 903 let mut formatter = formatter.debug_struct("ExprPath"); 904 formatter.field("attrs", &self.attrs); 905 formatter.field("qself", &self.qself); 906 formatter.field("path", &self.path); 907 formatter.finish() 908 } 909 } 910 #[cfg(feature = "full")] 911 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 912 impl Debug for ExprRange { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result913 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 914 let mut formatter = formatter.debug_struct("ExprRange"); 915 formatter.field("attrs", &self.attrs); 916 formatter.field("from", &self.from); 917 formatter.field("limits", &self.limits); 918 formatter.field("to", &self.to); 919 formatter.finish() 920 } 921 } 922 #[cfg(feature = "full")] 923 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 924 impl Debug for ExprReference { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result925 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 926 let mut formatter = formatter.debug_struct("ExprReference"); 927 formatter.field("attrs", &self.attrs); 928 formatter.field("and_token", &self.and_token); 929 formatter.field("raw", &self.raw); 930 formatter.field("mutability", &self.mutability); 931 formatter.field("expr", &self.expr); 932 formatter.finish() 933 } 934 } 935 #[cfg(feature = "full")] 936 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 937 impl Debug for ExprRepeat { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result938 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 939 let mut formatter = formatter.debug_struct("ExprRepeat"); 940 formatter.field("attrs", &self.attrs); 941 formatter.field("bracket_token", &self.bracket_token); 942 formatter.field("expr", &self.expr); 943 formatter.field("semi_token", &self.semi_token); 944 formatter.field("len", &self.len); 945 formatter.finish() 946 } 947 } 948 #[cfg(feature = "full")] 949 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 950 impl Debug for ExprReturn { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result951 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 952 let mut formatter = formatter.debug_struct("ExprReturn"); 953 formatter.field("attrs", &self.attrs); 954 formatter.field("return_token", &self.return_token); 955 formatter.field("expr", &self.expr); 956 formatter.finish() 957 } 958 } 959 #[cfg(feature = "full")] 960 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 961 impl Debug for ExprStruct { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result962 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 963 let mut formatter = formatter.debug_struct("ExprStruct"); 964 formatter.field("attrs", &self.attrs); 965 formatter.field("path", &self.path); 966 formatter.field("brace_token", &self.brace_token); 967 formatter.field("fields", &self.fields); 968 formatter.field("dot2_token", &self.dot2_token); 969 formatter.field("rest", &self.rest); 970 formatter.finish() 971 } 972 } 973 #[cfg(feature = "full")] 974 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 975 impl Debug for ExprTry { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result976 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 977 let mut formatter = formatter.debug_struct("ExprTry"); 978 formatter.field("attrs", &self.attrs); 979 formatter.field("expr", &self.expr); 980 formatter.field("question_token", &self.question_token); 981 formatter.finish() 982 } 983 } 984 #[cfg(feature = "full")] 985 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 986 impl Debug for ExprTryBlock { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result987 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 988 let mut formatter = formatter.debug_struct("ExprTryBlock"); 989 formatter.field("attrs", &self.attrs); 990 formatter.field("try_token", &self.try_token); 991 formatter.field("block", &self.block); 992 formatter.finish() 993 } 994 } 995 #[cfg(feature = "full")] 996 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 997 impl Debug for ExprTuple { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result998 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 999 let mut formatter = formatter.debug_struct("ExprTuple"); 1000 formatter.field("attrs", &self.attrs); 1001 formatter.field("paren_token", &self.paren_token); 1002 formatter.field("elems", &self.elems); 1003 formatter.finish() 1004 } 1005 } 1006 #[cfg(feature = "full")] 1007 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1008 impl Debug for ExprType { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1009 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1010 let mut formatter = formatter.debug_struct("ExprType"); 1011 formatter.field("attrs", &self.attrs); 1012 formatter.field("expr", &self.expr); 1013 formatter.field("colon_token", &self.colon_token); 1014 formatter.field("ty", &self.ty); 1015 formatter.finish() 1016 } 1017 } 1018 #[cfg(any(feature = "derive", feature = "full"))] 1019 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1020 impl Debug for ExprUnary { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1021 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1022 let mut formatter = formatter.debug_struct("ExprUnary"); 1023 formatter.field("attrs", &self.attrs); 1024 formatter.field("op", &self.op); 1025 formatter.field("expr", &self.expr); 1026 formatter.finish() 1027 } 1028 } 1029 #[cfg(feature = "full")] 1030 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1031 impl Debug for ExprUnsafe { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1032 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1033 let mut formatter = formatter.debug_struct("ExprUnsafe"); 1034 formatter.field("attrs", &self.attrs); 1035 formatter.field("unsafe_token", &self.unsafe_token); 1036 formatter.field("block", &self.block); 1037 formatter.finish() 1038 } 1039 } 1040 #[cfg(feature = "full")] 1041 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1042 impl Debug for ExprWhile { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1043 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1044 let mut formatter = formatter.debug_struct("ExprWhile"); 1045 formatter.field("attrs", &self.attrs); 1046 formatter.field("label", &self.label); 1047 formatter.field("while_token", &self.while_token); 1048 formatter.field("cond", &self.cond); 1049 formatter.field("body", &self.body); 1050 formatter.finish() 1051 } 1052 } 1053 #[cfg(feature = "full")] 1054 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1055 impl Debug for ExprYield { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1056 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1057 let mut formatter = formatter.debug_struct("ExprYield"); 1058 formatter.field("attrs", &self.attrs); 1059 formatter.field("yield_token", &self.yield_token); 1060 formatter.field("expr", &self.expr); 1061 formatter.finish() 1062 } 1063 } 1064 #[cfg(any(feature = "derive", feature = "full"))] 1065 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1066 impl Debug for Field { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1067 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1068 let mut formatter = formatter.debug_struct("Field"); 1069 formatter.field("attrs", &self.attrs); 1070 formatter.field("vis", &self.vis); 1071 formatter.field("ident", &self.ident); 1072 formatter.field("colon_token", &self.colon_token); 1073 formatter.field("ty", &self.ty); 1074 formatter.finish() 1075 } 1076 } 1077 #[cfg(feature = "full")] 1078 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1079 impl Debug for FieldPat { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1080 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1081 let mut formatter = formatter.debug_struct("FieldPat"); 1082 formatter.field("attrs", &self.attrs); 1083 formatter.field("member", &self.member); 1084 formatter.field("colon_token", &self.colon_token); 1085 formatter.field("pat", &self.pat); 1086 formatter.finish() 1087 } 1088 } 1089 #[cfg(feature = "full")] 1090 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1091 impl Debug for FieldValue { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1092 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1093 let mut formatter = formatter.debug_struct("FieldValue"); 1094 formatter.field("attrs", &self.attrs); 1095 formatter.field("member", &self.member); 1096 formatter.field("colon_token", &self.colon_token); 1097 formatter.field("expr", &self.expr); 1098 formatter.finish() 1099 } 1100 } 1101 #[cfg(any(feature = "derive", feature = "full"))] 1102 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1103 impl Debug for Fields { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1104 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1105 match self { 1106 Fields::Named(v0) => { 1107 let mut formatter = formatter.debug_tuple("Named"); 1108 formatter.field(v0); 1109 formatter.finish() 1110 } 1111 Fields::Unnamed(v0) => { 1112 let mut formatter = formatter.debug_tuple("Unnamed"); 1113 formatter.field(v0); 1114 formatter.finish() 1115 } 1116 Fields::Unit => formatter.write_str("Unit"), 1117 } 1118 } 1119 } 1120 #[cfg(any(feature = "derive", feature = "full"))] 1121 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1122 impl Debug for FieldsNamed { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1123 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1124 let mut formatter = formatter.debug_struct("FieldsNamed"); 1125 formatter.field("brace_token", &self.brace_token); 1126 formatter.field("named", &self.named); 1127 formatter.finish() 1128 } 1129 } 1130 #[cfg(any(feature = "derive", feature = "full"))] 1131 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1132 impl Debug for FieldsUnnamed { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1133 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1134 let mut formatter = formatter.debug_struct("FieldsUnnamed"); 1135 formatter.field("paren_token", &self.paren_token); 1136 formatter.field("unnamed", &self.unnamed); 1137 formatter.finish() 1138 } 1139 } 1140 #[cfg(feature = "full")] 1141 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1142 impl Debug for File { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1143 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1144 let mut formatter = formatter.debug_struct("File"); 1145 formatter.field("shebang", &self.shebang); 1146 formatter.field("attrs", &self.attrs); 1147 formatter.field("items", &self.items); 1148 formatter.finish() 1149 } 1150 } 1151 #[cfg(feature = "full")] 1152 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1153 impl Debug for FnArg { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1154 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1155 match self { 1156 FnArg::Receiver(v0) => { 1157 let mut formatter = formatter.debug_tuple("Receiver"); 1158 formatter.field(v0); 1159 formatter.finish() 1160 } 1161 FnArg::Typed(v0) => { 1162 let mut formatter = formatter.debug_tuple("Typed"); 1163 formatter.field(v0); 1164 formatter.finish() 1165 } 1166 } 1167 } 1168 } 1169 #[cfg(feature = "full")] 1170 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1171 impl Debug for ForeignItem { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1172 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1173 match self { 1174 ForeignItem::Fn(v0) => { 1175 let mut formatter = formatter.debug_tuple("Fn"); 1176 formatter.field(v0); 1177 formatter.finish() 1178 } 1179 ForeignItem::Static(v0) => { 1180 let mut formatter = formatter.debug_tuple("Static"); 1181 formatter.field(v0); 1182 formatter.finish() 1183 } 1184 ForeignItem::Type(v0) => { 1185 let mut formatter = formatter.debug_tuple("Type"); 1186 formatter.field(v0); 1187 formatter.finish() 1188 } 1189 ForeignItem::Macro(v0) => { 1190 let mut formatter = formatter.debug_tuple("Macro"); 1191 formatter.field(v0); 1192 formatter.finish() 1193 } 1194 ForeignItem::Verbatim(v0) => { 1195 let mut formatter = formatter.debug_tuple("Verbatim"); 1196 formatter.field(v0); 1197 formatter.finish() 1198 } 1199 #[cfg(syn_no_non_exhaustive)] 1200 _ => unreachable!(), 1201 } 1202 } 1203 } 1204 #[cfg(feature = "full")] 1205 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1206 impl Debug for ForeignItemFn { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1207 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1208 let mut formatter = formatter.debug_struct("ForeignItemFn"); 1209 formatter.field("attrs", &self.attrs); 1210 formatter.field("vis", &self.vis); 1211 formatter.field("sig", &self.sig); 1212 formatter.field("semi_token", &self.semi_token); 1213 formatter.finish() 1214 } 1215 } 1216 #[cfg(feature = "full")] 1217 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1218 impl Debug for ForeignItemMacro { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1219 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1220 let mut formatter = formatter.debug_struct("ForeignItemMacro"); 1221 formatter.field("attrs", &self.attrs); 1222 formatter.field("mac", &self.mac); 1223 formatter.field("semi_token", &self.semi_token); 1224 formatter.finish() 1225 } 1226 } 1227 #[cfg(feature = "full")] 1228 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1229 impl Debug for ForeignItemStatic { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1230 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1231 let mut formatter = formatter.debug_struct("ForeignItemStatic"); 1232 formatter.field("attrs", &self.attrs); 1233 formatter.field("vis", &self.vis); 1234 formatter.field("static_token", &self.static_token); 1235 formatter.field("mutability", &self.mutability); 1236 formatter.field("ident", &self.ident); 1237 formatter.field("colon_token", &self.colon_token); 1238 formatter.field("ty", &self.ty); 1239 formatter.field("semi_token", &self.semi_token); 1240 formatter.finish() 1241 } 1242 } 1243 #[cfg(feature = "full")] 1244 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1245 impl Debug for ForeignItemType { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1246 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1247 let mut formatter = formatter.debug_struct("ForeignItemType"); 1248 formatter.field("attrs", &self.attrs); 1249 formatter.field("vis", &self.vis); 1250 formatter.field("type_token", &self.type_token); 1251 formatter.field("ident", &self.ident); 1252 formatter.field("semi_token", &self.semi_token); 1253 formatter.finish() 1254 } 1255 } 1256 #[cfg(any(feature = "derive", feature = "full"))] 1257 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1258 impl Debug for GenericArgument { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1259 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1260 match self { 1261 GenericArgument::Lifetime(v0) => { 1262 let mut formatter = formatter.debug_tuple("Lifetime"); 1263 formatter.field(v0); 1264 formatter.finish() 1265 } 1266 GenericArgument::Type(v0) => { 1267 let mut formatter = formatter.debug_tuple("Type"); 1268 formatter.field(v0); 1269 formatter.finish() 1270 } 1271 GenericArgument::Const(v0) => { 1272 let mut formatter = formatter.debug_tuple("Const"); 1273 formatter.field(v0); 1274 formatter.finish() 1275 } 1276 GenericArgument::Binding(v0) => { 1277 let mut formatter = formatter.debug_tuple("Binding"); 1278 formatter.field(v0); 1279 formatter.finish() 1280 } 1281 GenericArgument::Constraint(v0) => { 1282 let mut formatter = formatter.debug_tuple("Constraint"); 1283 formatter.field(v0); 1284 formatter.finish() 1285 } 1286 } 1287 } 1288 } 1289 #[cfg(feature = "full")] 1290 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1291 impl Debug for GenericMethodArgument { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1292 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1293 match self { 1294 GenericMethodArgument::Type(v0) => { 1295 let mut formatter = formatter.debug_tuple("Type"); 1296 formatter.field(v0); 1297 formatter.finish() 1298 } 1299 GenericMethodArgument::Const(v0) => { 1300 let mut formatter = formatter.debug_tuple("Const"); 1301 formatter.field(v0); 1302 formatter.finish() 1303 } 1304 } 1305 } 1306 } 1307 #[cfg(any(feature = "derive", feature = "full"))] 1308 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1309 impl Debug for GenericParam { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1310 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1311 match self { 1312 GenericParam::Type(v0) => { 1313 let mut formatter = formatter.debug_tuple("Type"); 1314 formatter.field(v0); 1315 formatter.finish() 1316 } 1317 GenericParam::Lifetime(v0) => { 1318 let mut formatter = formatter.debug_tuple("Lifetime"); 1319 formatter.field(v0); 1320 formatter.finish() 1321 } 1322 GenericParam::Const(v0) => { 1323 let mut formatter = formatter.debug_tuple("Const"); 1324 formatter.field(v0); 1325 formatter.finish() 1326 } 1327 } 1328 } 1329 } 1330 #[cfg(any(feature = "derive", feature = "full"))] 1331 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1332 impl Debug for Generics { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1333 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1334 let mut formatter = formatter.debug_struct("Generics"); 1335 formatter.field("lt_token", &self.lt_token); 1336 formatter.field("params", &self.params); 1337 formatter.field("gt_token", &self.gt_token); 1338 formatter.field("where_clause", &self.where_clause); 1339 formatter.finish() 1340 } 1341 } 1342 #[cfg(feature = "full")] 1343 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1344 impl Debug for ImplItem { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1345 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1346 match self { 1347 ImplItem::Const(v0) => { 1348 let mut formatter = formatter.debug_tuple("Const"); 1349 formatter.field(v0); 1350 formatter.finish() 1351 } 1352 ImplItem::Method(v0) => { 1353 let mut formatter = formatter.debug_tuple("Method"); 1354 formatter.field(v0); 1355 formatter.finish() 1356 } 1357 ImplItem::Type(v0) => { 1358 let mut formatter = formatter.debug_tuple("Type"); 1359 formatter.field(v0); 1360 formatter.finish() 1361 } 1362 ImplItem::Macro(v0) => { 1363 let mut formatter = formatter.debug_tuple("Macro"); 1364 formatter.field(v0); 1365 formatter.finish() 1366 } 1367 ImplItem::Verbatim(v0) => { 1368 let mut formatter = formatter.debug_tuple("Verbatim"); 1369 formatter.field(v0); 1370 formatter.finish() 1371 } 1372 #[cfg(syn_no_non_exhaustive)] 1373 _ => unreachable!(), 1374 } 1375 } 1376 } 1377 #[cfg(feature = "full")] 1378 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1379 impl Debug for ImplItemConst { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1380 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1381 let mut formatter = formatter.debug_struct("ImplItemConst"); 1382 formatter.field("attrs", &self.attrs); 1383 formatter.field("vis", &self.vis); 1384 formatter.field("defaultness", &self.defaultness); 1385 formatter.field("const_token", &self.const_token); 1386 formatter.field("ident", &self.ident); 1387 formatter.field("colon_token", &self.colon_token); 1388 formatter.field("ty", &self.ty); 1389 formatter.field("eq_token", &self.eq_token); 1390 formatter.field("expr", &self.expr); 1391 formatter.field("semi_token", &self.semi_token); 1392 formatter.finish() 1393 } 1394 } 1395 #[cfg(feature = "full")] 1396 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1397 impl Debug for ImplItemMacro { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1398 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1399 let mut formatter = formatter.debug_struct("ImplItemMacro"); 1400 formatter.field("attrs", &self.attrs); 1401 formatter.field("mac", &self.mac); 1402 formatter.field("semi_token", &self.semi_token); 1403 formatter.finish() 1404 } 1405 } 1406 #[cfg(feature = "full")] 1407 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1408 impl Debug for ImplItemMethod { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1409 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1410 let mut formatter = formatter.debug_struct("ImplItemMethod"); 1411 formatter.field("attrs", &self.attrs); 1412 formatter.field("vis", &self.vis); 1413 formatter.field("defaultness", &self.defaultness); 1414 formatter.field("sig", &self.sig); 1415 formatter.field("block", &self.block); 1416 formatter.finish() 1417 } 1418 } 1419 #[cfg(feature = "full")] 1420 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1421 impl Debug for ImplItemType { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1422 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1423 let mut formatter = formatter.debug_struct("ImplItemType"); 1424 formatter.field("attrs", &self.attrs); 1425 formatter.field("vis", &self.vis); 1426 formatter.field("defaultness", &self.defaultness); 1427 formatter.field("type_token", &self.type_token); 1428 formatter.field("ident", &self.ident); 1429 formatter.field("generics", &self.generics); 1430 formatter.field("eq_token", &self.eq_token); 1431 formatter.field("ty", &self.ty); 1432 formatter.field("semi_token", &self.semi_token); 1433 formatter.finish() 1434 } 1435 } 1436 #[cfg(any(feature = "derive", feature = "full"))] 1437 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1438 impl Debug for Index { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1439 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1440 let mut formatter = formatter.debug_struct("Index"); 1441 formatter.field("index", &self.index); 1442 formatter.field("span", &self.span); 1443 formatter.finish() 1444 } 1445 } 1446 #[cfg(feature = "full")] 1447 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1448 impl Debug for Item { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1449 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1450 match self { 1451 Item::Const(v0) => { 1452 let mut formatter = formatter.debug_tuple("Const"); 1453 formatter.field(v0); 1454 formatter.finish() 1455 } 1456 Item::Enum(v0) => { 1457 let mut formatter = formatter.debug_tuple("Enum"); 1458 formatter.field(v0); 1459 formatter.finish() 1460 } 1461 Item::ExternCrate(v0) => { 1462 let mut formatter = formatter.debug_tuple("ExternCrate"); 1463 formatter.field(v0); 1464 formatter.finish() 1465 } 1466 Item::Fn(v0) => { 1467 let mut formatter = formatter.debug_tuple("Fn"); 1468 formatter.field(v0); 1469 formatter.finish() 1470 } 1471 Item::ForeignMod(v0) => { 1472 let mut formatter = formatter.debug_tuple("ForeignMod"); 1473 formatter.field(v0); 1474 formatter.finish() 1475 } 1476 Item::Impl(v0) => { 1477 let mut formatter = formatter.debug_tuple("Impl"); 1478 formatter.field(v0); 1479 formatter.finish() 1480 } 1481 Item::Macro(v0) => { 1482 let mut formatter = formatter.debug_tuple("Macro"); 1483 formatter.field(v0); 1484 formatter.finish() 1485 } 1486 Item::Macro2(v0) => { 1487 let mut formatter = formatter.debug_tuple("Macro2"); 1488 formatter.field(v0); 1489 formatter.finish() 1490 } 1491 Item::Mod(v0) => { 1492 let mut formatter = formatter.debug_tuple("Mod"); 1493 formatter.field(v0); 1494 formatter.finish() 1495 } 1496 Item::Static(v0) => { 1497 let mut formatter = formatter.debug_tuple("Static"); 1498 formatter.field(v0); 1499 formatter.finish() 1500 } 1501 Item::Struct(v0) => { 1502 let mut formatter = formatter.debug_tuple("Struct"); 1503 formatter.field(v0); 1504 formatter.finish() 1505 } 1506 Item::Trait(v0) => { 1507 let mut formatter = formatter.debug_tuple("Trait"); 1508 formatter.field(v0); 1509 formatter.finish() 1510 } 1511 Item::TraitAlias(v0) => { 1512 let mut formatter = formatter.debug_tuple("TraitAlias"); 1513 formatter.field(v0); 1514 formatter.finish() 1515 } 1516 Item::Type(v0) => { 1517 let mut formatter = formatter.debug_tuple("Type"); 1518 formatter.field(v0); 1519 formatter.finish() 1520 } 1521 Item::Union(v0) => { 1522 let mut formatter = formatter.debug_tuple("Union"); 1523 formatter.field(v0); 1524 formatter.finish() 1525 } 1526 Item::Use(v0) => { 1527 let mut formatter = formatter.debug_tuple("Use"); 1528 formatter.field(v0); 1529 formatter.finish() 1530 } 1531 Item::Verbatim(v0) => { 1532 let mut formatter = formatter.debug_tuple("Verbatim"); 1533 formatter.field(v0); 1534 formatter.finish() 1535 } 1536 #[cfg(syn_no_non_exhaustive)] 1537 _ => unreachable!(), 1538 } 1539 } 1540 } 1541 #[cfg(feature = "full")] 1542 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1543 impl Debug for ItemConst { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1544 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1545 let mut formatter = formatter.debug_struct("ItemConst"); 1546 formatter.field("attrs", &self.attrs); 1547 formatter.field("vis", &self.vis); 1548 formatter.field("const_token", &self.const_token); 1549 formatter.field("ident", &self.ident); 1550 formatter.field("colon_token", &self.colon_token); 1551 formatter.field("ty", &self.ty); 1552 formatter.field("eq_token", &self.eq_token); 1553 formatter.field("expr", &self.expr); 1554 formatter.field("semi_token", &self.semi_token); 1555 formatter.finish() 1556 } 1557 } 1558 #[cfg(feature = "full")] 1559 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1560 impl Debug for ItemEnum { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1561 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1562 let mut formatter = formatter.debug_struct("ItemEnum"); 1563 formatter.field("attrs", &self.attrs); 1564 formatter.field("vis", &self.vis); 1565 formatter.field("enum_token", &self.enum_token); 1566 formatter.field("ident", &self.ident); 1567 formatter.field("generics", &self.generics); 1568 formatter.field("brace_token", &self.brace_token); 1569 formatter.field("variants", &self.variants); 1570 formatter.finish() 1571 } 1572 } 1573 #[cfg(feature = "full")] 1574 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1575 impl Debug for ItemExternCrate { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1576 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1577 let mut formatter = formatter.debug_struct("ItemExternCrate"); 1578 formatter.field("attrs", &self.attrs); 1579 formatter.field("vis", &self.vis); 1580 formatter.field("extern_token", &self.extern_token); 1581 formatter.field("crate_token", &self.crate_token); 1582 formatter.field("ident", &self.ident); 1583 formatter.field("rename", &self.rename); 1584 formatter.field("semi_token", &self.semi_token); 1585 formatter.finish() 1586 } 1587 } 1588 #[cfg(feature = "full")] 1589 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1590 impl Debug for ItemFn { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1591 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1592 let mut formatter = formatter.debug_struct("ItemFn"); 1593 formatter.field("attrs", &self.attrs); 1594 formatter.field("vis", &self.vis); 1595 formatter.field("sig", &self.sig); 1596 formatter.field("block", &self.block); 1597 formatter.finish() 1598 } 1599 } 1600 #[cfg(feature = "full")] 1601 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1602 impl Debug for ItemForeignMod { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1603 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1604 let mut formatter = formatter.debug_struct("ItemForeignMod"); 1605 formatter.field("attrs", &self.attrs); 1606 formatter.field("abi", &self.abi); 1607 formatter.field("brace_token", &self.brace_token); 1608 formatter.field("items", &self.items); 1609 formatter.finish() 1610 } 1611 } 1612 #[cfg(feature = "full")] 1613 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1614 impl Debug for ItemImpl { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1615 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1616 let mut formatter = formatter.debug_struct("ItemImpl"); 1617 formatter.field("attrs", &self.attrs); 1618 formatter.field("defaultness", &self.defaultness); 1619 formatter.field("unsafety", &self.unsafety); 1620 formatter.field("impl_token", &self.impl_token); 1621 formatter.field("generics", &self.generics); 1622 formatter.field("trait_", &self.trait_); 1623 formatter.field("self_ty", &self.self_ty); 1624 formatter.field("brace_token", &self.brace_token); 1625 formatter.field("items", &self.items); 1626 formatter.finish() 1627 } 1628 } 1629 #[cfg(feature = "full")] 1630 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1631 impl Debug for ItemMacro { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1632 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1633 let mut formatter = formatter.debug_struct("ItemMacro"); 1634 formatter.field("attrs", &self.attrs); 1635 formatter.field("ident", &self.ident); 1636 formatter.field("mac", &self.mac); 1637 formatter.field("semi_token", &self.semi_token); 1638 formatter.finish() 1639 } 1640 } 1641 #[cfg(feature = "full")] 1642 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1643 impl Debug for ItemMacro2 { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1644 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1645 let mut formatter = formatter.debug_struct("ItemMacro2"); 1646 formatter.field("attrs", &self.attrs); 1647 formatter.field("vis", &self.vis); 1648 formatter.field("macro_token", &self.macro_token); 1649 formatter.field("ident", &self.ident); 1650 formatter.field("rules", &self.rules); 1651 formatter.finish() 1652 } 1653 } 1654 #[cfg(feature = "full")] 1655 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1656 impl Debug for ItemMod { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1657 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1658 let mut formatter = formatter.debug_struct("ItemMod"); 1659 formatter.field("attrs", &self.attrs); 1660 formatter.field("vis", &self.vis); 1661 formatter.field("mod_token", &self.mod_token); 1662 formatter.field("ident", &self.ident); 1663 formatter.field("content", &self.content); 1664 formatter.field("semi", &self.semi); 1665 formatter.finish() 1666 } 1667 } 1668 #[cfg(feature = "full")] 1669 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1670 impl Debug for ItemStatic { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1671 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1672 let mut formatter = formatter.debug_struct("ItemStatic"); 1673 formatter.field("attrs", &self.attrs); 1674 formatter.field("vis", &self.vis); 1675 formatter.field("static_token", &self.static_token); 1676 formatter.field("mutability", &self.mutability); 1677 formatter.field("ident", &self.ident); 1678 formatter.field("colon_token", &self.colon_token); 1679 formatter.field("ty", &self.ty); 1680 formatter.field("eq_token", &self.eq_token); 1681 formatter.field("expr", &self.expr); 1682 formatter.field("semi_token", &self.semi_token); 1683 formatter.finish() 1684 } 1685 } 1686 #[cfg(feature = "full")] 1687 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1688 impl Debug for ItemStruct { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1689 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1690 let mut formatter = formatter.debug_struct("ItemStruct"); 1691 formatter.field("attrs", &self.attrs); 1692 formatter.field("vis", &self.vis); 1693 formatter.field("struct_token", &self.struct_token); 1694 formatter.field("ident", &self.ident); 1695 formatter.field("generics", &self.generics); 1696 formatter.field("fields", &self.fields); 1697 formatter.field("semi_token", &self.semi_token); 1698 formatter.finish() 1699 } 1700 } 1701 #[cfg(feature = "full")] 1702 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1703 impl Debug for ItemTrait { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1704 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1705 let mut formatter = formatter.debug_struct("ItemTrait"); 1706 formatter.field("attrs", &self.attrs); 1707 formatter.field("vis", &self.vis); 1708 formatter.field("unsafety", &self.unsafety); 1709 formatter.field("auto_token", &self.auto_token); 1710 formatter.field("trait_token", &self.trait_token); 1711 formatter.field("ident", &self.ident); 1712 formatter.field("generics", &self.generics); 1713 formatter.field("colon_token", &self.colon_token); 1714 formatter.field("supertraits", &self.supertraits); 1715 formatter.field("brace_token", &self.brace_token); 1716 formatter.field("items", &self.items); 1717 formatter.finish() 1718 } 1719 } 1720 #[cfg(feature = "full")] 1721 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1722 impl Debug for ItemTraitAlias { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1723 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1724 let mut formatter = formatter.debug_struct("ItemTraitAlias"); 1725 formatter.field("attrs", &self.attrs); 1726 formatter.field("vis", &self.vis); 1727 formatter.field("trait_token", &self.trait_token); 1728 formatter.field("ident", &self.ident); 1729 formatter.field("generics", &self.generics); 1730 formatter.field("eq_token", &self.eq_token); 1731 formatter.field("bounds", &self.bounds); 1732 formatter.field("semi_token", &self.semi_token); 1733 formatter.finish() 1734 } 1735 } 1736 #[cfg(feature = "full")] 1737 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1738 impl Debug for ItemType { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1739 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1740 let mut formatter = formatter.debug_struct("ItemType"); 1741 formatter.field("attrs", &self.attrs); 1742 formatter.field("vis", &self.vis); 1743 formatter.field("type_token", &self.type_token); 1744 formatter.field("ident", &self.ident); 1745 formatter.field("generics", &self.generics); 1746 formatter.field("eq_token", &self.eq_token); 1747 formatter.field("ty", &self.ty); 1748 formatter.field("semi_token", &self.semi_token); 1749 formatter.finish() 1750 } 1751 } 1752 #[cfg(feature = "full")] 1753 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1754 impl Debug for ItemUnion { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1755 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1756 let mut formatter = formatter.debug_struct("ItemUnion"); 1757 formatter.field("attrs", &self.attrs); 1758 formatter.field("vis", &self.vis); 1759 formatter.field("union_token", &self.union_token); 1760 formatter.field("ident", &self.ident); 1761 formatter.field("generics", &self.generics); 1762 formatter.field("fields", &self.fields); 1763 formatter.finish() 1764 } 1765 } 1766 #[cfg(feature = "full")] 1767 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1768 impl Debug for ItemUse { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1769 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1770 let mut formatter = formatter.debug_struct("ItemUse"); 1771 formatter.field("attrs", &self.attrs); 1772 formatter.field("vis", &self.vis); 1773 formatter.field("use_token", &self.use_token); 1774 formatter.field("leading_colon", &self.leading_colon); 1775 formatter.field("tree", &self.tree); 1776 formatter.field("semi_token", &self.semi_token); 1777 formatter.finish() 1778 } 1779 } 1780 #[cfg(feature = "full")] 1781 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1782 impl Debug for Label { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1783 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1784 let mut formatter = formatter.debug_struct("Label"); 1785 formatter.field("name", &self.name); 1786 formatter.field("colon_token", &self.colon_token); 1787 formatter.finish() 1788 } 1789 } 1790 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1791 impl Debug for Lifetime { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1792 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1793 let mut formatter = formatter.debug_struct("Lifetime"); 1794 formatter.field("apostrophe", &self.apostrophe); 1795 formatter.field("ident", &self.ident); 1796 formatter.finish() 1797 } 1798 } 1799 #[cfg(any(feature = "derive", feature = "full"))] 1800 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1801 impl Debug for LifetimeDef { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1802 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1803 let mut formatter = formatter.debug_struct("LifetimeDef"); 1804 formatter.field("attrs", &self.attrs); 1805 formatter.field("lifetime", &self.lifetime); 1806 formatter.field("colon_token", &self.colon_token); 1807 formatter.field("bounds", &self.bounds); 1808 formatter.finish() 1809 } 1810 } 1811 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1812 impl Debug for Lit { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1813 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1814 match self { 1815 Lit::Str(v0) => { 1816 let mut formatter = formatter.debug_tuple("Str"); 1817 formatter.field(v0); 1818 formatter.finish() 1819 } 1820 Lit::ByteStr(v0) => { 1821 let mut formatter = formatter.debug_tuple("ByteStr"); 1822 formatter.field(v0); 1823 formatter.finish() 1824 } 1825 Lit::Byte(v0) => { 1826 let mut formatter = formatter.debug_tuple("Byte"); 1827 formatter.field(v0); 1828 formatter.finish() 1829 } 1830 Lit::Char(v0) => { 1831 let mut formatter = formatter.debug_tuple("Char"); 1832 formatter.field(v0); 1833 formatter.finish() 1834 } 1835 Lit::Int(v0) => { 1836 let mut formatter = formatter.debug_tuple("Int"); 1837 formatter.field(v0); 1838 formatter.finish() 1839 } 1840 Lit::Float(v0) => { 1841 let mut formatter = formatter.debug_tuple("Float"); 1842 formatter.field(v0); 1843 formatter.finish() 1844 } 1845 Lit::Bool(v0) => { 1846 let mut formatter = formatter.debug_tuple("Bool"); 1847 formatter.field(v0); 1848 formatter.finish() 1849 } 1850 Lit::Verbatim(v0) => { 1851 let mut formatter = formatter.debug_tuple("Verbatim"); 1852 formatter.field(v0); 1853 formatter.finish() 1854 } 1855 } 1856 } 1857 } 1858 #[cfg(feature = "full")] 1859 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1860 impl Debug for Local { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1861 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1862 let mut formatter = formatter.debug_struct("Local"); 1863 formatter.field("attrs", &self.attrs); 1864 formatter.field("let_token", &self.let_token); 1865 formatter.field("pat", &self.pat); 1866 formatter.field("init", &self.init); 1867 formatter.field("semi_token", &self.semi_token); 1868 formatter.finish() 1869 } 1870 } 1871 #[cfg(any(feature = "derive", feature = "full"))] 1872 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1873 impl Debug for Macro { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1874 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1875 let mut formatter = formatter.debug_struct("Macro"); 1876 formatter.field("path", &self.path); 1877 formatter.field("bang_token", &self.bang_token); 1878 formatter.field("delimiter", &self.delimiter); 1879 formatter.field("tokens", &self.tokens); 1880 formatter.finish() 1881 } 1882 } 1883 #[cfg(any(feature = "derive", feature = "full"))] 1884 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1885 impl Debug for MacroDelimiter { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1886 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1887 match self { 1888 MacroDelimiter::Paren(v0) => { 1889 let mut formatter = formatter.debug_tuple("Paren"); 1890 formatter.field(v0); 1891 formatter.finish() 1892 } 1893 MacroDelimiter::Brace(v0) => { 1894 let mut formatter = formatter.debug_tuple("Brace"); 1895 formatter.field(v0); 1896 formatter.finish() 1897 } 1898 MacroDelimiter::Bracket(v0) => { 1899 let mut formatter = formatter.debug_tuple("Bracket"); 1900 formatter.field(v0); 1901 formatter.finish() 1902 } 1903 } 1904 } 1905 } 1906 #[cfg(any(feature = "derive", feature = "full"))] 1907 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1908 impl Debug for Member { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1909 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1910 match self { 1911 Member::Named(v0) => { 1912 let mut formatter = formatter.debug_tuple("Named"); 1913 formatter.field(v0); 1914 formatter.finish() 1915 } 1916 Member::Unnamed(v0) => { 1917 let mut formatter = formatter.debug_tuple("Unnamed"); 1918 formatter.field(v0); 1919 formatter.finish() 1920 } 1921 } 1922 } 1923 } 1924 #[cfg(any(feature = "derive", feature = "full"))] 1925 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1926 impl Debug for Meta { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1927 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1928 match self { 1929 Meta::Path(v0) => { 1930 let mut formatter = formatter.debug_tuple("Path"); 1931 formatter.field(v0); 1932 formatter.finish() 1933 } 1934 Meta::List(v0) => { 1935 let mut formatter = formatter.debug_tuple("List"); 1936 formatter.field(v0); 1937 formatter.finish() 1938 } 1939 Meta::NameValue(v0) => { 1940 let mut formatter = formatter.debug_tuple("NameValue"); 1941 formatter.field(v0); 1942 formatter.finish() 1943 } 1944 } 1945 } 1946 } 1947 #[cfg(any(feature = "derive", feature = "full"))] 1948 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1949 impl Debug for MetaList { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1950 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1951 let mut formatter = formatter.debug_struct("MetaList"); 1952 formatter.field("path", &self.path); 1953 formatter.field("paren_token", &self.paren_token); 1954 formatter.field("nested", &self.nested); 1955 formatter.finish() 1956 } 1957 } 1958 #[cfg(any(feature = "derive", feature = "full"))] 1959 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1960 impl Debug for MetaNameValue { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1961 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1962 let mut formatter = formatter.debug_struct("MetaNameValue"); 1963 formatter.field("path", &self.path); 1964 formatter.field("eq_token", &self.eq_token); 1965 formatter.field("lit", &self.lit); 1966 formatter.finish() 1967 } 1968 } 1969 #[cfg(feature = "full")] 1970 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1971 impl Debug for MethodTurbofish { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1972 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1973 let mut formatter = formatter.debug_struct("MethodTurbofish"); 1974 formatter.field("colon2_token", &self.colon2_token); 1975 formatter.field("lt_token", &self.lt_token); 1976 formatter.field("args", &self.args); 1977 formatter.field("gt_token", &self.gt_token); 1978 formatter.finish() 1979 } 1980 } 1981 #[cfg(any(feature = "derive", feature = "full"))] 1982 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 1983 impl Debug for NestedMeta { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1984 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1985 match self { 1986 NestedMeta::Meta(v0) => { 1987 let mut formatter = formatter.debug_tuple("Meta"); 1988 formatter.field(v0); 1989 formatter.finish() 1990 } 1991 NestedMeta::Lit(v0) => { 1992 let mut formatter = formatter.debug_tuple("Lit"); 1993 formatter.field(v0); 1994 formatter.finish() 1995 } 1996 } 1997 } 1998 } 1999 #[cfg(any(feature = "derive", feature = "full"))] 2000 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2001 impl Debug for ParenthesizedGenericArguments { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2002 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2003 let mut formatter = formatter.debug_struct("ParenthesizedGenericArguments"); 2004 formatter.field("paren_token", &self.paren_token); 2005 formatter.field("inputs", &self.inputs); 2006 formatter.field("output", &self.output); 2007 formatter.finish() 2008 } 2009 } 2010 #[cfg(feature = "full")] 2011 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2012 impl Debug for Pat { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2013 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2014 match self { 2015 Pat::Box(v0) => { 2016 let mut formatter = formatter.debug_tuple("Box"); 2017 formatter.field(v0); 2018 formatter.finish() 2019 } 2020 Pat::Ident(v0) => { 2021 let mut formatter = formatter.debug_tuple("Ident"); 2022 formatter.field(v0); 2023 formatter.finish() 2024 } 2025 Pat::Lit(v0) => { 2026 let mut formatter = formatter.debug_tuple("Lit"); 2027 formatter.field(v0); 2028 formatter.finish() 2029 } 2030 Pat::Macro(v0) => { 2031 let mut formatter = formatter.debug_tuple("Macro"); 2032 formatter.field(v0); 2033 formatter.finish() 2034 } 2035 Pat::Or(v0) => { 2036 let mut formatter = formatter.debug_tuple("Or"); 2037 formatter.field(v0); 2038 formatter.finish() 2039 } 2040 Pat::Path(v0) => { 2041 let mut formatter = formatter.debug_tuple("Path"); 2042 formatter.field(v0); 2043 formatter.finish() 2044 } 2045 Pat::Range(v0) => { 2046 let mut formatter = formatter.debug_tuple("Range"); 2047 formatter.field(v0); 2048 formatter.finish() 2049 } 2050 Pat::Reference(v0) => { 2051 let mut formatter = formatter.debug_tuple("Reference"); 2052 formatter.field(v0); 2053 formatter.finish() 2054 } 2055 Pat::Rest(v0) => { 2056 let mut formatter = formatter.debug_tuple("Rest"); 2057 formatter.field(v0); 2058 formatter.finish() 2059 } 2060 Pat::Slice(v0) => { 2061 let mut formatter = formatter.debug_tuple("Slice"); 2062 formatter.field(v0); 2063 formatter.finish() 2064 } 2065 Pat::Struct(v0) => { 2066 let mut formatter = formatter.debug_tuple("Struct"); 2067 formatter.field(v0); 2068 formatter.finish() 2069 } 2070 Pat::Tuple(v0) => { 2071 let mut formatter = formatter.debug_tuple("Tuple"); 2072 formatter.field(v0); 2073 formatter.finish() 2074 } 2075 Pat::TupleStruct(v0) => { 2076 let mut formatter = formatter.debug_tuple("TupleStruct"); 2077 formatter.field(v0); 2078 formatter.finish() 2079 } 2080 Pat::Type(v0) => { 2081 let mut formatter = formatter.debug_tuple("Type"); 2082 formatter.field(v0); 2083 formatter.finish() 2084 } 2085 Pat::Verbatim(v0) => { 2086 let mut formatter = formatter.debug_tuple("Verbatim"); 2087 formatter.field(v0); 2088 formatter.finish() 2089 } 2090 Pat::Wild(v0) => { 2091 let mut formatter = formatter.debug_tuple("Wild"); 2092 formatter.field(v0); 2093 formatter.finish() 2094 } 2095 #[cfg(syn_no_non_exhaustive)] 2096 _ => unreachable!(), 2097 } 2098 } 2099 } 2100 #[cfg(feature = "full")] 2101 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2102 impl Debug for PatBox { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2103 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2104 let mut formatter = formatter.debug_struct("PatBox"); 2105 formatter.field("attrs", &self.attrs); 2106 formatter.field("box_token", &self.box_token); 2107 formatter.field("pat", &self.pat); 2108 formatter.finish() 2109 } 2110 } 2111 #[cfg(feature = "full")] 2112 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2113 impl Debug for PatIdent { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2114 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2115 let mut formatter = formatter.debug_struct("PatIdent"); 2116 formatter.field("attrs", &self.attrs); 2117 formatter.field("by_ref", &self.by_ref); 2118 formatter.field("mutability", &self.mutability); 2119 formatter.field("ident", &self.ident); 2120 formatter.field("subpat", &self.subpat); 2121 formatter.finish() 2122 } 2123 } 2124 #[cfg(feature = "full")] 2125 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2126 impl Debug for PatLit { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2127 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2128 let mut formatter = formatter.debug_struct("PatLit"); 2129 formatter.field("attrs", &self.attrs); 2130 formatter.field("expr", &self.expr); 2131 formatter.finish() 2132 } 2133 } 2134 #[cfg(feature = "full")] 2135 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2136 impl Debug for PatMacro { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2137 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2138 let mut formatter = formatter.debug_struct("PatMacro"); 2139 formatter.field("attrs", &self.attrs); 2140 formatter.field("mac", &self.mac); 2141 formatter.finish() 2142 } 2143 } 2144 #[cfg(feature = "full")] 2145 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2146 impl Debug for PatOr { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2147 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2148 let mut formatter = formatter.debug_struct("PatOr"); 2149 formatter.field("attrs", &self.attrs); 2150 formatter.field("leading_vert", &self.leading_vert); 2151 formatter.field("cases", &self.cases); 2152 formatter.finish() 2153 } 2154 } 2155 #[cfg(feature = "full")] 2156 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2157 impl Debug for PatPath { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2158 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2159 let mut formatter = formatter.debug_struct("PatPath"); 2160 formatter.field("attrs", &self.attrs); 2161 formatter.field("qself", &self.qself); 2162 formatter.field("path", &self.path); 2163 formatter.finish() 2164 } 2165 } 2166 #[cfg(feature = "full")] 2167 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2168 impl Debug for PatRange { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2169 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2170 let mut formatter = formatter.debug_struct("PatRange"); 2171 formatter.field("attrs", &self.attrs); 2172 formatter.field("lo", &self.lo); 2173 formatter.field("limits", &self.limits); 2174 formatter.field("hi", &self.hi); 2175 formatter.finish() 2176 } 2177 } 2178 #[cfg(feature = "full")] 2179 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2180 impl Debug for PatReference { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2181 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2182 let mut formatter = formatter.debug_struct("PatReference"); 2183 formatter.field("attrs", &self.attrs); 2184 formatter.field("and_token", &self.and_token); 2185 formatter.field("mutability", &self.mutability); 2186 formatter.field("pat", &self.pat); 2187 formatter.finish() 2188 } 2189 } 2190 #[cfg(feature = "full")] 2191 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2192 impl Debug for PatRest { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2193 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2194 let mut formatter = formatter.debug_struct("PatRest"); 2195 formatter.field("attrs", &self.attrs); 2196 formatter.field("dot2_token", &self.dot2_token); 2197 formatter.finish() 2198 } 2199 } 2200 #[cfg(feature = "full")] 2201 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2202 impl Debug for PatSlice { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2203 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2204 let mut formatter = formatter.debug_struct("PatSlice"); 2205 formatter.field("attrs", &self.attrs); 2206 formatter.field("bracket_token", &self.bracket_token); 2207 formatter.field("elems", &self.elems); 2208 formatter.finish() 2209 } 2210 } 2211 #[cfg(feature = "full")] 2212 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2213 impl Debug for PatStruct { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2214 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2215 let mut formatter = formatter.debug_struct("PatStruct"); 2216 formatter.field("attrs", &self.attrs); 2217 formatter.field("path", &self.path); 2218 formatter.field("brace_token", &self.brace_token); 2219 formatter.field("fields", &self.fields); 2220 formatter.field("dot2_token", &self.dot2_token); 2221 formatter.finish() 2222 } 2223 } 2224 #[cfg(feature = "full")] 2225 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2226 impl Debug for PatTuple { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2227 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2228 let mut formatter = formatter.debug_struct("PatTuple"); 2229 formatter.field("attrs", &self.attrs); 2230 formatter.field("paren_token", &self.paren_token); 2231 formatter.field("elems", &self.elems); 2232 formatter.finish() 2233 } 2234 } 2235 #[cfg(feature = "full")] 2236 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2237 impl Debug for PatTupleStruct { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2238 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2239 let mut formatter = formatter.debug_struct("PatTupleStruct"); 2240 formatter.field("attrs", &self.attrs); 2241 formatter.field("path", &self.path); 2242 formatter.field("pat", &self.pat); 2243 formatter.finish() 2244 } 2245 } 2246 #[cfg(feature = "full")] 2247 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2248 impl Debug for PatType { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2249 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2250 let mut formatter = formatter.debug_struct("PatType"); 2251 formatter.field("attrs", &self.attrs); 2252 formatter.field("pat", &self.pat); 2253 formatter.field("colon_token", &self.colon_token); 2254 formatter.field("ty", &self.ty); 2255 formatter.finish() 2256 } 2257 } 2258 #[cfg(feature = "full")] 2259 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2260 impl Debug for PatWild { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2261 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2262 let mut formatter = formatter.debug_struct("PatWild"); 2263 formatter.field("attrs", &self.attrs); 2264 formatter.field("underscore_token", &self.underscore_token); 2265 formatter.finish() 2266 } 2267 } 2268 #[cfg(any(feature = "derive", feature = "full"))] 2269 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2270 impl Debug for Path { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2271 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2272 let mut formatter = formatter.debug_struct("Path"); 2273 formatter.field("leading_colon", &self.leading_colon); 2274 formatter.field("segments", &self.segments); 2275 formatter.finish() 2276 } 2277 } 2278 #[cfg(any(feature = "derive", feature = "full"))] 2279 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2280 impl Debug for PathArguments { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2281 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2282 match self { 2283 PathArguments::None => formatter.write_str("None"), 2284 PathArguments::AngleBracketed(v0) => { 2285 let mut formatter = formatter.debug_tuple("AngleBracketed"); 2286 formatter.field(v0); 2287 formatter.finish() 2288 } 2289 PathArguments::Parenthesized(v0) => { 2290 let mut formatter = formatter.debug_tuple("Parenthesized"); 2291 formatter.field(v0); 2292 formatter.finish() 2293 } 2294 } 2295 } 2296 } 2297 #[cfg(any(feature = "derive", feature = "full"))] 2298 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2299 impl Debug for PathSegment { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2300 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2301 let mut formatter = formatter.debug_struct("PathSegment"); 2302 formatter.field("ident", &self.ident); 2303 formatter.field("arguments", &self.arguments); 2304 formatter.finish() 2305 } 2306 } 2307 #[cfg(any(feature = "derive", feature = "full"))] 2308 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2309 impl Debug for PredicateEq { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2310 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2311 let mut formatter = formatter.debug_struct("PredicateEq"); 2312 formatter.field("lhs_ty", &self.lhs_ty); 2313 formatter.field("eq_token", &self.eq_token); 2314 formatter.field("rhs_ty", &self.rhs_ty); 2315 formatter.finish() 2316 } 2317 } 2318 #[cfg(any(feature = "derive", feature = "full"))] 2319 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2320 impl Debug for PredicateLifetime { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2321 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2322 let mut formatter = formatter.debug_struct("PredicateLifetime"); 2323 formatter.field("lifetime", &self.lifetime); 2324 formatter.field("colon_token", &self.colon_token); 2325 formatter.field("bounds", &self.bounds); 2326 formatter.finish() 2327 } 2328 } 2329 #[cfg(any(feature = "derive", feature = "full"))] 2330 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2331 impl Debug for PredicateType { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2332 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2333 let mut formatter = formatter.debug_struct("PredicateType"); 2334 formatter.field("lifetimes", &self.lifetimes); 2335 formatter.field("bounded_ty", &self.bounded_ty); 2336 formatter.field("colon_token", &self.colon_token); 2337 formatter.field("bounds", &self.bounds); 2338 formatter.finish() 2339 } 2340 } 2341 #[cfg(any(feature = "derive", feature = "full"))] 2342 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2343 impl Debug for QSelf { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2344 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2345 let mut formatter = formatter.debug_struct("QSelf"); 2346 formatter.field("lt_token", &self.lt_token); 2347 formatter.field("ty", &self.ty); 2348 formatter.field("position", &self.position); 2349 formatter.field("as_token", &self.as_token); 2350 formatter.field("gt_token", &self.gt_token); 2351 formatter.finish() 2352 } 2353 } 2354 #[cfg(feature = "full")] 2355 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2356 impl Debug for RangeLimits { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2357 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2358 match self { 2359 RangeLimits::HalfOpen(v0) => { 2360 let mut formatter = formatter.debug_tuple("HalfOpen"); 2361 formatter.field(v0); 2362 formatter.finish() 2363 } 2364 RangeLimits::Closed(v0) => { 2365 let mut formatter = formatter.debug_tuple("Closed"); 2366 formatter.field(v0); 2367 formatter.finish() 2368 } 2369 } 2370 } 2371 } 2372 #[cfg(feature = "full")] 2373 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2374 impl Debug for Receiver { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2375 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2376 let mut formatter = formatter.debug_struct("Receiver"); 2377 formatter.field("attrs", &self.attrs); 2378 formatter.field("reference", &self.reference); 2379 formatter.field("mutability", &self.mutability); 2380 formatter.field("self_token", &self.self_token); 2381 formatter.finish() 2382 } 2383 } 2384 #[cfg(any(feature = "derive", feature = "full"))] 2385 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2386 impl Debug for ReturnType { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2387 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2388 match self { 2389 ReturnType::Default => formatter.write_str("Default"), 2390 ReturnType::Type(v0, v1) => { 2391 let mut formatter = formatter.debug_tuple("Type"); 2392 formatter.field(v0); 2393 formatter.field(v1); 2394 formatter.finish() 2395 } 2396 } 2397 } 2398 } 2399 #[cfg(feature = "full")] 2400 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2401 impl Debug for Signature { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2402 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2403 let mut formatter = formatter.debug_struct("Signature"); 2404 formatter.field("constness", &self.constness); 2405 formatter.field("asyncness", &self.asyncness); 2406 formatter.field("unsafety", &self.unsafety); 2407 formatter.field("abi", &self.abi); 2408 formatter.field("fn_token", &self.fn_token); 2409 formatter.field("ident", &self.ident); 2410 formatter.field("generics", &self.generics); 2411 formatter.field("paren_token", &self.paren_token); 2412 formatter.field("inputs", &self.inputs); 2413 formatter.field("variadic", &self.variadic); 2414 formatter.field("output", &self.output); 2415 formatter.finish() 2416 } 2417 } 2418 #[cfg(feature = "full")] 2419 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2420 impl Debug for Stmt { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2421 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2422 match self { 2423 Stmt::Local(v0) => { 2424 let mut formatter = formatter.debug_tuple("Local"); 2425 formatter.field(v0); 2426 formatter.finish() 2427 } 2428 Stmt::Item(v0) => { 2429 let mut formatter = formatter.debug_tuple("Item"); 2430 formatter.field(v0); 2431 formatter.finish() 2432 } 2433 Stmt::Expr(v0) => { 2434 let mut formatter = formatter.debug_tuple("Expr"); 2435 formatter.field(v0); 2436 formatter.finish() 2437 } 2438 Stmt::Semi(v0, v1) => { 2439 let mut formatter = formatter.debug_tuple("Semi"); 2440 formatter.field(v0); 2441 formatter.field(v1); 2442 formatter.finish() 2443 } 2444 } 2445 } 2446 } 2447 #[cfg(any(feature = "derive", feature = "full"))] 2448 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2449 impl Debug for TraitBound { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2450 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2451 let mut formatter = formatter.debug_struct("TraitBound"); 2452 formatter.field("paren_token", &self.paren_token); 2453 formatter.field("modifier", &self.modifier); 2454 formatter.field("lifetimes", &self.lifetimes); 2455 formatter.field("path", &self.path); 2456 formatter.finish() 2457 } 2458 } 2459 #[cfg(any(feature = "derive", feature = "full"))] 2460 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2461 impl Debug for TraitBoundModifier { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2462 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2463 match self { 2464 TraitBoundModifier::None => formatter.write_str("None"), 2465 TraitBoundModifier::Maybe(v0) => { 2466 let mut formatter = formatter.debug_tuple("Maybe"); 2467 formatter.field(v0); 2468 formatter.finish() 2469 } 2470 } 2471 } 2472 } 2473 #[cfg(feature = "full")] 2474 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2475 impl Debug for TraitItem { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2476 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2477 match self { 2478 TraitItem::Const(v0) => { 2479 let mut formatter = formatter.debug_tuple("Const"); 2480 formatter.field(v0); 2481 formatter.finish() 2482 } 2483 TraitItem::Method(v0) => { 2484 let mut formatter = formatter.debug_tuple("Method"); 2485 formatter.field(v0); 2486 formatter.finish() 2487 } 2488 TraitItem::Type(v0) => { 2489 let mut formatter = formatter.debug_tuple("Type"); 2490 formatter.field(v0); 2491 formatter.finish() 2492 } 2493 TraitItem::Macro(v0) => { 2494 let mut formatter = formatter.debug_tuple("Macro"); 2495 formatter.field(v0); 2496 formatter.finish() 2497 } 2498 TraitItem::Verbatim(v0) => { 2499 let mut formatter = formatter.debug_tuple("Verbatim"); 2500 formatter.field(v0); 2501 formatter.finish() 2502 } 2503 #[cfg(syn_no_non_exhaustive)] 2504 _ => unreachable!(), 2505 } 2506 } 2507 } 2508 #[cfg(feature = "full")] 2509 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2510 impl Debug for TraitItemConst { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2511 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2512 let mut formatter = formatter.debug_struct("TraitItemConst"); 2513 formatter.field("attrs", &self.attrs); 2514 formatter.field("const_token", &self.const_token); 2515 formatter.field("ident", &self.ident); 2516 formatter.field("colon_token", &self.colon_token); 2517 formatter.field("ty", &self.ty); 2518 formatter.field("default", &self.default); 2519 formatter.field("semi_token", &self.semi_token); 2520 formatter.finish() 2521 } 2522 } 2523 #[cfg(feature = "full")] 2524 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2525 impl Debug for TraitItemMacro { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2526 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2527 let mut formatter = formatter.debug_struct("TraitItemMacro"); 2528 formatter.field("attrs", &self.attrs); 2529 formatter.field("mac", &self.mac); 2530 formatter.field("semi_token", &self.semi_token); 2531 formatter.finish() 2532 } 2533 } 2534 #[cfg(feature = "full")] 2535 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2536 impl Debug for TraitItemMethod { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2537 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2538 let mut formatter = formatter.debug_struct("TraitItemMethod"); 2539 formatter.field("attrs", &self.attrs); 2540 formatter.field("sig", &self.sig); 2541 formatter.field("default", &self.default); 2542 formatter.field("semi_token", &self.semi_token); 2543 formatter.finish() 2544 } 2545 } 2546 #[cfg(feature = "full")] 2547 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2548 impl Debug for TraitItemType { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2549 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2550 let mut formatter = formatter.debug_struct("TraitItemType"); 2551 formatter.field("attrs", &self.attrs); 2552 formatter.field("type_token", &self.type_token); 2553 formatter.field("ident", &self.ident); 2554 formatter.field("generics", &self.generics); 2555 formatter.field("colon_token", &self.colon_token); 2556 formatter.field("bounds", &self.bounds); 2557 formatter.field("default", &self.default); 2558 formatter.field("semi_token", &self.semi_token); 2559 formatter.finish() 2560 } 2561 } 2562 #[cfg(any(feature = "derive", feature = "full"))] 2563 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2564 impl Debug for Type { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2565 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2566 match self { 2567 Type::Array(v0) => { 2568 let mut formatter = formatter.debug_tuple("Array"); 2569 formatter.field(v0); 2570 formatter.finish() 2571 } 2572 Type::BareFn(v0) => { 2573 let mut formatter = formatter.debug_tuple("BareFn"); 2574 formatter.field(v0); 2575 formatter.finish() 2576 } 2577 Type::Group(v0) => { 2578 let mut formatter = formatter.debug_tuple("Group"); 2579 formatter.field(v0); 2580 formatter.finish() 2581 } 2582 Type::ImplTrait(v0) => { 2583 let mut formatter = formatter.debug_tuple("ImplTrait"); 2584 formatter.field(v0); 2585 formatter.finish() 2586 } 2587 Type::Infer(v0) => { 2588 let mut formatter = formatter.debug_tuple("Infer"); 2589 formatter.field(v0); 2590 formatter.finish() 2591 } 2592 Type::Macro(v0) => { 2593 let mut formatter = formatter.debug_tuple("Macro"); 2594 formatter.field(v0); 2595 formatter.finish() 2596 } 2597 Type::Never(v0) => { 2598 let mut formatter = formatter.debug_tuple("Never"); 2599 formatter.field(v0); 2600 formatter.finish() 2601 } 2602 Type::Paren(v0) => { 2603 let mut formatter = formatter.debug_tuple("Paren"); 2604 formatter.field(v0); 2605 formatter.finish() 2606 } 2607 Type::Path(v0) => { 2608 let mut formatter = formatter.debug_tuple("Path"); 2609 formatter.field(v0); 2610 formatter.finish() 2611 } 2612 Type::Ptr(v0) => { 2613 let mut formatter = formatter.debug_tuple("Ptr"); 2614 formatter.field(v0); 2615 formatter.finish() 2616 } 2617 Type::Reference(v0) => { 2618 let mut formatter = formatter.debug_tuple("Reference"); 2619 formatter.field(v0); 2620 formatter.finish() 2621 } 2622 Type::Slice(v0) => { 2623 let mut formatter = formatter.debug_tuple("Slice"); 2624 formatter.field(v0); 2625 formatter.finish() 2626 } 2627 Type::TraitObject(v0) => { 2628 let mut formatter = formatter.debug_tuple("TraitObject"); 2629 formatter.field(v0); 2630 formatter.finish() 2631 } 2632 Type::Tuple(v0) => { 2633 let mut formatter = formatter.debug_tuple("Tuple"); 2634 formatter.field(v0); 2635 formatter.finish() 2636 } 2637 Type::Verbatim(v0) => { 2638 let mut formatter = formatter.debug_tuple("Verbatim"); 2639 formatter.field(v0); 2640 formatter.finish() 2641 } 2642 #[cfg(syn_no_non_exhaustive)] 2643 _ => unreachable!(), 2644 } 2645 } 2646 } 2647 #[cfg(any(feature = "derive", feature = "full"))] 2648 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2649 impl Debug for TypeArray { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2650 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2651 let mut formatter = formatter.debug_struct("TypeArray"); 2652 formatter.field("bracket_token", &self.bracket_token); 2653 formatter.field("elem", &self.elem); 2654 formatter.field("semi_token", &self.semi_token); 2655 formatter.field("len", &self.len); 2656 formatter.finish() 2657 } 2658 } 2659 #[cfg(any(feature = "derive", feature = "full"))] 2660 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2661 impl Debug for TypeBareFn { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2662 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2663 let mut formatter = formatter.debug_struct("TypeBareFn"); 2664 formatter.field("lifetimes", &self.lifetimes); 2665 formatter.field("unsafety", &self.unsafety); 2666 formatter.field("abi", &self.abi); 2667 formatter.field("fn_token", &self.fn_token); 2668 formatter.field("paren_token", &self.paren_token); 2669 formatter.field("inputs", &self.inputs); 2670 formatter.field("variadic", &self.variadic); 2671 formatter.field("output", &self.output); 2672 formatter.finish() 2673 } 2674 } 2675 #[cfg(any(feature = "derive", feature = "full"))] 2676 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2677 impl Debug for TypeGroup { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2678 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2679 let mut formatter = formatter.debug_struct("TypeGroup"); 2680 formatter.field("group_token", &self.group_token); 2681 formatter.field("elem", &self.elem); 2682 formatter.finish() 2683 } 2684 } 2685 #[cfg(any(feature = "derive", feature = "full"))] 2686 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2687 impl Debug for TypeImplTrait { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2688 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2689 let mut formatter = formatter.debug_struct("TypeImplTrait"); 2690 formatter.field("impl_token", &self.impl_token); 2691 formatter.field("bounds", &self.bounds); 2692 formatter.finish() 2693 } 2694 } 2695 #[cfg(any(feature = "derive", feature = "full"))] 2696 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2697 impl Debug for TypeInfer { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2698 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2699 let mut formatter = formatter.debug_struct("TypeInfer"); 2700 formatter.field("underscore_token", &self.underscore_token); 2701 formatter.finish() 2702 } 2703 } 2704 #[cfg(any(feature = "derive", feature = "full"))] 2705 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2706 impl Debug for TypeMacro { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2707 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2708 let mut formatter = formatter.debug_struct("TypeMacro"); 2709 formatter.field("mac", &self.mac); 2710 formatter.finish() 2711 } 2712 } 2713 #[cfg(any(feature = "derive", feature = "full"))] 2714 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2715 impl Debug for TypeNever { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2716 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2717 let mut formatter = formatter.debug_struct("TypeNever"); 2718 formatter.field("bang_token", &self.bang_token); 2719 formatter.finish() 2720 } 2721 } 2722 #[cfg(any(feature = "derive", feature = "full"))] 2723 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2724 impl Debug for TypeParam { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2725 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2726 let mut formatter = formatter.debug_struct("TypeParam"); 2727 formatter.field("attrs", &self.attrs); 2728 formatter.field("ident", &self.ident); 2729 formatter.field("colon_token", &self.colon_token); 2730 formatter.field("bounds", &self.bounds); 2731 formatter.field("eq_token", &self.eq_token); 2732 formatter.field("default", &self.default); 2733 formatter.finish() 2734 } 2735 } 2736 #[cfg(any(feature = "derive", feature = "full"))] 2737 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2738 impl Debug for TypeParamBound { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2739 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2740 match self { 2741 TypeParamBound::Trait(v0) => { 2742 let mut formatter = formatter.debug_tuple("Trait"); 2743 formatter.field(v0); 2744 formatter.finish() 2745 } 2746 TypeParamBound::Lifetime(v0) => { 2747 let mut formatter = formatter.debug_tuple("Lifetime"); 2748 formatter.field(v0); 2749 formatter.finish() 2750 } 2751 } 2752 } 2753 } 2754 #[cfg(any(feature = "derive", feature = "full"))] 2755 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2756 impl Debug for TypeParen { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2757 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2758 let mut formatter = formatter.debug_struct("TypeParen"); 2759 formatter.field("paren_token", &self.paren_token); 2760 formatter.field("elem", &self.elem); 2761 formatter.finish() 2762 } 2763 } 2764 #[cfg(any(feature = "derive", feature = "full"))] 2765 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2766 impl Debug for TypePath { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2767 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2768 let mut formatter = formatter.debug_struct("TypePath"); 2769 formatter.field("qself", &self.qself); 2770 formatter.field("path", &self.path); 2771 formatter.finish() 2772 } 2773 } 2774 #[cfg(any(feature = "derive", feature = "full"))] 2775 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2776 impl Debug for TypePtr { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2777 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2778 let mut formatter = formatter.debug_struct("TypePtr"); 2779 formatter.field("star_token", &self.star_token); 2780 formatter.field("const_token", &self.const_token); 2781 formatter.field("mutability", &self.mutability); 2782 formatter.field("elem", &self.elem); 2783 formatter.finish() 2784 } 2785 } 2786 #[cfg(any(feature = "derive", feature = "full"))] 2787 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2788 impl Debug for TypeReference { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2789 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2790 let mut formatter = formatter.debug_struct("TypeReference"); 2791 formatter.field("and_token", &self.and_token); 2792 formatter.field("lifetime", &self.lifetime); 2793 formatter.field("mutability", &self.mutability); 2794 formatter.field("elem", &self.elem); 2795 formatter.finish() 2796 } 2797 } 2798 #[cfg(any(feature = "derive", feature = "full"))] 2799 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2800 impl Debug for TypeSlice { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2801 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2802 let mut formatter = formatter.debug_struct("TypeSlice"); 2803 formatter.field("bracket_token", &self.bracket_token); 2804 formatter.field("elem", &self.elem); 2805 formatter.finish() 2806 } 2807 } 2808 #[cfg(any(feature = "derive", feature = "full"))] 2809 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2810 impl Debug for TypeTraitObject { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2811 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2812 let mut formatter = formatter.debug_struct("TypeTraitObject"); 2813 formatter.field("dyn_token", &self.dyn_token); 2814 formatter.field("bounds", &self.bounds); 2815 formatter.finish() 2816 } 2817 } 2818 #[cfg(any(feature = "derive", feature = "full"))] 2819 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2820 impl Debug for TypeTuple { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2821 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2822 let mut formatter = formatter.debug_struct("TypeTuple"); 2823 formatter.field("paren_token", &self.paren_token); 2824 formatter.field("elems", &self.elems); 2825 formatter.finish() 2826 } 2827 } 2828 #[cfg(any(feature = "derive", feature = "full"))] 2829 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2830 impl Debug for UnOp { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2831 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2832 match self { 2833 UnOp::Deref(v0) => { 2834 let mut formatter = formatter.debug_tuple("Deref"); 2835 formatter.field(v0); 2836 formatter.finish() 2837 } 2838 UnOp::Not(v0) => { 2839 let mut formatter = formatter.debug_tuple("Not"); 2840 formatter.field(v0); 2841 formatter.finish() 2842 } 2843 UnOp::Neg(v0) => { 2844 let mut formatter = formatter.debug_tuple("Neg"); 2845 formatter.field(v0); 2846 formatter.finish() 2847 } 2848 } 2849 } 2850 } 2851 #[cfg(feature = "full")] 2852 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2853 impl Debug for UseGlob { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2854 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2855 let mut formatter = formatter.debug_struct("UseGlob"); 2856 formatter.field("star_token", &self.star_token); 2857 formatter.finish() 2858 } 2859 } 2860 #[cfg(feature = "full")] 2861 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2862 impl Debug for UseGroup { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2863 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2864 let mut formatter = formatter.debug_struct("UseGroup"); 2865 formatter.field("brace_token", &self.brace_token); 2866 formatter.field("items", &self.items); 2867 formatter.finish() 2868 } 2869 } 2870 #[cfg(feature = "full")] 2871 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2872 impl Debug for UseName { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2873 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2874 let mut formatter = formatter.debug_struct("UseName"); 2875 formatter.field("ident", &self.ident); 2876 formatter.finish() 2877 } 2878 } 2879 #[cfg(feature = "full")] 2880 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2881 impl Debug for UsePath { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2882 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2883 let mut formatter = formatter.debug_struct("UsePath"); 2884 formatter.field("ident", &self.ident); 2885 formatter.field("colon2_token", &self.colon2_token); 2886 formatter.field("tree", &self.tree); 2887 formatter.finish() 2888 } 2889 } 2890 #[cfg(feature = "full")] 2891 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2892 impl Debug for UseRename { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2893 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2894 let mut formatter = formatter.debug_struct("UseRename"); 2895 formatter.field("ident", &self.ident); 2896 formatter.field("as_token", &self.as_token); 2897 formatter.field("rename", &self.rename); 2898 formatter.finish() 2899 } 2900 } 2901 #[cfg(feature = "full")] 2902 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2903 impl Debug for UseTree { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2904 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2905 match self { 2906 UseTree::Path(v0) => { 2907 let mut formatter = formatter.debug_tuple("Path"); 2908 formatter.field(v0); 2909 formatter.finish() 2910 } 2911 UseTree::Name(v0) => { 2912 let mut formatter = formatter.debug_tuple("Name"); 2913 formatter.field(v0); 2914 formatter.finish() 2915 } 2916 UseTree::Rename(v0) => { 2917 let mut formatter = formatter.debug_tuple("Rename"); 2918 formatter.field(v0); 2919 formatter.finish() 2920 } 2921 UseTree::Glob(v0) => { 2922 let mut formatter = formatter.debug_tuple("Glob"); 2923 formatter.field(v0); 2924 formatter.finish() 2925 } 2926 UseTree::Group(v0) => { 2927 let mut formatter = formatter.debug_tuple("Group"); 2928 formatter.field(v0); 2929 formatter.finish() 2930 } 2931 } 2932 } 2933 } 2934 #[cfg(any(feature = "derive", feature = "full"))] 2935 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2936 impl Debug for Variadic { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2937 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2938 let mut formatter = formatter.debug_struct("Variadic"); 2939 formatter.field("attrs", &self.attrs); 2940 formatter.field("dots", &self.dots); 2941 formatter.finish() 2942 } 2943 } 2944 #[cfg(any(feature = "derive", feature = "full"))] 2945 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2946 impl Debug for Variant { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2947 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2948 let mut formatter = formatter.debug_struct("Variant"); 2949 formatter.field("attrs", &self.attrs); 2950 formatter.field("ident", &self.ident); 2951 formatter.field("fields", &self.fields); 2952 formatter.field("discriminant", &self.discriminant); 2953 formatter.finish() 2954 } 2955 } 2956 #[cfg(any(feature = "derive", feature = "full"))] 2957 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2958 impl Debug for VisCrate { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2959 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2960 let mut formatter = formatter.debug_struct("VisCrate"); 2961 formatter.field("crate_token", &self.crate_token); 2962 formatter.finish() 2963 } 2964 } 2965 #[cfg(any(feature = "derive", feature = "full"))] 2966 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2967 impl Debug for VisPublic { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2968 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2969 let mut formatter = formatter.debug_struct("VisPublic"); 2970 formatter.field("pub_token", &self.pub_token); 2971 formatter.finish() 2972 } 2973 } 2974 #[cfg(any(feature = "derive", feature = "full"))] 2975 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2976 impl Debug for VisRestricted { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2977 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2978 let mut formatter = formatter.debug_struct("VisRestricted"); 2979 formatter.field("pub_token", &self.pub_token); 2980 formatter.field("paren_token", &self.paren_token); 2981 formatter.field("in_token", &self.in_token); 2982 formatter.field("path", &self.path); 2983 formatter.finish() 2984 } 2985 } 2986 #[cfg(any(feature = "derive", feature = "full"))] 2987 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 2988 impl Debug for Visibility { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2989 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2990 match self { 2991 Visibility::Public(v0) => { 2992 let mut formatter = formatter.debug_tuple("Public"); 2993 formatter.field(v0); 2994 formatter.finish() 2995 } 2996 Visibility::Crate(v0) => { 2997 let mut formatter = formatter.debug_tuple("Crate"); 2998 formatter.field(v0); 2999 formatter.finish() 3000 } 3001 Visibility::Restricted(v0) => { 3002 let mut formatter = formatter.debug_tuple("Restricted"); 3003 formatter.field(v0); 3004 formatter.finish() 3005 } 3006 Visibility::Inherited => formatter.write_str("Inherited"), 3007 } 3008 } 3009 } 3010 #[cfg(any(feature = "derive", feature = "full"))] 3011 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 3012 impl Debug for WhereClause { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result3013 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3014 let mut formatter = formatter.debug_struct("WhereClause"); 3015 formatter.field("where_token", &self.where_token); 3016 formatter.field("predicates", &self.predicates); 3017 formatter.finish() 3018 } 3019 } 3020 #[cfg(any(feature = "derive", feature = "full"))] 3021 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] 3022 impl Debug for WherePredicate { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result3023 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3024 match self { 3025 WherePredicate::Type(v0) => { 3026 let mut formatter = formatter.debug_tuple("Type"); 3027 formatter.field(v0); 3028 formatter.finish() 3029 } 3030 WherePredicate::Lifetime(v0) => { 3031 let mut formatter = formatter.debug_tuple("Lifetime"); 3032 formatter.field(v0); 3033 formatter.finish() 3034 } 3035 WherePredicate::Eq(v0) => { 3036 let mut formatter = formatter.debug_tuple("Eq"); 3037 formatter.field(v0); 3038 formatter.finish() 3039 } 3040 } 3041 } 3042 } 3043