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