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