1// This file is @generated by syn-internal-codegen. 2// It is not intended for manual editing. 3 4#![allow(repr_transparent_external_private_fields)] 5#![allow(clippy::match_wildcard_for_single_variants)] 6use super::{Lite, Present}; 7use ref_cast::RefCast; 8use std::fmt::{self, Debug, Display}; 9impl Debug for Lite<syn::Abi> { 10 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 11 let mut formatter = formatter.debug_struct("Abi"); 12 if let Some(val) = &self.value.name { 13 #[derive(RefCast)] 14 #[repr(transparent)] 15 struct Print(syn::LitStr); 16 impl Debug for Print { 17 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 18 formatter.write_str("Some(")?; 19 Debug::fmt(Lite(&self.0), formatter)?; 20 formatter.write_str(")")?; 21 Ok(()) 22 } 23 } 24 formatter.field("name", Print::ref_cast(val)); 25 } 26 formatter.finish() 27 } 28} 29impl Debug for Lite<syn::AngleBracketedGenericArguments> { 30 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 31 let mut formatter = formatter.debug_struct("AngleBracketedGenericArguments"); 32 if self.value.colon2_token.is_some() { 33 formatter.field("colon2_token", &Present); 34 } 35 if !self.value.args.is_empty() { 36 formatter.field("args", Lite(&self.value.args)); 37 } 38 formatter.finish() 39 } 40} 41impl Debug for Lite<syn::Arm> { 42 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 43 let mut formatter = formatter.debug_struct("Arm"); 44 if !self.value.attrs.is_empty() { 45 formatter.field("attrs", Lite(&self.value.attrs)); 46 } 47 formatter.field("pat", Lite(&self.value.pat)); 48 if let Some(val) = &self.value.guard { 49 #[derive(RefCast)] 50 #[repr(transparent)] 51 struct Print((syn::token::If, Box<syn::Expr>)); 52 impl Debug for Print { 53 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 54 formatter.write_str("Some(")?; 55 Debug::fmt(Lite(&self.0.1), formatter)?; 56 formatter.write_str(")")?; 57 Ok(()) 58 } 59 } 60 formatter.field("guard", Print::ref_cast(val)); 61 } 62 formatter.field("body", Lite(&self.value.body)); 63 if self.value.comma.is_some() { 64 formatter.field("comma", &Present); 65 } 66 formatter.finish() 67 } 68} 69impl Debug for Lite<syn::AssocConst> { 70 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 71 let mut formatter = formatter.debug_struct("AssocConst"); 72 formatter.field("ident", Lite(&self.value.ident)); 73 if let Some(val) = &self.value.generics { 74 #[derive(RefCast)] 75 #[repr(transparent)] 76 struct Print(syn::AngleBracketedGenericArguments); 77 impl Debug for Print { 78 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 79 formatter.write_str("Some(")?; 80 Debug::fmt(Lite(&self.0), formatter)?; 81 formatter.write_str(")")?; 82 Ok(()) 83 } 84 } 85 formatter.field("generics", Print::ref_cast(val)); 86 } 87 formatter.field("value", Lite(&self.value.value)); 88 formatter.finish() 89 } 90} 91impl Debug for Lite<syn::AssocType> { 92 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 93 let mut formatter = formatter.debug_struct("AssocType"); 94 formatter.field("ident", Lite(&self.value.ident)); 95 if let Some(val) = &self.value.generics { 96 #[derive(RefCast)] 97 #[repr(transparent)] 98 struct Print(syn::AngleBracketedGenericArguments); 99 impl Debug for Print { 100 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 101 formatter.write_str("Some(")?; 102 Debug::fmt(Lite(&self.0), formatter)?; 103 formatter.write_str(")")?; 104 Ok(()) 105 } 106 } 107 formatter.field("generics", Print::ref_cast(val)); 108 } 109 formatter.field("ty", Lite(&self.value.ty)); 110 formatter.finish() 111 } 112} 113impl Debug for Lite<syn::AttrStyle> { 114 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 115 match &self.value { 116 syn::AttrStyle::Outer => formatter.write_str("AttrStyle::Outer"), 117 syn::AttrStyle::Inner(_val) => { 118 formatter.write_str("AttrStyle::Inner")?; 119 Ok(()) 120 } 121 } 122 } 123} 124impl Debug for Lite<syn::Attribute> { 125 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 126 let mut formatter = formatter.debug_struct("Attribute"); 127 formatter.field("style", Lite(&self.value.style)); 128 formatter.field("meta", Lite(&self.value.meta)); 129 formatter.finish() 130 } 131} 132impl Debug for Lite<syn::BareFnArg> { 133 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 134 let mut formatter = formatter.debug_struct("BareFnArg"); 135 if !self.value.attrs.is_empty() { 136 formatter.field("attrs", Lite(&self.value.attrs)); 137 } 138 if let Some(val) = &self.value.name { 139 #[derive(RefCast)] 140 #[repr(transparent)] 141 struct Print((proc_macro2::Ident, syn::token::Colon)); 142 impl Debug for Print { 143 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 144 formatter.write_str("Some(")?; 145 Debug::fmt(Lite(&self.0.0), formatter)?; 146 formatter.write_str(")")?; 147 Ok(()) 148 } 149 } 150 formatter.field("name", Print::ref_cast(val)); 151 } 152 formatter.field("ty", Lite(&self.value.ty)); 153 formatter.finish() 154 } 155} 156impl Debug for Lite<syn::BareVariadic> { 157 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 158 let mut formatter = formatter.debug_struct("BareVariadic"); 159 if !self.value.attrs.is_empty() { 160 formatter.field("attrs", Lite(&self.value.attrs)); 161 } 162 if let Some(val) = &self.value.name { 163 #[derive(RefCast)] 164 #[repr(transparent)] 165 struct Print((proc_macro2::Ident, syn::token::Colon)); 166 impl Debug for Print { 167 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 168 formatter.write_str("Some(")?; 169 Debug::fmt(Lite(&self.0.0), formatter)?; 170 formatter.write_str(")")?; 171 Ok(()) 172 } 173 } 174 formatter.field("name", Print::ref_cast(val)); 175 } 176 if self.value.comma.is_some() { 177 formatter.field("comma", &Present); 178 } 179 formatter.finish() 180 } 181} 182impl Debug for Lite<syn::BinOp> { 183 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 184 match &self.value { 185 syn::BinOp::Add(_val) => { 186 formatter.write_str("BinOp::Add")?; 187 Ok(()) 188 } 189 syn::BinOp::Sub(_val) => { 190 formatter.write_str("BinOp::Sub")?; 191 Ok(()) 192 } 193 syn::BinOp::Mul(_val) => { 194 formatter.write_str("BinOp::Mul")?; 195 Ok(()) 196 } 197 syn::BinOp::Div(_val) => { 198 formatter.write_str("BinOp::Div")?; 199 Ok(()) 200 } 201 syn::BinOp::Rem(_val) => { 202 formatter.write_str("BinOp::Rem")?; 203 Ok(()) 204 } 205 syn::BinOp::And(_val) => { 206 formatter.write_str("BinOp::And")?; 207 Ok(()) 208 } 209 syn::BinOp::Or(_val) => { 210 formatter.write_str("BinOp::Or")?; 211 Ok(()) 212 } 213 syn::BinOp::BitXor(_val) => { 214 formatter.write_str("BinOp::BitXor")?; 215 Ok(()) 216 } 217 syn::BinOp::BitAnd(_val) => { 218 formatter.write_str("BinOp::BitAnd")?; 219 Ok(()) 220 } 221 syn::BinOp::BitOr(_val) => { 222 formatter.write_str("BinOp::BitOr")?; 223 Ok(()) 224 } 225 syn::BinOp::Shl(_val) => { 226 formatter.write_str("BinOp::Shl")?; 227 Ok(()) 228 } 229 syn::BinOp::Shr(_val) => { 230 formatter.write_str("BinOp::Shr")?; 231 Ok(()) 232 } 233 syn::BinOp::Eq(_val) => { 234 formatter.write_str("BinOp::Eq")?; 235 Ok(()) 236 } 237 syn::BinOp::Lt(_val) => { 238 formatter.write_str("BinOp::Lt")?; 239 Ok(()) 240 } 241 syn::BinOp::Le(_val) => { 242 formatter.write_str("BinOp::Le")?; 243 Ok(()) 244 } 245 syn::BinOp::Ne(_val) => { 246 formatter.write_str("BinOp::Ne")?; 247 Ok(()) 248 } 249 syn::BinOp::Ge(_val) => { 250 formatter.write_str("BinOp::Ge")?; 251 Ok(()) 252 } 253 syn::BinOp::Gt(_val) => { 254 formatter.write_str("BinOp::Gt")?; 255 Ok(()) 256 } 257 syn::BinOp::AddAssign(_val) => { 258 formatter.write_str("BinOp::AddAssign")?; 259 Ok(()) 260 } 261 syn::BinOp::SubAssign(_val) => { 262 formatter.write_str("BinOp::SubAssign")?; 263 Ok(()) 264 } 265 syn::BinOp::MulAssign(_val) => { 266 formatter.write_str("BinOp::MulAssign")?; 267 Ok(()) 268 } 269 syn::BinOp::DivAssign(_val) => { 270 formatter.write_str("BinOp::DivAssign")?; 271 Ok(()) 272 } 273 syn::BinOp::RemAssign(_val) => { 274 formatter.write_str("BinOp::RemAssign")?; 275 Ok(()) 276 } 277 syn::BinOp::BitXorAssign(_val) => { 278 formatter.write_str("BinOp::BitXorAssign")?; 279 Ok(()) 280 } 281 syn::BinOp::BitAndAssign(_val) => { 282 formatter.write_str("BinOp::BitAndAssign")?; 283 Ok(()) 284 } 285 syn::BinOp::BitOrAssign(_val) => { 286 formatter.write_str("BinOp::BitOrAssign")?; 287 Ok(()) 288 } 289 syn::BinOp::ShlAssign(_val) => { 290 formatter.write_str("BinOp::ShlAssign")?; 291 Ok(()) 292 } 293 syn::BinOp::ShrAssign(_val) => { 294 formatter.write_str("BinOp::ShrAssign")?; 295 Ok(()) 296 } 297 _ => unreachable!(), 298 } 299 } 300} 301impl Debug for Lite<syn::Block> { 302 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 303 let mut formatter = formatter.debug_struct("Block"); 304 formatter.field("stmts", Lite(&self.value.stmts)); 305 formatter.finish() 306 } 307} 308impl Debug for Lite<syn::BoundLifetimes> { 309 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 310 let mut formatter = formatter.debug_struct("BoundLifetimes"); 311 if !self.value.lifetimes.is_empty() { 312 formatter.field("lifetimes", Lite(&self.value.lifetimes)); 313 } 314 formatter.finish() 315 } 316} 317impl Debug for Lite<syn::ConstParam> { 318 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 319 let mut formatter = formatter.debug_struct("ConstParam"); 320 if !self.value.attrs.is_empty() { 321 formatter.field("attrs", Lite(&self.value.attrs)); 322 } 323 formatter.field("ident", Lite(&self.value.ident)); 324 formatter.field("ty", Lite(&self.value.ty)); 325 if self.value.eq_token.is_some() { 326 formatter.field("eq_token", &Present); 327 } 328 if let Some(val) = &self.value.default { 329 #[derive(RefCast)] 330 #[repr(transparent)] 331 struct Print(syn::Expr); 332 impl Debug for Print { 333 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 334 formatter.write_str("Some(")?; 335 Debug::fmt(Lite(&self.0), formatter)?; 336 formatter.write_str(")")?; 337 Ok(()) 338 } 339 } 340 formatter.field("default", Print::ref_cast(val)); 341 } 342 formatter.finish() 343 } 344} 345impl Debug for Lite<syn::Constraint> { 346 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 347 let mut formatter = formatter.debug_struct("Constraint"); 348 formatter.field("ident", Lite(&self.value.ident)); 349 if let Some(val) = &self.value.generics { 350 #[derive(RefCast)] 351 #[repr(transparent)] 352 struct Print(syn::AngleBracketedGenericArguments); 353 impl Debug for Print { 354 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 355 formatter.write_str("Some(")?; 356 Debug::fmt(Lite(&self.0), formatter)?; 357 formatter.write_str(")")?; 358 Ok(()) 359 } 360 } 361 formatter.field("generics", Print::ref_cast(val)); 362 } 363 if !self.value.bounds.is_empty() { 364 formatter.field("bounds", Lite(&self.value.bounds)); 365 } 366 formatter.finish() 367 } 368} 369impl Debug for Lite<syn::Data> { 370 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 371 match &self.value { 372 syn::Data::Struct(_val) => { 373 let mut formatter = formatter.debug_struct("Data::Struct"); 374 formatter.field("fields", Lite(&_val.fields)); 375 if _val.semi_token.is_some() { 376 formatter.field("semi_token", &Present); 377 } 378 formatter.finish() 379 } 380 syn::Data::Enum(_val) => { 381 let mut formatter = formatter.debug_struct("Data::Enum"); 382 if !_val.variants.is_empty() { 383 formatter.field("variants", Lite(&_val.variants)); 384 } 385 formatter.finish() 386 } 387 syn::Data::Union(_val) => { 388 let mut formatter = formatter.debug_struct("Data::Union"); 389 formatter.field("fields", Lite(&_val.fields)); 390 formatter.finish() 391 } 392 } 393 } 394} 395impl Debug for Lite<syn::DataEnum> { 396 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 397 let mut formatter = formatter.debug_struct("DataEnum"); 398 if !self.value.variants.is_empty() { 399 formatter.field("variants", Lite(&self.value.variants)); 400 } 401 formatter.finish() 402 } 403} 404impl Debug for Lite<syn::DataStruct> { 405 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 406 let mut formatter = formatter.debug_struct("DataStruct"); 407 formatter.field("fields", Lite(&self.value.fields)); 408 if self.value.semi_token.is_some() { 409 formatter.field("semi_token", &Present); 410 } 411 formatter.finish() 412 } 413} 414impl Debug for Lite<syn::DataUnion> { 415 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 416 let mut formatter = formatter.debug_struct("DataUnion"); 417 formatter.field("fields", Lite(&self.value.fields)); 418 formatter.finish() 419 } 420} 421impl Debug for Lite<syn::DeriveInput> { 422 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 423 let mut formatter = formatter.debug_struct("DeriveInput"); 424 if !self.value.attrs.is_empty() { 425 formatter.field("attrs", Lite(&self.value.attrs)); 426 } 427 formatter.field("vis", Lite(&self.value.vis)); 428 formatter.field("ident", Lite(&self.value.ident)); 429 formatter.field("generics", Lite(&self.value.generics)); 430 formatter.field("data", Lite(&self.value.data)); 431 formatter.finish() 432 } 433} 434impl Debug for Lite<syn::Expr> { 435 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 436 match &self.value { 437 syn::Expr::Array(_val) => { 438 let mut formatter = formatter.debug_struct("Expr::Array"); 439 if !_val.attrs.is_empty() { 440 formatter.field("attrs", Lite(&_val.attrs)); 441 } 442 if !_val.elems.is_empty() { 443 formatter.field("elems", Lite(&_val.elems)); 444 } 445 formatter.finish() 446 } 447 syn::Expr::Assign(_val) => { 448 let mut formatter = formatter.debug_struct("Expr::Assign"); 449 if !_val.attrs.is_empty() { 450 formatter.field("attrs", Lite(&_val.attrs)); 451 } 452 formatter.field("left", Lite(&_val.left)); 453 formatter.field("right", Lite(&_val.right)); 454 formatter.finish() 455 } 456 syn::Expr::Async(_val) => { 457 let mut formatter = formatter.debug_struct("Expr::Async"); 458 if !_val.attrs.is_empty() { 459 formatter.field("attrs", Lite(&_val.attrs)); 460 } 461 if _val.capture.is_some() { 462 formatter.field("capture", &Present); 463 } 464 formatter.field("block", Lite(&_val.block)); 465 formatter.finish() 466 } 467 syn::Expr::Await(_val) => { 468 let mut formatter = formatter.debug_struct("Expr::Await"); 469 if !_val.attrs.is_empty() { 470 formatter.field("attrs", Lite(&_val.attrs)); 471 } 472 formatter.field("base", Lite(&_val.base)); 473 formatter.finish() 474 } 475 syn::Expr::Binary(_val) => { 476 let mut formatter = formatter.debug_struct("Expr::Binary"); 477 if !_val.attrs.is_empty() { 478 formatter.field("attrs", Lite(&_val.attrs)); 479 } 480 formatter.field("left", Lite(&_val.left)); 481 formatter.field("op", Lite(&_val.op)); 482 formatter.field("right", Lite(&_val.right)); 483 formatter.finish() 484 } 485 syn::Expr::Block(_val) => { 486 let mut formatter = formatter.debug_struct("Expr::Block"); 487 if !_val.attrs.is_empty() { 488 formatter.field("attrs", Lite(&_val.attrs)); 489 } 490 if let Some(val) = &_val.label { 491 #[derive(RefCast)] 492 #[repr(transparent)] 493 struct Print(syn::Label); 494 impl Debug for Print { 495 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 496 formatter.write_str("Some(")?; 497 Debug::fmt(Lite(&self.0), formatter)?; 498 formatter.write_str(")")?; 499 Ok(()) 500 } 501 } 502 formatter.field("label", Print::ref_cast(val)); 503 } 504 formatter.field("block", Lite(&_val.block)); 505 formatter.finish() 506 } 507 syn::Expr::Break(_val) => { 508 let mut formatter = formatter.debug_struct("Expr::Break"); 509 if !_val.attrs.is_empty() { 510 formatter.field("attrs", Lite(&_val.attrs)); 511 } 512 if let Some(val) = &_val.label { 513 #[derive(RefCast)] 514 #[repr(transparent)] 515 struct Print(syn::Lifetime); 516 impl Debug for Print { 517 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 518 formatter.write_str("Some(")?; 519 Debug::fmt(Lite(&self.0), formatter)?; 520 formatter.write_str(")")?; 521 Ok(()) 522 } 523 } 524 formatter.field("label", Print::ref_cast(val)); 525 } 526 if let Some(val) = &_val.expr { 527 #[derive(RefCast)] 528 #[repr(transparent)] 529 struct Print(Box<syn::Expr>); 530 impl Debug for Print { 531 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 532 formatter.write_str("Some(")?; 533 Debug::fmt(Lite(&self.0), formatter)?; 534 formatter.write_str(")")?; 535 Ok(()) 536 } 537 } 538 formatter.field("expr", Print::ref_cast(val)); 539 } 540 formatter.finish() 541 } 542 syn::Expr::Call(_val) => { 543 let mut formatter = formatter.debug_struct("Expr::Call"); 544 if !_val.attrs.is_empty() { 545 formatter.field("attrs", Lite(&_val.attrs)); 546 } 547 formatter.field("func", Lite(&_val.func)); 548 if !_val.args.is_empty() { 549 formatter.field("args", Lite(&_val.args)); 550 } 551 formatter.finish() 552 } 553 syn::Expr::Cast(_val) => { 554 let mut formatter = formatter.debug_struct("Expr::Cast"); 555 if !_val.attrs.is_empty() { 556 formatter.field("attrs", Lite(&_val.attrs)); 557 } 558 formatter.field("expr", Lite(&_val.expr)); 559 formatter.field("ty", Lite(&_val.ty)); 560 formatter.finish() 561 } 562 syn::Expr::Closure(_val) => { 563 let mut formatter = formatter.debug_struct("Expr::Closure"); 564 if !_val.attrs.is_empty() { 565 formatter.field("attrs", Lite(&_val.attrs)); 566 } 567 if let Some(val) = &_val.lifetimes { 568 #[derive(RefCast)] 569 #[repr(transparent)] 570 struct Print(syn::BoundLifetimes); 571 impl Debug for Print { 572 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 573 formatter.write_str("Some(")?; 574 Debug::fmt(Lite(&self.0), formatter)?; 575 formatter.write_str(")")?; 576 Ok(()) 577 } 578 } 579 formatter.field("lifetimes", Print::ref_cast(val)); 580 } 581 if _val.constness.is_some() { 582 formatter.field("constness", &Present); 583 } 584 if _val.movability.is_some() { 585 formatter.field("movability", &Present); 586 } 587 if _val.asyncness.is_some() { 588 formatter.field("asyncness", &Present); 589 } 590 if _val.capture.is_some() { 591 formatter.field("capture", &Present); 592 } 593 if !_val.inputs.is_empty() { 594 formatter.field("inputs", Lite(&_val.inputs)); 595 } 596 formatter.field("output", Lite(&_val.output)); 597 formatter.field("body", Lite(&_val.body)); 598 formatter.finish() 599 } 600 syn::Expr::Const(_val) => { 601 let mut formatter = formatter.debug_struct("Expr::Const"); 602 if !_val.attrs.is_empty() { 603 formatter.field("attrs", Lite(&_val.attrs)); 604 } 605 formatter.field("block", Lite(&_val.block)); 606 formatter.finish() 607 } 608 syn::Expr::Continue(_val) => { 609 let mut formatter = formatter.debug_struct("Expr::Continue"); 610 if !_val.attrs.is_empty() { 611 formatter.field("attrs", Lite(&_val.attrs)); 612 } 613 if let Some(val) = &_val.label { 614 #[derive(RefCast)] 615 #[repr(transparent)] 616 struct Print(syn::Lifetime); 617 impl Debug for Print { 618 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 619 formatter.write_str("Some(")?; 620 Debug::fmt(Lite(&self.0), formatter)?; 621 formatter.write_str(")")?; 622 Ok(()) 623 } 624 } 625 formatter.field("label", Print::ref_cast(val)); 626 } 627 formatter.finish() 628 } 629 syn::Expr::Field(_val) => { 630 let mut formatter = formatter.debug_struct("Expr::Field"); 631 if !_val.attrs.is_empty() { 632 formatter.field("attrs", Lite(&_val.attrs)); 633 } 634 formatter.field("base", Lite(&_val.base)); 635 formatter.field("member", Lite(&_val.member)); 636 formatter.finish() 637 } 638 syn::Expr::ForLoop(_val) => { 639 let mut formatter = formatter.debug_struct("Expr::ForLoop"); 640 if !_val.attrs.is_empty() { 641 formatter.field("attrs", Lite(&_val.attrs)); 642 } 643 if let Some(val) = &_val.label { 644 #[derive(RefCast)] 645 #[repr(transparent)] 646 struct Print(syn::Label); 647 impl Debug for Print { 648 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 649 formatter.write_str("Some(")?; 650 Debug::fmt(Lite(&self.0), formatter)?; 651 formatter.write_str(")")?; 652 Ok(()) 653 } 654 } 655 formatter.field("label", Print::ref_cast(val)); 656 } 657 formatter.field("pat", Lite(&_val.pat)); 658 formatter.field("expr", Lite(&_val.expr)); 659 formatter.field("body", Lite(&_val.body)); 660 formatter.finish() 661 } 662 syn::Expr::Group(_val) => { 663 let mut formatter = formatter.debug_struct("Expr::Group"); 664 if !_val.attrs.is_empty() { 665 formatter.field("attrs", Lite(&_val.attrs)); 666 } 667 formatter.field("expr", Lite(&_val.expr)); 668 formatter.finish() 669 } 670 syn::Expr::If(_val) => { 671 let mut formatter = formatter.debug_struct("Expr::If"); 672 if !_val.attrs.is_empty() { 673 formatter.field("attrs", Lite(&_val.attrs)); 674 } 675 formatter.field("cond", Lite(&_val.cond)); 676 formatter.field("then_branch", Lite(&_val.then_branch)); 677 if let Some(val) = &_val.else_branch { 678 #[derive(RefCast)] 679 #[repr(transparent)] 680 struct Print((syn::token::Else, Box<syn::Expr>)); 681 impl Debug for Print { 682 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 683 formatter.write_str("Some(")?; 684 Debug::fmt(Lite(&self.0.1), formatter)?; 685 formatter.write_str(")")?; 686 Ok(()) 687 } 688 } 689 formatter.field("else_branch", Print::ref_cast(val)); 690 } 691 formatter.finish() 692 } 693 syn::Expr::Index(_val) => { 694 let mut formatter = formatter.debug_struct("Expr::Index"); 695 if !_val.attrs.is_empty() { 696 formatter.field("attrs", Lite(&_val.attrs)); 697 } 698 formatter.field("expr", Lite(&_val.expr)); 699 formatter.field("index", Lite(&_val.index)); 700 formatter.finish() 701 } 702 syn::Expr::Infer(_val) => { 703 let mut formatter = formatter.debug_struct("Expr::Infer"); 704 if !_val.attrs.is_empty() { 705 formatter.field("attrs", Lite(&_val.attrs)); 706 } 707 formatter.finish() 708 } 709 syn::Expr::Let(_val) => { 710 let mut formatter = formatter.debug_struct("Expr::Let"); 711 if !_val.attrs.is_empty() { 712 formatter.field("attrs", Lite(&_val.attrs)); 713 } 714 formatter.field("pat", Lite(&_val.pat)); 715 formatter.field("expr", Lite(&_val.expr)); 716 formatter.finish() 717 } 718 syn::Expr::Lit(_val) => { 719 let mut formatter = formatter.debug_struct("Expr::Lit"); 720 if !_val.attrs.is_empty() { 721 formatter.field("attrs", Lite(&_val.attrs)); 722 } 723 formatter.field("lit", Lite(&_val.lit)); 724 formatter.finish() 725 } 726 syn::Expr::Loop(_val) => { 727 let mut formatter = formatter.debug_struct("Expr::Loop"); 728 if !_val.attrs.is_empty() { 729 formatter.field("attrs", Lite(&_val.attrs)); 730 } 731 if let Some(val) = &_val.label { 732 #[derive(RefCast)] 733 #[repr(transparent)] 734 struct Print(syn::Label); 735 impl Debug for Print { 736 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 737 formatter.write_str("Some(")?; 738 Debug::fmt(Lite(&self.0), formatter)?; 739 formatter.write_str(")")?; 740 Ok(()) 741 } 742 } 743 formatter.field("label", Print::ref_cast(val)); 744 } 745 formatter.field("body", Lite(&_val.body)); 746 formatter.finish() 747 } 748 syn::Expr::Macro(_val) => { 749 let mut formatter = formatter.debug_struct("Expr::Macro"); 750 if !_val.attrs.is_empty() { 751 formatter.field("attrs", Lite(&_val.attrs)); 752 } 753 formatter.field("mac", Lite(&_val.mac)); 754 formatter.finish() 755 } 756 syn::Expr::Match(_val) => { 757 let mut formatter = formatter.debug_struct("Expr::Match"); 758 if !_val.attrs.is_empty() { 759 formatter.field("attrs", Lite(&_val.attrs)); 760 } 761 formatter.field("expr", Lite(&_val.expr)); 762 if !_val.arms.is_empty() { 763 formatter.field("arms", Lite(&_val.arms)); 764 } 765 formatter.finish() 766 } 767 syn::Expr::MethodCall(_val) => { 768 let mut formatter = formatter.debug_struct("Expr::MethodCall"); 769 if !_val.attrs.is_empty() { 770 formatter.field("attrs", Lite(&_val.attrs)); 771 } 772 formatter.field("receiver", Lite(&_val.receiver)); 773 formatter.field("method", Lite(&_val.method)); 774 if let Some(val) = &_val.turbofish { 775 #[derive(RefCast)] 776 #[repr(transparent)] 777 struct Print(syn::AngleBracketedGenericArguments); 778 impl Debug for Print { 779 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 780 formatter.write_str("Some(")?; 781 Debug::fmt(Lite(&self.0), formatter)?; 782 formatter.write_str(")")?; 783 Ok(()) 784 } 785 } 786 formatter.field("turbofish", Print::ref_cast(val)); 787 } 788 if !_val.args.is_empty() { 789 formatter.field("args", Lite(&_val.args)); 790 } 791 formatter.finish() 792 } 793 syn::Expr::Paren(_val) => { 794 let mut formatter = formatter.debug_struct("Expr::Paren"); 795 if !_val.attrs.is_empty() { 796 formatter.field("attrs", Lite(&_val.attrs)); 797 } 798 formatter.field("expr", Lite(&_val.expr)); 799 formatter.finish() 800 } 801 syn::Expr::Path(_val) => { 802 let mut formatter = formatter.debug_struct("Expr::Path"); 803 if !_val.attrs.is_empty() { 804 formatter.field("attrs", Lite(&_val.attrs)); 805 } 806 if let Some(val) = &_val.qself { 807 #[derive(RefCast)] 808 #[repr(transparent)] 809 struct Print(syn::QSelf); 810 impl Debug for Print { 811 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 812 formatter.write_str("Some(")?; 813 Debug::fmt(Lite(&self.0), formatter)?; 814 formatter.write_str(")")?; 815 Ok(()) 816 } 817 } 818 formatter.field("qself", Print::ref_cast(val)); 819 } 820 formatter.field("path", Lite(&_val.path)); 821 formatter.finish() 822 } 823 syn::Expr::Range(_val) => { 824 let mut formatter = formatter.debug_struct("Expr::Range"); 825 if !_val.attrs.is_empty() { 826 formatter.field("attrs", Lite(&_val.attrs)); 827 } 828 if let Some(val) = &_val.start { 829 #[derive(RefCast)] 830 #[repr(transparent)] 831 struct Print(Box<syn::Expr>); 832 impl Debug for Print { 833 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 834 formatter.write_str("Some(")?; 835 Debug::fmt(Lite(&self.0), formatter)?; 836 formatter.write_str(")")?; 837 Ok(()) 838 } 839 } 840 formatter.field("start", Print::ref_cast(val)); 841 } 842 formatter.field("limits", Lite(&_val.limits)); 843 if let Some(val) = &_val.end { 844 #[derive(RefCast)] 845 #[repr(transparent)] 846 struct Print(Box<syn::Expr>); 847 impl Debug for Print { 848 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 849 formatter.write_str("Some(")?; 850 Debug::fmt(Lite(&self.0), formatter)?; 851 formatter.write_str(")")?; 852 Ok(()) 853 } 854 } 855 formatter.field("end", Print::ref_cast(val)); 856 } 857 formatter.finish() 858 } 859 syn::Expr::Reference(_val) => { 860 let mut formatter = formatter.debug_struct("Expr::Reference"); 861 if !_val.attrs.is_empty() { 862 formatter.field("attrs", Lite(&_val.attrs)); 863 } 864 if _val.mutability.is_some() { 865 formatter.field("mutability", &Present); 866 } 867 formatter.field("expr", Lite(&_val.expr)); 868 formatter.finish() 869 } 870 syn::Expr::Repeat(_val) => { 871 let mut formatter = formatter.debug_struct("Expr::Repeat"); 872 if !_val.attrs.is_empty() { 873 formatter.field("attrs", Lite(&_val.attrs)); 874 } 875 formatter.field("expr", Lite(&_val.expr)); 876 formatter.field("len", Lite(&_val.len)); 877 formatter.finish() 878 } 879 syn::Expr::Return(_val) => { 880 let mut formatter = formatter.debug_struct("Expr::Return"); 881 if !_val.attrs.is_empty() { 882 formatter.field("attrs", Lite(&_val.attrs)); 883 } 884 if let Some(val) = &_val.expr { 885 #[derive(RefCast)] 886 #[repr(transparent)] 887 struct Print(Box<syn::Expr>); 888 impl Debug for Print { 889 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 890 formatter.write_str("Some(")?; 891 Debug::fmt(Lite(&self.0), formatter)?; 892 formatter.write_str(")")?; 893 Ok(()) 894 } 895 } 896 formatter.field("expr", Print::ref_cast(val)); 897 } 898 formatter.finish() 899 } 900 syn::Expr::Struct(_val) => { 901 let mut formatter = formatter.debug_struct("Expr::Struct"); 902 if !_val.attrs.is_empty() { 903 formatter.field("attrs", Lite(&_val.attrs)); 904 } 905 if let Some(val) = &_val.qself { 906 #[derive(RefCast)] 907 #[repr(transparent)] 908 struct Print(syn::QSelf); 909 impl Debug for Print { 910 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 911 formatter.write_str("Some(")?; 912 Debug::fmt(Lite(&self.0), formatter)?; 913 formatter.write_str(")")?; 914 Ok(()) 915 } 916 } 917 formatter.field("qself", Print::ref_cast(val)); 918 } 919 formatter.field("path", Lite(&_val.path)); 920 if !_val.fields.is_empty() { 921 formatter.field("fields", Lite(&_val.fields)); 922 } 923 if _val.dot2_token.is_some() { 924 formatter.field("dot2_token", &Present); 925 } 926 if let Some(val) = &_val.rest { 927 #[derive(RefCast)] 928 #[repr(transparent)] 929 struct Print(Box<syn::Expr>); 930 impl Debug for Print { 931 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 932 formatter.write_str("Some(")?; 933 Debug::fmt(Lite(&self.0), formatter)?; 934 formatter.write_str(")")?; 935 Ok(()) 936 } 937 } 938 formatter.field("rest", Print::ref_cast(val)); 939 } 940 formatter.finish() 941 } 942 syn::Expr::Try(_val) => { 943 let mut formatter = formatter.debug_struct("Expr::Try"); 944 if !_val.attrs.is_empty() { 945 formatter.field("attrs", Lite(&_val.attrs)); 946 } 947 formatter.field("expr", Lite(&_val.expr)); 948 formatter.finish() 949 } 950 syn::Expr::TryBlock(_val) => { 951 let mut formatter = formatter.debug_struct("Expr::TryBlock"); 952 if !_val.attrs.is_empty() { 953 formatter.field("attrs", Lite(&_val.attrs)); 954 } 955 formatter.field("block", Lite(&_val.block)); 956 formatter.finish() 957 } 958 syn::Expr::Tuple(_val) => { 959 let mut formatter = formatter.debug_struct("Expr::Tuple"); 960 if !_val.attrs.is_empty() { 961 formatter.field("attrs", Lite(&_val.attrs)); 962 } 963 if !_val.elems.is_empty() { 964 formatter.field("elems", Lite(&_val.elems)); 965 } 966 formatter.finish() 967 } 968 syn::Expr::Unary(_val) => { 969 let mut formatter = formatter.debug_struct("Expr::Unary"); 970 if !_val.attrs.is_empty() { 971 formatter.field("attrs", Lite(&_val.attrs)); 972 } 973 formatter.field("op", Lite(&_val.op)); 974 formatter.field("expr", Lite(&_val.expr)); 975 formatter.finish() 976 } 977 syn::Expr::Unsafe(_val) => { 978 let mut formatter = formatter.debug_struct("Expr::Unsafe"); 979 if !_val.attrs.is_empty() { 980 formatter.field("attrs", Lite(&_val.attrs)); 981 } 982 formatter.field("block", Lite(&_val.block)); 983 formatter.finish() 984 } 985 syn::Expr::Verbatim(_val) => { 986 formatter.write_str("Expr::Verbatim")?; 987 formatter.write_str("(`")?; 988 Display::fmt(_val, formatter)?; 989 formatter.write_str("`)")?; 990 Ok(()) 991 } 992 syn::Expr::While(_val) => { 993 let mut formatter = formatter.debug_struct("Expr::While"); 994 if !_val.attrs.is_empty() { 995 formatter.field("attrs", Lite(&_val.attrs)); 996 } 997 if let Some(val) = &_val.label { 998 #[derive(RefCast)] 999 #[repr(transparent)] 1000 struct Print(syn::Label); 1001 impl Debug for Print { 1002 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1003 formatter.write_str("Some(")?; 1004 Debug::fmt(Lite(&self.0), formatter)?; 1005 formatter.write_str(")")?; 1006 Ok(()) 1007 } 1008 } 1009 formatter.field("label", Print::ref_cast(val)); 1010 } 1011 formatter.field("cond", Lite(&_val.cond)); 1012 formatter.field("body", Lite(&_val.body)); 1013 formatter.finish() 1014 } 1015 syn::Expr::Yield(_val) => { 1016 let mut formatter = formatter.debug_struct("Expr::Yield"); 1017 if !_val.attrs.is_empty() { 1018 formatter.field("attrs", Lite(&_val.attrs)); 1019 } 1020 if let Some(val) = &_val.expr { 1021 #[derive(RefCast)] 1022 #[repr(transparent)] 1023 struct Print(Box<syn::Expr>); 1024 impl Debug for Print { 1025 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1026 formatter.write_str("Some(")?; 1027 Debug::fmt(Lite(&self.0), formatter)?; 1028 formatter.write_str(")")?; 1029 Ok(()) 1030 } 1031 } 1032 formatter.field("expr", Print::ref_cast(val)); 1033 } 1034 formatter.finish() 1035 } 1036 _ => unreachable!(), 1037 } 1038 } 1039} 1040impl Debug for Lite<syn::ExprArray> { 1041 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1042 let mut formatter = formatter.debug_struct("ExprArray"); 1043 if !self.value.attrs.is_empty() { 1044 formatter.field("attrs", Lite(&self.value.attrs)); 1045 } 1046 if !self.value.elems.is_empty() { 1047 formatter.field("elems", Lite(&self.value.elems)); 1048 } 1049 formatter.finish() 1050 } 1051} 1052impl Debug for Lite<syn::ExprAssign> { 1053 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1054 let mut formatter = formatter.debug_struct("ExprAssign"); 1055 if !self.value.attrs.is_empty() { 1056 formatter.field("attrs", Lite(&self.value.attrs)); 1057 } 1058 formatter.field("left", Lite(&self.value.left)); 1059 formatter.field("right", Lite(&self.value.right)); 1060 formatter.finish() 1061 } 1062} 1063impl Debug for Lite<syn::ExprAsync> { 1064 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1065 let mut formatter = formatter.debug_struct("ExprAsync"); 1066 if !self.value.attrs.is_empty() { 1067 formatter.field("attrs", Lite(&self.value.attrs)); 1068 } 1069 if self.value.capture.is_some() { 1070 formatter.field("capture", &Present); 1071 } 1072 formatter.field("block", Lite(&self.value.block)); 1073 formatter.finish() 1074 } 1075} 1076impl Debug for Lite<syn::ExprAwait> { 1077 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1078 let mut formatter = formatter.debug_struct("ExprAwait"); 1079 if !self.value.attrs.is_empty() { 1080 formatter.field("attrs", Lite(&self.value.attrs)); 1081 } 1082 formatter.field("base", Lite(&self.value.base)); 1083 formatter.finish() 1084 } 1085} 1086impl Debug for Lite<syn::ExprBinary> { 1087 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1088 let mut formatter = formatter.debug_struct("ExprBinary"); 1089 if !self.value.attrs.is_empty() { 1090 formatter.field("attrs", Lite(&self.value.attrs)); 1091 } 1092 formatter.field("left", Lite(&self.value.left)); 1093 formatter.field("op", Lite(&self.value.op)); 1094 formatter.field("right", Lite(&self.value.right)); 1095 formatter.finish() 1096 } 1097} 1098impl Debug for Lite<syn::ExprBlock> { 1099 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1100 let mut formatter = formatter.debug_struct("ExprBlock"); 1101 if !self.value.attrs.is_empty() { 1102 formatter.field("attrs", Lite(&self.value.attrs)); 1103 } 1104 if let Some(val) = &self.value.label { 1105 #[derive(RefCast)] 1106 #[repr(transparent)] 1107 struct Print(syn::Label); 1108 impl Debug for Print { 1109 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1110 formatter.write_str("Some(")?; 1111 Debug::fmt(Lite(&self.0), formatter)?; 1112 formatter.write_str(")")?; 1113 Ok(()) 1114 } 1115 } 1116 formatter.field("label", Print::ref_cast(val)); 1117 } 1118 formatter.field("block", Lite(&self.value.block)); 1119 formatter.finish() 1120 } 1121} 1122impl Debug for Lite<syn::ExprBreak> { 1123 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1124 let mut formatter = formatter.debug_struct("ExprBreak"); 1125 if !self.value.attrs.is_empty() { 1126 formatter.field("attrs", Lite(&self.value.attrs)); 1127 } 1128 if let Some(val) = &self.value.label { 1129 #[derive(RefCast)] 1130 #[repr(transparent)] 1131 struct Print(syn::Lifetime); 1132 impl Debug for Print { 1133 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1134 formatter.write_str("Some(")?; 1135 Debug::fmt(Lite(&self.0), formatter)?; 1136 formatter.write_str(")")?; 1137 Ok(()) 1138 } 1139 } 1140 formatter.field("label", Print::ref_cast(val)); 1141 } 1142 if let Some(val) = &self.value.expr { 1143 #[derive(RefCast)] 1144 #[repr(transparent)] 1145 struct Print(Box<syn::Expr>); 1146 impl Debug for Print { 1147 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1148 formatter.write_str("Some(")?; 1149 Debug::fmt(Lite(&self.0), formatter)?; 1150 formatter.write_str(")")?; 1151 Ok(()) 1152 } 1153 } 1154 formatter.field("expr", Print::ref_cast(val)); 1155 } 1156 formatter.finish() 1157 } 1158} 1159impl Debug for Lite<syn::ExprCall> { 1160 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1161 let mut formatter = formatter.debug_struct("ExprCall"); 1162 if !self.value.attrs.is_empty() { 1163 formatter.field("attrs", Lite(&self.value.attrs)); 1164 } 1165 formatter.field("func", Lite(&self.value.func)); 1166 if !self.value.args.is_empty() { 1167 formatter.field("args", Lite(&self.value.args)); 1168 } 1169 formatter.finish() 1170 } 1171} 1172impl Debug for Lite<syn::ExprCast> { 1173 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1174 let mut formatter = formatter.debug_struct("ExprCast"); 1175 if !self.value.attrs.is_empty() { 1176 formatter.field("attrs", Lite(&self.value.attrs)); 1177 } 1178 formatter.field("expr", Lite(&self.value.expr)); 1179 formatter.field("ty", Lite(&self.value.ty)); 1180 formatter.finish() 1181 } 1182} 1183impl Debug for Lite<syn::ExprClosure> { 1184 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1185 let mut formatter = formatter.debug_struct("ExprClosure"); 1186 if !self.value.attrs.is_empty() { 1187 formatter.field("attrs", Lite(&self.value.attrs)); 1188 } 1189 if let Some(val) = &self.value.lifetimes { 1190 #[derive(RefCast)] 1191 #[repr(transparent)] 1192 struct Print(syn::BoundLifetimes); 1193 impl Debug for Print { 1194 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1195 formatter.write_str("Some(")?; 1196 Debug::fmt(Lite(&self.0), formatter)?; 1197 formatter.write_str(")")?; 1198 Ok(()) 1199 } 1200 } 1201 formatter.field("lifetimes", Print::ref_cast(val)); 1202 } 1203 if self.value.constness.is_some() { 1204 formatter.field("constness", &Present); 1205 } 1206 if self.value.movability.is_some() { 1207 formatter.field("movability", &Present); 1208 } 1209 if self.value.asyncness.is_some() { 1210 formatter.field("asyncness", &Present); 1211 } 1212 if self.value.capture.is_some() { 1213 formatter.field("capture", &Present); 1214 } 1215 if !self.value.inputs.is_empty() { 1216 formatter.field("inputs", Lite(&self.value.inputs)); 1217 } 1218 formatter.field("output", Lite(&self.value.output)); 1219 formatter.field("body", Lite(&self.value.body)); 1220 formatter.finish() 1221 } 1222} 1223impl Debug for Lite<syn::ExprConst> { 1224 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1225 let mut formatter = formatter.debug_struct("ExprConst"); 1226 if !self.value.attrs.is_empty() { 1227 formatter.field("attrs", Lite(&self.value.attrs)); 1228 } 1229 formatter.field("block", Lite(&self.value.block)); 1230 formatter.finish() 1231 } 1232} 1233impl Debug for Lite<syn::ExprContinue> { 1234 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1235 let mut formatter = formatter.debug_struct("ExprContinue"); 1236 if !self.value.attrs.is_empty() { 1237 formatter.field("attrs", Lite(&self.value.attrs)); 1238 } 1239 if let Some(val) = &self.value.label { 1240 #[derive(RefCast)] 1241 #[repr(transparent)] 1242 struct Print(syn::Lifetime); 1243 impl Debug for Print { 1244 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1245 formatter.write_str("Some(")?; 1246 Debug::fmt(Lite(&self.0), formatter)?; 1247 formatter.write_str(")")?; 1248 Ok(()) 1249 } 1250 } 1251 formatter.field("label", Print::ref_cast(val)); 1252 } 1253 formatter.finish() 1254 } 1255} 1256impl Debug for Lite<syn::ExprField> { 1257 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1258 let mut formatter = formatter.debug_struct("ExprField"); 1259 if !self.value.attrs.is_empty() { 1260 formatter.field("attrs", Lite(&self.value.attrs)); 1261 } 1262 formatter.field("base", Lite(&self.value.base)); 1263 formatter.field("member", Lite(&self.value.member)); 1264 formatter.finish() 1265 } 1266} 1267impl Debug for Lite<syn::ExprForLoop> { 1268 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1269 let mut formatter = formatter.debug_struct("ExprForLoop"); 1270 if !self.value.attrs.is_empty() { 1271 formatter.field("attrs", Lite(&self.value.attrs)); 1272 } 1273 if let Some(val) = &self.value.label { 1274 #[derive(RefCast)] 1275 #[repr(transparent)] 1276 struct Print(syn::Label); 1277 impl Debug for Print { 1278 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1279 formatter.write_str("Some(")?; 1280 Debug::fmt(Lite(&self.0), formatter)?; 1281 formatter.write_str(")")?; 1282 Ok(()) 1283 } 1284 } 1285 formatter.field("label", Print::ref_cast(val)); 1286 } 1287 formatter.field("pat", Lite(&self.value.pat)); 1288 formatter.field("expr", Lite(&self.value.expr)); 1289 formatter.field("body", Lite(&self.value.body)); 1290 formatter.finish() 1291 } 1292} 1293impl Debug for Lite<syn::ExprGroup> { 1294 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1295 let mut formatter = formatter.debug_struct("ExprGroup"); 1296 if !self.value.attrs.is_empty() { 1297 formatter.field("attrs", Lite(&self.value.attrs)); 1298 } 1299 formatter.field("expr", Lite(&self.value.expr)); 1300 formatter.finish() 1301 } 1302} 1303impl Debug for Lite<syn::ExprIf> { 1304 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1305 let mut formatter = formatter.debug_struct("ExprIf"); 1306 if !self.value.attrs.is_empty() { 1307 formatter.field("attrs", Lite(&self.value.attrs)); 1308 } 1309 formatter.field("cond", Lite(&self.value.cond)); 1310 formatter.field("then_branch", Lite(&self.value.then_branch)); 1311 if let Some(val) = &self.value.else_branch { 1312 #[derive(RefCast)] 1313 #[repr(transparent)] 1314 struct Print((syn::token::Else, Box<syn::Expr>)); 1315 impl Debug for Print { 1316 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1317 formatter.write_str("Some(")?; 1318 Debug::fmt(Lite(&self.0.1), formatter)?; 1319 formatter.write_str(")")?; 1320 Ok(()) 1321 } 1322 } 1323 formatter.field("else_branch", Print::ref_cast(val)); 1324 } 1325 formatter.finish() 1326 } 1327} 1328impl Debug for Lite<syn::ExprIndex> { 1329 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1330 let mut formatter = formatter.debug_struct("ExprIndex"); 1331 if !self.value.attrs.is_empty() { 1332 formatter.field("attrs", Lite(&self.value.attrs)); 1333 } 1334 formatter.field("expr", Lite(&self.value.expr)); 1335 formatter.field("index", Lite(&self.value.index)); 1336 formatter.finish() 1337 } 1338} 1339impl Debug for Lite<syn::ExprInfer> { 1340 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1341 let mut formatter = formatter.debug_struct("ExprInfer"); 1342 if !self.value.attrs.is_empty() { 1343 formatter.field("attrs", Lite(&self.value.attrs)); 1344 } 1345 formatter.finish() 1346 } 1347} 1348impl Debug for Lite<syn::ExprLet> { 1349 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1350 let mut formatter = formatter.debug_struct("ExprLet"); 1351 if !self.value.attrs.is_empty() { 1352 formatter.field("attrs", Lite(&self.value.attrs)); 1353 } 1354 formatter.field("pat", Lite(&self.value.pat)); 1355 formatter.field("expr", Lite(&self.value.expr)); 1356 formatter.finish() 1357 } 1358} 1359impl Debug for Lite<syn::ExprLit> { 1360 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1361 let mut formatter = formatter.debug_struct("ExprLit"); 1362 if !self.value.attrs.is_empty() { 1363 formatter.field("attrs", Lite(&self.value.attrs)); 1364 } 1365 formatter.field("lit", Lite(&self.value.lit)); 1366 formatter.finish() 1367 } 1368} 1369impl Debug for Lite<syn::ExprLoop> { 1370 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1371 let mut formatter = formatter.debug_struct("ExprLoop"); 1372 if !self.value.attrs.is_empty() { 1373 formatter.field("attrs", Lite(&self.value.attrs)); 1374 } 1375 if let Some(val) = &self.value.label { 1376 #[derive(RefCast)] 1377 #[repr(transparent)] 1378 struct Print(syn::Label); 1379 impl Debug for Print { 1380 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1381 formatter.write_str("Some(")?; 1382 Debug::fmt(Lite(&self.0), formatter)?; 1383 formatter.write_str(")")?; 1384 Ok(()) 1385 } 1386 } 1387 formatter.field("label", Print::ref_cast(val)); 1388 } 1389 formatter.field("body", Lite(&self.value.body)); 1390 formatter.finish() 1391 } 1392} 1393impl Debug for Lite<syn::ExprMacro> { 1394 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1395 let mut formatter = formatter.debug_struct("ExprMacro"); 1396 if !self.value.attrs.is_empty() { 1397 formatter.field("attrs", Lite(&self.value.attrs)); 1398 } 1399 formatter.field("mac", Lite(&self.value.mac)); 1400 formatter.finish() 1401 } 1402} 1403impl Debug for Lite<syn::ExprMatch> { 1404 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1405 let mut formatter = formatter.debug_struct("ExprMatch"); 1406 if !self.value.attrs.is_empty() { 1407 formatter.field("attrs", Lite(&self.value.attrs)); 1408 } 1409 formatter.field("expr", Lite(&self.value.expr)); 1410 if !self.value.arms.is_empty() { 1411 formatter.field("arms", Lite(&self.value.arms)); 1412 } 1413 formatter.finish() 1414 } 1415} 1416impl Debug for Lite<syn::ExprMethodCall> { 1417 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1418 let mut formatter = formatter.debug_struct("ExprMethodCall"); 1419 if !self.value.attrs.is_empty() { 1420 formatter.field("attrs", Lite(&self.value.attrs)); 1421 } 1422 formatter.field("receiver", Lite(&self.value.receiver)); 1423 formatter.field("method", Lite(&self.value.method)); 1424 if let Some(val) = &self.value.turbofish { 1425 #[derive(RefCast)] 1426 #[repr(transparent)] 1427 struct Print(syn::AngleBracketedGenericArguments); 1428 impl Debug for Print { 1429 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1430 formatter.write_str("Some(")?; 1431 Debug::fmt(Lite(&self.0), formatter)?; 1432 formatter.write_str(")")?; 1433 Ok(()) 1434 } 1435 } 1436 formatter.field("turbofish", Print::ref_cast(val)); 1437 } 1438 if !self.value.args.is_empty() { 1439 formatter.field("args", Lite(&self.value.args)); 1440 } 1441 formatter.finish() 1442 } 1443} 1444impl Debug for Lite<syn::ExprParen> { 1445 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1446 let mut formatter = formatter.debug_struct("ExprParen"); 1447 if !self.value.attrs.is_empty() { 1448 formatter.field("attrs", Lite(&self.value.attrs)); 1449 } 1450 formatter.field("expr", Lite(&self.value.expr)); 1451 formatter.finish() 1452 } 1453} 1454impl Debug for Lite<syn::ExprPath> { 1455 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1456 let mut formatter = formatter.debug_struct("ExprPath"); 1457 if !self.value.attrs.is_empty() { 1458 formatter.field("attrs", Lite(&self.value.attrs)); 1459 } 1460 if let Some(val) = &self.value.qself { 1461 #[derive(RefCast)] 1462 #[repr(transparent)] 1463 struct Print(syn::QSelf); 1464 impl Debug for Print { 1465 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1466 formatter.write_str("Some(")?; 1467 Debug::fmt(Lite(&self.0), formatter)?; 1468 formatter.write_str(")")?; 1469 Ok(()) 1470 } 1471 } 1472 formatter.field("qself", Print::ref_cast(val)); 1473 } 1474 formatter.field("path", Lite(&self.value.path)); 1475 formatter.finish() 1476 } 1477} 1478impl Debug for Lite<syn::ExprRange> { 1479 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1480 let mut formatter = formatter.debug_struct("ExprRange"); 1481 if !self.value.attrs.is_empty() { 1482 formatter.field("attrs", Lite(&self.value.attrs)); 1483 } 1484 if let Some(val) = &self.value.start { 1485 #[derive(RefCast)] 1486 #[repr(transparent)] 1487 struct Print(Box<syn::Expr>); 1488 impl Debug for Print { 1489 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1490 formatter.write_str("Some(")?; 1491 Debug::fmt(Lite(&self.0), formatter)?; 1492 formatter.write_str(")")?; 1493 Ok(()) 1494 } 1495 } 1496 formatter.field("start", Print::ref_cast(val)); 1497 } 1498 formatter.field("limits", Lite(&self.value.limits)); 1499 if let Some(val) = &self.value.end { 1500 #[derive(RefCast)] 1501 #[repr(transparent)] 1502 struct Print(Box<syn::Expr>); 1503 impl Debug for Print { 1504 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1505 formatter.write_str("Some(")?; 1506 Debug::fmt(Lite(&self.0), formatter)?; 1507 formatter.write_str(")")?; 1508 Ok(()) 1509 } 1510 } 1511 formatter.field("end", Print::ref_cast(val)); 1512 } 1513 formatter.finish() 1514 } 1515} 1516impl Debug for Lite<syn::ExprReference> { 1517 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1518 let mut formatter = formatter.debug_struct("ExprReference"); 1519 if !self.value.attrs.is_empty() { 1520 formatter.field("attrs", Lite(&self.value.attrs)); 1521 } 1522 if self.value.mutability.is_some() { 1523 formatter.field("mutability", &Present); 1524 } 1525 formatter.field("expr", Lite(&self.value.expr)); 1526 formatter.finish() 1527 } 1528} 1529impl Debug for Lite<syn::ExprRepeat> { 1530 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1531 let mut formatter = formatter.debug_struct("ExprRepeat"); 1532 if !self.value.attrs.is_empty() { 1533 formatter.field("attrs", Lite(&self.value.attrs)); 1534 } 1535 formatter.field("expr", Lite(&self.value.expr)); 1536 formatter.field("len", Lite(&self.value.len)); 1537 formatter.finish() 1538 } 1539} 1540impl Debug for Lite<syn::ExprReturn> { 1541 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1542 let mut formatter = formatter.debug_struct("ExprReturn"); 1543 if !self.value.attrs.is_empty() { 1544 formatter.field("attrs", Lite(&self.value.attrs)); 1545 } 1546 if let Some(val) = &self.value.expr { 1547 #[derive(RefCast)] 1548 #[repr(transparent)] 1549 struct Print(Box<syn::Expr>); 1550 impl Debug for Print { 1551 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1552 formatter.write_str("Some(")?; 1553 Debug::fmt(Lite(&self.0), formatter)?; 1554 formatter.write_str(")")?; 1555 Ok(()) 1556 } 1557 } 1558 formatter.field("expr", Print::ref_cast(val)); 1559 } 1560 formatter.finish() 1561 } 1562} 1563impl Debug for Lite<syn::ExprStruct> { 1564 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1565 let mut formatter = formatter.debug_struct("ExprStruct"); 1566 if !self.value.attrs.is_empty() { 1567 formatter.field("attrs", Lite(&self.value.attrs)); 1568 } 1569 if let Some(val) = &self.value.qself { 1570 #[derive(RefCast)] 1571 #[repr(transparent)] 1572 struct Print(syn::QSelf); 1573 impl Debug for Print { 1574 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1575 formatter.write_str("Some(")?; 1576 Debug::fmt(Lite(&self.0), formatter)?; 1577 formatter.write_str(")")?; 1578 Ok(()) 1579 } 1580 } 1581 formatter.field("qself", Print::ref_cast(val)); 1582 } 1583 formatter.field("path", Lite(&self.value.path)); 1584 if !self.value.fields.is_empty() { 1585 formatter.field("fields", Lite(&self.value.fields)); 1586 } 1587 if self.value.dot2_token.is_some() { 1588 formatter.field("dot2_token", &Present); 1589 } 1590 if let Some(val) = &self.value.rest { 1591 #[derive(RefCast)] 1592 #[repr(transparent)] 1593 struct Print(Box<syn::Expr>); 1594 impl Debug for Print { 1595 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1596 formatter.write_str("Some(")?; 1597 Debug::fmt(Lite(&self.0), formatter)?; 1598 formatter.write_str(")")?; 1599 Ok(()) 1600 } 1601 } 1602 formatter.field("rest", Print::ref_cast(val)); 1603 } 1604 formatter.finish() 1605 } 1606} 1607impl Debug for Lite<syn::ExprTry> { 1608 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1609 let mut formatter = formatter.debug_struct("ExprTry"); 1610 if !self.value.attrs.is_empty() { 1611 formatter.field("attrs", Lite(&self.value.attrs)); 1612 } 1613 formatter.field("expr", Lite(&self.value.expr)); 1614 formatter.finish() 1615 } 1616} 1617impl Debug for Lite<syn::ExprTryBlock> { 1618 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1619 let mut formatter = formatter.debug_struct("ExprTryBlock"); 1620 if !self.value.attrs.is_empty() { 1621 formatter.field("attrs", Lite(&self.value.attrs)); 1622 } 1623 formatter.field("block", Lite(&self.value.block)); 1624 formatter.finish() 1625 } 1626} 1627impl Debug for Lite<syn::ExprTuple> { 1628 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1629 let mut formatter = formatter.debug_struct("ExprTuple"); 1630 if !self.value.attrs.is_empty() { 1631 formatter.field("attrs", Lite(&self.value.attrs)); 1632 } 1633 if !self.value.elems.is_empty() { 1634 formatter.field("elems", Lite(&self.value.elems)); 1635 } 1636 formatter.finish() 1637 } 1638} 1639impl Debug for Lite<syn::ExprUnary> { 1640 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1641 let mut formatter = formatter.debug_struct("ExprUnary"); 1642 if !self.value.attrs.is_empty() { 1643 formatter.field("attrs", Lite(&self.value.attrs)); 1644 } 1645 formatter.field("op", Lite(&self.value.op)); 1646 formatter.field("expr", Lite(&self.value.expr)); 1647 formatter.finish() 1648 } 1649} 1650impl Debug for Lite<syn::ExprUnsafe> { 1651 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1652 let mut formatter = formatter.debug_struct("ExprUnsafe"); 1653 if !self.value.attrs.is_empty() { 1654 formatter.field("attrs", Lite(&self.value.attrs)); 1655 } 1656 formatter.field("block", Lite(&self.value.block)); 1657 formatter.finish() 1658 } 1659} 1660impl Debug for Lite<syn::ExprWhile> { 1661 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1662 let mut formatter = formatter.debug_struct("ExprWhile"); 1663 if !self.value.attrs.is_empty() { 1664 formatter.field("attrs", Lite(&self.value.attrs)); 1665 } 1666 if let Some(val) = &self.value.label { 1667 #[derive(RefCast)] 1668 #[repr(transparent)] 1669 struct Print(syn::Label); 1670 impl Debug for Print { 1671 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1672 formatter.write_str("Some(")?; 1673 Debug::fmt(Lite(&self.0), formatter)?; 1674 formatter.write_str(")")?; 1675 Ok(()) 1676 } 1677 } 1678 formatter.field("label", Print::ref_cast(val)); 1679 } 1680 formatter.field("cond", Lite(&self.value.cond)); 1681 formatter.field("body", Lite(&self.value.body)); 1682 formatter.finish() 1683 } 1684} 1685impl Debug for Lite<syn::ExprYield> { 1686 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1687 let mut formatter = formatter.debug_struct("ExprYield"); 1688 if !self.value.attrs.is_empty() { 1689 formatter.field("attrs", Lite(&self.value.attrs)); 1690 } 1691 if let Some(val) = &self.value.expr { 1692 #[derive(RefCast)] 1693 #[repr(transparent)] 1694 struct Print(Box<syn::Expr>); 1695 impl Debug for Print { 1696 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1697 formatter.write_str("Some(")?; 1698 Debug::fmt(Lite(&self.0), formatter)?; 1699 formatter.write_str(")")?; 1700 Ok(()) 1701 } 1702 } 1703 formatter.field("expr", Print::ref_cast(val)); 1704 } 1705 formatter.finish() 1706 } 1707} 1708impl Debug for Lite<syn::Field> { 1709 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1710 let mut formatter = formatter.debug_struct("Field"); 1711 if !self.value.attrs.is_empty() { 1712 formatter.field("attrs", Lite(&self.value.attrs)); 1713 } 1714 formatter.field("vis", Lite(&self.value.vis)); 1715 match self.value.mutability { 1716 syn::FieldMutability::None => {} 1717 _ => { 1718 formatter.field("mutability", Lite(&self.value.mutability)); 1719 } 1720 } 1721 if let Some(val) = &self.value.ident { 1722 #[derive(RefCast)] 1723 #[repr(transparent)] 1724 struct Print(proc_macro2::Ident); 1725 impl Debug for Print { 1726 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1727 formatter.write_str("Some(")?; 1728 Debug::fmt(Lite(&self.0), formatter)?; 1729 formatter.write_str(")")?; 1730 Ok(()) 1731 } 1732 } 1733 formatter.field("ident", Print::ref_cast(val)); 1734 } 1735 if self.value.colon_token.is_some() { 1736 formatter.field("colon_token", &Present); 1737 } 1738 formatter.field("ty", Lite(&self.value.ty)); 1739 formatter.finish() 1740 } 1741} 1742impl Debug for Lite<syn::FieldMutability> { 1743 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1744 match &self.value { 1745 syn::FieldMutability::None => formatter.write_str("FieldMutability::None"), 1746 _ => unreachable!(), 1747 } 1748 } 1749} 1750impl Debug for Lite<syn::FieldPat> { 1751 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1752 let mut formatter = formatter.debug_struct("FieldPat"); 1753 if !self.value.attrs.is_empty() { 1754 formatter.field("attrs", Lite(&self.value.attrs)); 1755 } 1756 formatter.field("member", Lite(&self.value.member)); 1757 if self.value.colon_token.is_some() { 1758 formatter.field("colon_token", &Present); 1759 } 1760 formatter.field("pat", Lite(&self.value.pat)); 1761 formatter.finish() 1762 } 1763} 1764impl Debug for Lite<syn::FieldValue> { 1765 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1766 let mut formatter = formatter.debug_struct("FieldValue"); 1767 if !self.value.attrs.is_empty() { 1768 formatter.field("attrs", Lite(&self.value.attrs)); 1769 } 1770 formatter.field("member", Lite(&self.value.member)); 1771 if self.value.colon_token.is_some() { 1772 formatter.field("colon_token", &Present); 1773 } 1774 formatter.field("expr", Lite(&self.value.expr)); 1775 formatter.finish() 1776 } 1777} 1778impl Debug for Lite<syn::Fields> { 1779 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1780 match &self.value { 1781 syn::Fields::Named(_val) => { 1782 let mut formatter = formatter.debug_struct("Fields::Named"); 1783 if !_val.named.is_empty() { 1784 formatter.field("named", Lite(&_val.named)); 1785 } 1786 formatter.finish() 1787 } 1788 syn::Fields::Unnamed(_val) => { 1789 let mut formatter = formatter.debug_struct("Fields::Unnamed"); 1790 if !_val.unnamed.is_empty() { 1791 formatter.field("unnamed", Lite(&_val.unnamed)); 1792 } 1793 formatter.finish() 1794 } 1795 syn::Fields::Unit => formatter.write_str("Fields::Unit"), 1796 } 1797 } 1798} 1799impl Debug for Lite<syn::FieldsNamed> { 1800 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1801 let mut formatter = formatter.debug_struct("FieldsNamed"); 1802 if !self.value.named.is_empty() { 1803 formatter.field("named", Lite(&self.value.named)); 1804 } 1805 formatter.finish() 1806 } 1807} 1808impl Debug for Lite<syn::FieldsUnnamed> { 1809 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1810 let mut formatter = formatter.debug_struct("FieldsUnnamed"); 1811 if !self.value.unnamed.is_empty() { 1812 formatter.field("unnamed", Lite(&self.value.unnamed)); 1813 } 1814 formatter.finish() 1815 } 1816} 1817impl Debug for Lite<syn::File> { 1818 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1819 let mut formatter = formatter.debug_struct("File"); 1820 if let Some(val) = &self.value.shebang { 1821 #[derive(RefCast)] 1822 #[repr(transparent)] 1823 struct Print(String); 1824 impl Debug for Print { 1825 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1826 formatter.write_str("Some(")?; 1827 Debug::fmt(Lite(&self.0), formatter)?; 1828 formatter.write_str(")")?; 1829 Ok(()) 1830 } 1831 } 1832 formatter.field("shebang", Print::ref_cast(val)); 1833 } 1834 if !self.value.attrs.is_empty() { 1835 formatter.field("attrs", Lite(&self.value.attrs)); 1836 } 1837 if !self.value.items.is_empty() { 1838 formatter.field("items", Lite(&self.value.items)); 1839 } 1840 formatter.finish() 1841 } 1842} 1843impl Debug for Lite<syn::FnArg> { 1844 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1845 match &self.value { 1846 syn::FnArg::Receiver(_val) => { 1847 formatter.write_str("FnArg::Receiver")?; 1848 formatter.write_str("(")?; 1849 Debug::fmt(Lite(_val), formatter)?; 1850 formatter.write_str(")")?; 1851 Ok(()) 1852 } 1853 syn::FnArg::Typed(_val) => { 1854 formatter.write_str("FnArg::Typed")?; 1855 formatter.write_str("(")?; 1856 Debug::fmt(Lite(_val), formatter)?; 1857 formatter.write_str(")")?; 1858 Ok(()) 1859 } 1860 } 1861 } 1862} 1863impl Debug for Lite<syn::ForeignItem> { 1864 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1865 match &self.value { 1866 syn::ForeignItem::Fn(_val) => { 1867 let mut formatter = formatter.debug_struct("ForeignItem::Fn"); 1868 if !_val.attrs.is_empty() { 1869 formatter.field("attrs", Lite(&_val.attrs)); 1870 } 1871 formatter.field("vis", Lite(&_val.vis)); 1872 formatter.field("sig", Lite(&_val.sig)); 1873 formatter.finish() 1874 } 1875 syn::ForeignItem::Static(_val) => { 1876 let mut formatter = formatter.debug_struct("ForeignItem::Static"); 1877 if !_val.attrs.is_empty() { 1878 formatter.field("attrs", Lite(&_val.attrs)); 1879 } 1880 formatter.field("vis", Lite(&_val.vis)); 1881 match _val.mutability { 1882 syn::StaticMutability::None => {} 1883 _ => { 1884 formatter.field("mutability", Lite(&_val.mutability)); 1885 } 1886 } 1887 formatter.field("ident", Lite(&_val.ident)); 1888 formatter.field("ty", Lite(&_val.ty)); 1889 formatter.finish() 1890 } 1891 syn::ForeignItem::Type(_val) => { 1892 let mut formatter = formatter.debug_struct("ForeignItem::Type"); 1893 if !_val.attrs.is_empty() { 1894 formatter.field("attrs", Lite(&_val.attrs)); 1895 } 1896 formatter.field("vis", Lite(&_val.vis)); 1897 formatter.field("ident", Lite(&_val.ident)); 1898 formatter.field("generics", Lite(&_val.generics)); 1899 formatter.finish() 1900 } 1901 syn::ForeignItem::Macro(_val) => { 1902 let mut formatter = formatter.debug_struct("ForeignItem::Macro"); 1903 if !_val.attrs.is_empty() { 1904 formatter.field("attrs", Lite(&_val.attrs)); 1905 } 1906 formatter.field("mac", Lite(&_val.mac)); 1907 if _val.semi_token.is_some() { 1908 formatter.field("semi_token", &Present); 1909 } 1910 formatter.finish() 1911 } 1912 syn::ForeignItem::Verbatim(_val) => { 1913 formatter.write_str("ForeignItem::Verbatim")?; 1914 formatter.write_str("(`")?; 1915 Display::fmt(_val, formatter)?; 1916 formatter.write_str("`)")?; 1917 Ok(()) 1918 } 1919 _ => unreachable!(), 1920 } 1921 } 1922} 1923impl Debug for Lite<syn::ForeignItemFn> { 1924 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1925 let mut formatter = formatter.debug_struct("ForeignItemFn"); 1926 if !self.value.attrs.is_empty() { 1927 formatter.field("attrs", Lite(&self.value.attrs)); 1928 } 1929 formatter.field("vis", Lite(&self.value.vis)); 1930 formatter.field("sig", Lite(&self.value.sig)); 1931 formatter.finish() 1932 } 1933} 1934impl Debug for Lite<syn::ForeignItemMacro> { 1935 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1936 let mut formatter = formatter.debug_struct("ForeignItemMacro"); 1937 if !self.value.attrs.is_empty() { 1938 formatter.field("attrs", Lite(&self.value.attrs)); 1939 } 1940 formatter.field("mac", Lite(&self.value.mac)); 1941 if self.value.semi_token.is_some() { 1942 formatter.field("semi_token", &Present); 1943 } 1944 formatter.finish() 1945 } 1946} 1947impl Debug for Lite<syn::ForeignItemStatic> { 1948 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1949 let mut formatter = formatter.debug_struct("ForeignItemStatic"); 1950 if !self.value.attrs.is_empty() { 1951 formatter.field("attrs", Lite(&self.value.attrs)); 1952 } 1953 formatter.field("vis", Lite(&self.value.vis)); 1954 match self.value.mutability { 1955 syn::StaticMutability::None => {} 1956 _ => { 1957 formatter.field("mutability", Lite(&self.value.mutability)); 1958 } 1959 } 1960 formatter.field("ident", Lite(&self.value.ident)); 1961 formatter.field("ty", Lite(&self.value.ty)); 1962 formatter.finish() 1963 } 1964} 1965impl Debug for Lite<syn::ForeignItemType> { 1966 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1967 let mut formatter = formatter.debug_struct("ForeignItemType"); 1968 if !self.value.attrs.is_empty() { 1969 formatter.field("attrs", Lite(&self.value.attrs)); 1970 } 1971 formatter.field("vis", Lite(&self.value.vis)); 1972 formatter.field("ident", Lite(&self.value.ident)); 1973 formatter.field("generics", Lite(&self.value.generics)); 1974 formatter.finish() 1975 } 1976} 1977impl Debug for Lite<syn::GenericArgument> { 1978 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1979 match &self.value { 1980 syn::GenericArgument::Lifetime(_val) => { 1981 formatter.write_str("GenericArgument::Lifetime")?; 1982 formatter.write_str("(")?; 1983 Debug::fmt(Lite(_val), formatter)?; 1984 formatter.write_str(")")?; 1985 Ok(()) 1986 } 1987 syn::GenericArgument::Type(_val) => { 1988 formatter.write_str("GenericArgument::Type")?; 1989 formatter.write_str("(")?; 1990 Debug::fmt(Lite(_val), formatter)?; 1991 formatter.write_str(")")?; 1992 Ok(()) 1993 } 1994 syn::GenericArgument::Const(_val) => { 1995 formatter.write_str("GenericArgument::Const")?; 1996 formatter.write_str("(")?; 1997 Debug::fmt(Lite(_val), formatter)?; 1998 formatter.write_str(")")?; 1999 Ok(()) 2000 } 2001 syn::GenericArgument::AssocType(_val) => { 2002 formatter.write_str("GenericArgument::AssocType")?; 2003 formatter.write_str("(")?; 2004 Debug::fmt(Lite(_val), formatter)?; 2005 formatter.write_str(")")?; 2006 Ok(()) 2007 } 2008 syn::GenericArgument::AssocConst(_val) => { 2009 formatter.write_str("GenericArgument::AssocConst")?; 2010 formatter.write_str("(")?; 2011 Debug::fmt(Lite(_val), formatter)?; 2012 formatter.write_str(")")?; 2013 Ok(()) 2014 } 2015 syn::GenericArgument::Constraint(_val) => { 2016 formatter.write_str("GenericArgument::Constraint")?; 2017 formatter.write_str("(")?; 2018 Debug::fmt(Lite(_val), formatter)?; 2019 formatter.write_str(")")?; 2020 Ok(()) 2021 } 2022 _ => unreachable!(), 2023 } 2024 } 2025} 2026impl Debug for Lite<syn::GenericParam> { 2027 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2028 match &self.value { 2029 syn::GenericParam::Lifetime(_val) => { 2030 formatter.write_str("GenericParam::Lifetime")?; 2031 formatter.write_str("(")?; 2032 Debug::fmt(Lite(_val), formatter)?; 2033 formatter.write_str(")")?; 2034 Ok(()) 2035 } 2036 syn::GenericParam::Type(_val) => { 2037 formatter.write_str("GenericParam::Type")?; 2038 formatter.write_str("(")?; 2039 Debug::fmt(Lite(_val), formatter)?; 2040 formatter.write_str(")")?; 2041 Ok(()) 2042 } 2043 syn::GenericParam::Const(_val) => { 2044 formatter.write_str("GenericParam::Const")?; 2045 formatter.write_str("(")?; 2046 Debug::fmt(Lite(_val), formatter)?; 2047 formatter.write_str(")")?; 2048 Ok(()) 2049 } 2050 } 2051 } 2052} 2053impl Debug for Lite<syn::Generics> { 2054 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2055 let mut formatter = formatter.debug_struct("Generics"); 2056 if self.value.lt_token.is_some() { 2057 formatter.field("lt_token", &Present); 2058 } 2059 if !self.value.params.is_empty() { 2060 formatter.field("params", Lite(&self.value.params)); 2061 } 2062 if self.value.gt_token.is_some() { 2063 formatter.field("gt_token", &Present); 2064 } 2065 if let Some(val) = &self.value.where_clause { 2066 #[derive(RefCast)] 2067 #[repr(transparent)] 2068 struct Print(syn::WhereClause); 2069 impl Debug for Print { 2070 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2071 formatter.write_str("Some(")?; 2072 Debug::fmt(Lite(&self.0), formatter)?; 2073 formatter.write_str(")")?; 2074 Ok(()) 2075 } 2076 } 2077 formatter.field("where_clause", Print::ref_cast(val)); 2078 } 2079 formatter.finish() 2080 } 2081} 2082impl Debug for Lite<syn::ImplItem> { 2083 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2084 match &self.value { 2085 syn::ImplItem::Const(_val) => { 2086 let mut formatter = formatter.debug_struct("ImplItem::Const"); 2087 if !_val.attrs.is_empty() { 2088 formatter.field("attrs", Lite(&_val.attrs)); 2089 } 2090 formatter.field("vis", Lite(&_val.vis)); 2091 if _val.defaultness.is_some() { 2092 formatter.field("defaultness", &Present); 2093 } 2094 formatter.field("ident", Lite(&_val.ident)); 2095 formatter.field("generics", Lite(&_val.generics)); 2096 formatter.field("ty", Lite(&_val.ty)); 2097 formatter.field("expr", Lite(&_val.expr)); 2098 formatter.finish() 2099 } 2100 syn::ImplItem::Fn(_val) => { 2101 let mut formatter = formatter.debug_struct("ImplItem::Fn"); 2102 if !_val.attrs.is_empty() { 2103 formatter.field("attrs", Lite(&_val.attrs)); 2104 } 2105 formatter.field("vis", Lite(&_val.vis)); 2106 if _val.defaultness.is_some() { 2107 formatter.field("defaultness", &Present); 2108 } 2109 formatter.field("sig", Lite(&_val.sig)); 2110 formatter.field("block", Lite(&_val.block)); 2111 formatter.finish() 2112 } 2113 syn::ImplItem::Type(_val) => { 2114 let mut formatter = formatter.debug_struct("ImplItem::Type"); 2115 if !_val.attrs.is_empty() { 2116 formatter.field("attrs", Lite(&_val.attrs)); 2117 } 2118 formatter.field("vis", Lite(&_val.vis)); 2119 if _val.defaultness.is_some() { 2120 formatter.field("defaultness", &Present); 2121 } 2122 formatter.field("ident", Lite(&_val.ident)); 2123 formatter.field("generics", Lite(&_val.generics)); 2124 formatter.field("ty", Lite(&_val.ty)); 2125 formatter.finish() 2126 } 2127 syn::ImplItem::Macro(_val) => { 2128 let mut formatter = formatter.debug_struct("ImplItem::Macro"); 2129 if !_val.attrs.is_empty() { 2130 formatter.field("attrs", Lite(&_val.attrs)); 2131 } 2132 formatter.field("mac", Lite(&_val.mac)); 2133 if _val.semi_token.is_some() { 2134 formatter.field("semi_token", &Present); 2135 } 2136 formatter.finish() 2137 } 2138 syn::ImplItem::Verbatim(_val) => { 2139 formatter.write_str("ImplItem::Verbatim")?; 2140 formatter.write_str("(`")?; 2141 Display::fmt(_val, formatter)?; 2142 formatter.write_str("`)")?; 2143 Ok(()) 2144 } 2145 _ => unreachable!(), 2146 } 2147 } 2148} 2149impl Debug for Lite<syn::ImplItemConst> { 2150 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2151 let mut formatter = formatter.debug_struct("ImplItemConst"); 2152 if !self.value.attrs.is_empty() { 2153 formatter.field("attrs", Lite(&self.value.attrs)); 2154 } 2155 formatter.field("vis", Lite(&self.value.vis)); 2156 if self.value.defaultness.is_some() { 2157 formatter.field("defaultness", &Present); 2158 } 2159 formatter.field("ident", Lite(&self.value.ident)); 2160 formatter.field("generics", Lite(&self.value.generics)); 2161 formatter.field("ty", Lite(&self.value.ty)); 2162 formatter.field("expr", Lite(&self.value.expr)); 2163 formatter.finish() 2164 } 2165} 2166impl Debug for Lite<syn::ImplItemFn> { 2167 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2168 let mut formatter = formatter.debug_struct("ImplItemFn"); 2169 if !self.value.attrs.is_empty() { 2170 formatter.field("attrs", Lite(&self.value.attrs)); 2171 } 2172 formatter.field("vis", Lite(&self.value.vis)); 2173 if self.value.defaultness.is_some() { 2174 formatter.field("defaultness", &Present); 2175 } 2176 formatter.field("sig", Lite(&self.value.sig)); 2177 formatter.field("block", Lite(&self.value.block)); 2178 formatter.finish() 2179 } 2180} 2181impl Debug for Lite<syn::ImplItemMacro> { 2182 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2183 let mut formatter = formatter.debug_struct("ImplItemMacro"); 2184 if !self.value.attrs.is_empty() { 2185 formatter.field("attrs", Lite(&self.value.attrs)); 2186 } 2187 formatter.field("mac", Lite(&self.value.mac)); 2188 if self.value.semi_token.is_some() { 2189 formatter.field("semi_token", &Present); 2190 } 2191 formatter.finish() 2192 } 2193} 2194impl Debug for Lite<syn::ImplItemType> { 2195 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2196 let mut formatter = formatter.debug_struct("ImplItemType"); 2197 if !self.value.attrs.is_empty() { 2198 formatter.field("attrs", Lite(&self.value.attrs)); 2199 } 2200 formatter.field("vis", Lite(&self.value.vis)); 2201 if self.value.defaultness.is_some() { 2202 formatter.field("defaultness", &Present); 2203 } 2204 formatter.field("ident", Lite(&self.value.ident)); 2205 formatter.field("generics", Lite(&self.value.generics)); 2206 formatter.field("ty", Lite(&self.value.ty)); 2207 formatter.finish() 2208 } 2209} 2210impl Debug for Lite<syn::ImplRestriction> { 2211 fn fmt(&self, _formatter: &mut fmt::Formatter) -> fmt::Result { 2212 unreachable!() 2213 } 2214} 2215impl Debug for Lite<syn::Index> { 2216 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2217 let mut formatter = formatter.debug_struct("Index"); 2218 formatter.field("index", Lite(&self.value.index)); 2219 formatter.finish() 2220 } 2221} 2222impl Debug for Lite<syn::Item> { 2223 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2224 match &self.value { 2225 syn::Item::Const(_val) => { 2226 let mut formatter = formatter.debug_struct("Item::Const"); 2227 if !_val.attrs.is_empty() { 2228 formatter.field("attrs", Lite(&_val.attrs)); 2229 } 2230 formatter.field("vis", Lite(&_val.vis)); 2231 formatter.field("ident", Lite(&_val.ident)); 2232 formatter.field("generics", Lite(&_val.generics)); 2233 formatter.field("ty", Lite(&_val.ty)); 2234 formatter.field("expr", Lite(&_val.expr)); 2235 formatter.finish() 2236 } 2237 syn::Item::Enum(_val) => { 2238 let mut formatter = formatter.debug_struct("Item::Enum"); 2239 if !_val.attrs.is_empty() { 2240 formatter.field("attrs", Lite(&_val.attrs)); 2241 } 2242 formatter.field("vis", Lite(&_val.vis)); 2243 formatter.field("ident", Lite(&_val.ident)); 2244 formatter.field("generics", Lite(&_val.generics)); 2245 if !_val.variants.is_empty() { 2246 formatter.field("variants", Lite(&_val.variants)); 2247 } 2248 formatter.finish() 2249 } 2250 syn::Item::ExternCrate(_val) => { 2251 let mut formatter = formatter.debug_struct("Item::ExternCrate"); 2252 if !_val.attrs.is_empty() { 2253 formatter.field("attrs", Lite(&_val.attrs)); 2254 } 2255 formatter.field("vis", Lite(&_val.vis)); 2256 formatter.field("ident", Lite(&_val.ident)); 2257 if let Some(val) = &_val.rename { 2258 #[derive(RefCast)] 2259 #[repr(transparent)] 2260 struct Print((syn::token::As, proc_macro2::Ident)); 2261 impl Debug for Print { 2262 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2263 formatter.write_str("Some(")?; 2264 Debug::fmt(Lite(&self.0.1), formatter)?; 2265 formatter.write_str(")")?; 2266 Ok(()) 2267 } 2268 } 2269 formatter.field("rename", Print::ref_cast(val)); 2270 } 2271 formatter.finish() 2272 } 2273 syn::Item::Fn(_val) => { 2274 let mut formatter = formatter.debug_struct("Item::Fn"); 2275 if !_val.attrs.is_empty() { 2276 formatter.field("attrs", Lite(&_val.attrs)); 2277 } 2278 formatter.field("vis", Lite(&_val.vis)); 2279 formatter.field("sig", Lite(&_val.sig)); 2280 formatter.field("block", Lite(&_val.block)); 2281 formatter.finish() 2282 } 2283 syn::Item::ForeignMod(_val) => { 2284 let mut formatter = formatter.debug_struct("Item::ForeignMod"); 2285 if !_val.attrs.is_empty() { 2286 formatter.field("attrs", Lite(&_val.attrs)); 2287 } 2288 if _val.unsafety.is_some() { 2289 formatter.field("unsafety", &Present); 2290 } 2291 formatter.field("abi", Lite(&_val.abi)); 2292 if !_val.items.is_empty() { 2293 formatter.field("items", Lite(&_val.items)); 2294 } 2295 formatter.finish() 2296 } 2297 syn::Item::Impl(_val) => { 2298 let mut formatter = formatter.debug_struct("Item::Impl"); 2299 if !_val.attrs.is_empty() { 2300 formatter.field("attrs", Lite(&_val.attrs)); 2301 } 2302 if _val.defaultness.is_some() { 2303 formatter.field("defaultness", &Present); 2304 } 2305 if _val.unsafety.is_some() { 2306 formatter.field("unsafety", &Present); 2307 } 2308 formatter.field("generics", Lite(&_val.generics)); 2309 if let Some(val) = &_val.trait_ { 2310 #[derive(RefCast)] 2311 #[repr(transparent)] 2312 struct Print((Option<syn::token::Not>, syn::Path, syn::token::For)); 2313 impl Debug for Print { 2314 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2315 formatter.write_str("Some(")?; 2316 Debug::fmt( 2317 &( 2318 &super::Option { 2319 present: self.0.0.is_some(), 2320 }, 2321 Lite(&self.0.1), 2322 ), 2323 formatter, 2324 )?; 2325 formatter.write_str(")")?; 2326 Ok(()) 2327 } 2328 } 2329 formatter.field("trait_", Print::ref_cast(val)); 2330 } 2331 formatter.field("self_ty", Lite(&_val.self_ty)); 2332 if !_val.items.is_empty() { 2333 formatter.field("items", Lite(&_val.items)); 2334 } 2335 formatter.finish() 2336 } 2337 syn::Item::Macro(_val) => { 2338 let mut formatter = formatter.debug_struct("Item::Macro"); 2339 if !_val.attrs.is_empty() { 2340 formatter.field("attrs", Lite(&_val.attrs)); 2341 } 2342 if let Some(val) = &_val.ident { 2343 #[derive(RefCast)] 2344 #[repr(transparent)] 2345 struct Print(proc_macro2::Ident); 2346 impl Debug for Print { 2347 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2348 formatter.write_str("Some(")?; 2349 Debug::fmt(Lite(&self.0), formatter)?; 2350 formatter.write_str(")")?; 2351 Ok(()) 2352 } 2353 } 2354 formatter.field("ident", Print::ref_cast(val)); 2355 } 2356 formatter.field("mac", Lite(&_val.mac)); 2357 if _val.semi_token.is_some() { 2358 formatter.field("semi_token", &Present); 2359 } 2360 formatter.finish() 2361 } 2362 syn::Item::Mod(_val) => { 2363 let mut formatter = formatter.debug_struct("Item::Mod"); 2364 if !_val.attrs.is_empty() { 2365 formatter.field("attrs", Lite(&_val.attrs)); 2366 } 2367 formatter.field("vis", Lite(&_val.vis)); 2368 if _val.unsafety.is_some() { 2369 formatter.field("unsafety", &Present); 2370 } 2371 formatter.field("ident", Lite(&_val.ident)); 2372 if let Some(val) = &_val.content { 2373 #[derive(RefCast)] 2374 #[repr(transparent)] 2375 struct Print((syn::token::Brace, Vec<syn::Item>)); 2376 impl Debug for Print { 2377 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2378 formatter.write_str("Some(")?; 2379 Debug::fmt(Lite(&self.0.1), formatter)?; 2380 formatter.write_str(")")?; 2381 Ok(()) 2382 } 2383 } 2384 formatter.field("content", Print::ref_cast(val)); 2385 } 2386 if _val.semi.is_some() { 2387 formatter.field("semi", &Present); 2388 } 2389 formatter.finish() 2390 } 2391 syn::Item::Static(_val) => { 2392 let mut formatter = formatter.debug_struct("Item::Static"); 2393 if !_val.attrs.is_empty() { 2394 formatter.field("attrs", Lite(&_val.attrs)); 2395 } 2396 formatter.field("vis", Lite(&_val.vis)); 2397 match _val.mutability { 2398 syn::StaticMutability::None => {} 2399 _ => { 2400 formatter.field("mutability", Lite(&_val.mutability)); 2401 } 2402 } 2403 formatter.field("ident", Lite(&_val.ident)); 2404 formatter.field("ty", Lite(&_val.ty)); 2405 formatter.field("expr", Lite(&_val.expr)); 2406 formatter.finish() 2407 } 2408 syn::Item::Struct(_val) => { 2409 let mut formatter = formatter.debug_struct("Item::Struct"); 2410 if !_val.attrs.is_empty() { 2411 formatter.field("attrs", Lite(&_val.attrs)); 2412 } 2413 formatter.field("vis", Lite(&_val.vis)); 2414 formatter.field("ident", Lite(&_val.ident)); 2415 formatter.field("generics", Lite(&_val.generics)); 2416 formatter.field("fields", Lite(&_val.fields)); 2417 if _val.semi_token.is_some() { 2418 formatter.field("semi_token", &Present); 2419 } 2420 formatter.finish() 2421 } 2422 syn::Item::Trait(_val) => { 2423 let mut formatter = formatter.debug_struct("Item::Trait"); 2424 if !_val.attrs.is_empty() { 2425 formatter.field("attrs", Lite(&_val.attrs)); 2426 } 2427 formatter.field("vis", Lite(&_val.vis)); 2428 if _val.unsafety.is_some() { 2429 formatter.field("unsafety", &Present); 2430 } 2431 if _val.auto_token.is_some() { 2432 formatter.field("auto_token", &Present); 2433 } 2434 if let Some(val) = &_val.restriction { 2435 #[derive(RefCast)] 2436 #[repr(transparent)] 2437 struct Print(syn::ImplRestriction); 2438 impl Debug for Print { 2439 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2440 formatter.write_str("Some(")?; 2441 Debug::fmt(Lite(&self.0), formatter)?; 2442 formatter.write_str(")")?; 2443 Ok(()) 2444 } 2445 } 2446 formatter.field("restriction", Print::ref_cast(val)); 2447 } 2448 formatter.field("ident", Lite(&_val.ident)); 2449 formatter.field("generics", Lite(&_val.generics)); 2450 if _val.colon_token.is_some() { 2451 formatter.field("colon_token", &Present); 2452 } 2453 if !_val.supertraits.is_empty() { 2454 formatter.field("supertraits", Lite(&_val.supertraits)); 2455 } 2456 if !_val.items.is_empty() { 2457 formatter.field("items", Lite(&_val.items)); 2458 } 2459 formatter.finish() 2460 } 2461 syn::Item::TraitAlias(_val) => { 2462 let mut formatter = formatter.debug_struct("Item::TraitAlias"); 2463 if !_val.attrs.is_empty() { 2464 formatter.field("attrs", Lite(&_val.attrs)); 2465 } 2466 formatter.field("vis", Lite(&_val.vis)); 2467 formatter.field("ident", Lite(&_val.ident)); 2468 formatter.field("generics", Lite(&_val.generics)); 2469 if !_val.bounds.is_empty() { 2470 formatter.field("bounds", Lite(&_val.bounds)); 2471 } 2472 formatter.finish() 2473 } 2474 syn::Item::Type(_val) => { 2475 let mut formatter = formatter.debug_struct("Item::Type"); 2476 if !_val.attrs.is_empty() { 2477 formatter.field("attrs", Lite(&_val.attrs)); 2478 } 2479 formatter.field("vis", Lite(&_val.vis)); 2480 formatter.field("ident", Lite(&_val.ident)); 2481 formatter.field("generics", Lite(&_val.generics)); 2482 formatter.field("ty", Lite(&_val.ty)); 2483 formatter.finish() 2484 } 2485 syn::Item::Union(_val) => { 2486 let mut formatter = formatter.debug_struct("Item::Union"); 2487 if !_val.attrs.is_empty() { 2488 formatter.field("attrs", Lite(&_val.attrs)); 2489 } 2490 formatter.field("vis", Lite(&_val.vis)); 2491 formatter.field("ident", Lite(&_val.ident)); 2492 formatter.field("generics", Lite(&_val.generics)); 2493 formatter.field("fields", Lite(&_val.fields)); 2494 formatter.finish() 2495 } 2496 syn::Item::Use(_val) => { 2497 let mut formatter = formatter.debug_struct("Item::Use"); 2498 if !_val.attrs.is_empty() { 2499 formatter.field("attrs", Lite(&_val.attrs)); 2500 } 2501 formatter.field("vis", Lite(&_val.vis)); 2502 if _val.leading_colon.is_some() { 2503 formatter.field("leading_colon", &Present); 2504 } 2505 formatter.field("tree", Lite(&_val.tree)); 2506 formatter.finish() 2507 } 2508 syn::Item::Verbatim(_val) => { 2509 formatter.write_str("Item::Verbatim")?; 2510 formatter.write_str("(`")?; 2511 Display::fmt(_val, formatter)?; 2512 formatter.write_str("`)")?; 2513 Ok(()) 2514 } 2515 _ => unreachable!(), 2516 } 2517 } 2518} 2519impl Debug for Lite<syn::ItemConst> { 2520 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2521 let mut formatter = formatter.debug_struct("ItemConst"); 2522 if !self.value.attrs.is_empty() { 2523 formatter.field("attrs", Lite(&self.value.attrs)); 2524 } 2525 formatter.field("vis", Lite(&self.value.vis)); 2526 formatter.field("ident", Lite(&self.value.ident)); 2527 formatter.field("generics", Lite(&self.value.generics)); 2528 formatter.field("ty", Lite(&self.value.ty)); 2529 formatter.field("expr", Lite(&self.value.expr)); 2530 formatter.finish() 2531 } 2532} 2533impl Debug for Lite<syn::ItemEnum> { 2534 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2535 let mut formatter = formatter.debug_struct("ItemEnum"); 2536 if !self.value.attrs.is_empty() { 2537 formatter.field("attrs", Lite(&self.value.attrs)); 2538 } 2539 formatter.field("vis", Lite(&self.value.vis)); 2540 formatter.field("ident", Lite(&self.value.ident)); 2541 formatter.field("generics", Lite(&self.value.generics)); 2542 if !self.value.variants.is_empty() { 2543 formatter.field("variants", Lite(&self.value.variants)); 2544 } 2545 formatter.finish() 2546 } 2547} 2548impl Debug for Lite<syn::ItemExternCrate> { 2549 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2550 let mut formatter = formatter.debug_struct("ItemExternCrate"); 2551 if !self.value.attrs.is_empty() { 2552 formatter.field("attrs", Lite(&self.value.attrs)); 2553 } 2554 formatter.field("vis", Lite(&self.value.vis)); 2555 formatter.field("ident", Lite(&self.value.ident)); 2556 if let Some(val) = &self.value.rename { 2557 #[derive(RefCast)] 2558 #[repr(transparent)] 2559 struct Print((syn::token::As, proc_macro2::Ident)); 2560 impl Debug for Print { 2561 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2562 formatter.write_str("Some(")?; 2563 Debug::fmt(Lite(&self.0.1), formatter)?; 2564 formatter.write_str(")")?; 2565 Ok(()) 2566 } 2567 } 2568 formatter.field("rename", Print::ref_cast(val)); 2569 } 2570 formatter.finish() 2571 } 2572} 2573impl Debug for Lite<syn::ItemFn> { 2574 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2575 let mut formatter = formatter.debug_struct("ItemFn"); 2576 if !self.value.attrs.is_empty() { 2577 formatter.field("attrs", Lite(&self.value.attrs)); 2578 } 2579 formatter.field("vis", Lite(&self.value.vis)); 2580 formatter.field("sig", Lite(&self.value.sig)); 2581 formatter.field("block", Lite(&self.value.block)); 2582 formatter.finish() 2583 } 2584} 2585impl Debug for Lite<syn::ItemForeignMod> { 2586 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2587 let mut formatter = formatter.debug_struct("ItemForeignMod"); 2588 if !self.value.attrs.is_empty() { 2589 formatter.field("attrs", Lite(&self.value.attrs)); 2590 } 2591 if self.value.unsafety.is_some() { 2592 formatter.field("unsafety", &Present); 2593 } 2594 formatter.field("abi", Lite(&self.value.abi)); 2595 if !self.value.items.is_empty() { 2596 formatter.field("items", Lite(&self.value.items)); 2597 } 2598 formatter.finish() 2599 } 2600} 2601impl Debug for Lite<syn::ItemImpl> { 2602 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2603 let mut formatter = formatter.debug_struct("ItemImpl"); 2604 if !self.value.attrs.is_empty() { 2605 formatter.field("attrs", Lite(&self.value.attrs)); 2606 } 2607 if self.value.defaultness.is_some() { 2608 formatter.field("defaultness", &Present); 2609 } 2610 if self.value.unsafety.is_some() { 2611 formatter.field("unsafety", &Present); 2612 } 2613 formatter.field("generics", Lite(&self.value.generics)); 2614 if let Some(val) = &self.value.trait_ { 2615 #[derive(RefCast)] 2616 #[repr(transparent)] 2617 struct Print((Option<syn::token::Not>, syn::Path, syn::token::For)); 2618 impl Debug for Print { 2619 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2620 formatter.write_str("Some(")?; 2621 Debug::fmt( 2622 &( 2623 &super::Option { 2624 present: self.0.0.is_some(), 2625 }, 2626 Lite(&self.0.1), 2627 ), 2628 formatter, 2629 )?; 2630 formatter.write_str(")")?; 2631 Ok(()) 2632 } 2633 } 2634 formatter.field("trait_", Print::ref_cast(val)); 2635 } 2636 formatter.field("self_ty", Lite(&self.value.self_ty)); 2637 if !self.value.items.is_empty() { 2638 formatter.field("items", Lite(&self.value.items)); 2639 } 2640 formatter.finish() 2641 } 2642} 2643impl Debug for Lite<syn::ItemMacro> { 2644 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2645 let mut formatter = formatter.debug_struct("ItemMacro"); 2646 if !self.value.attrs.is_empty() { 2647 formatter.field("attrs", Lite(&self.value.attrs)); 2648 } 2649 if let Some(val) = &self.value.ident { 2650 #[derive(RefCast)] 2651 #[repr(transparent)] 2652 struct Print(proc_macro2::Ident); 2653 impl Debug for Print { 2654 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2655 formatter.write_str("Some(")?; 2656 Debug::fmt(Lite(&self.0), formatter)?; 2657 formatter.write_str(")")?; 2658 Ok(()) 2659 } 2660 } 2661 formatter.field("ident", Print::ref_cast(val)); 2662 } 2663 formatter.field("mac", Lite(&self.value.mac)); 2664 if self.value.semi_token.is_some() { 2665 formatter.field("semi_token", &Present); 2666 } 2667 formatter.finish() 2668 } 2669} 2670impl Debug for Lite<syn::ItemMod> { 2671 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2672 let mut formatter = formatter.debug_struct("ItemMod"); 2673 if !self.value.attrs.is_empty() { 2674 formatter.field("attrs", Lite(&self.value.attrs)); 2675 } 2676 formatter.field("vis", Lite(&self.value.vis)); 2677 if self.value.unsafety.is_some() { 2678 formatter.field("unsafety", &Present); 2679 } 2680 formatter.field("ident", Lite(&self.value.ident)); 2681 if let Some(val) = &self.value.content { 2682 #[derive(RefCast)] 2683 #[repr(transparent)] 2684 struct Print((syn::token::Brace, Vec<syn::Item>)); 2685 impl Debug for Print { 2686 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2687 formatter.write_str("Some(")?; 2688 Debug::fmt(Lite(&self.0.1), formatter)?; 2689 formatter.write_str(")")?; 2690 Ok(()) 2691 } 2692 } 2693 formatter.field("content", Print::ref_cast(val)); 2694 } 2695 if self.value.semi.is_some() { 2696 formatter.field("semi", &Present); 2697 } 2698 formatter.finish() 2699 } 2700} 2701impl Debug for Lite<syn::ItemStatic> { 2702 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2703 let mut formatter = formatter.debug_struct("ItemStatic"); 2704 if !self.value.attrs.is_empty() { 2705 formatter.field("attrs", Lite(&self.value.attrs)); 2706 } 2707 formatter.field("vis", Lite(&self.value.vis)); 2708 match self.value.mutability { 2709 syn::StaticMutability::None => {} 2710 _ => { 2711 formatter.field("mutability", Lite(&self.value.mutability)); 2712 } 2713 } 2714 formatter.field("ident", Lite(&self.value.ident)); 2715 formatter.field("ty", Lite(&self.value.ty)); 2716 formatter.field("expr", Lite(&self.value.expr)); 2717 formatter.finish() 2718 } 2719} 2720impl Debug for Lite<syn::ItemStruct> { 2721 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2722 let mut formatter = formatter.debug_struct("ItemStruct"); 2723 if !self.value.attrs.is_empty() { 2724 formatter.field("attrs", Lite(&self.value.attrs)); 2725 } 2726 formatter.field("vis", Lite(&self.value.vis)); 2727 formatter.field("ident", Lite(&self.value.ident)); 2728 formatter.field("generics", Lite(&self.value.generics)); 2729 formatter.field("fields", Lite(&self.value.fields)); 2730 if self.value.semi_token.is_some() { 2731 formatter.field("semi_token", &Present); 2732 } 2733 formatter.finish() 2734 } 2735} 2736impl Debug for Lite<syn::ItemTrait> { 2737 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2738 let mut formatter = formatter.debug_struct("ItemTrait"); 2739 if !self.value.attrs.is_empty() { 2740 formatter.field("attrs", Lite(&self.value.attrs)); 2741 } 2742 formatter.field("vis", Lite(&self.value.vis)); 2743 if self.value.unsafety.is_some() { 2744 formatter.field("unsafety", &Present); 2745 } 2746 if self.value.auto_token.is_some() { 2747 formatter.field("auto_token", &Present); 2748 } 2749 if let Some(val) = &self.value.restriction { 2750 #[derive(RefCast)] 2751 #[repr(transparent)] 2752 struct Print(syn::ImplRestriction); 2753 impl Debug for Print { 2754 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2755 formatter.write_str("Some(")?; 2756 Debug::fmt(Lite(&self.0), formatter)?; 2757 formatter.write_str(")")?; 2758 Ok(()) 2759 } 2760 } 2761 formatter.field("restriction", Print::ref_cast(val)); 2762 } 2763 formatter.field("ident", Lite(&self.value.ident)); 2764 formatter.field("generics", Lite(&self.value.generics)); 2765 if self.value.colon_token.is_some() { 2766 formatter.field("colon_token", &Present); 2767 } 2768 if !self.value.supertraits.is_empty() { 2769 formatter.field("supertraits", Lite(&self.value.supertraits)); 2770 } 2771 if !self.value.items.is_empty() { 2772 formatter.field("items", Lite(&self.value.items)); 2773 } 2774 formatter.finish() 2775 } 2776} 2777impl Debug for Lite<syn::ItemTraitAlias> { 2778 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2779 let mut formatter = formatter.debug_struct("ItemTraitAlias"); 2780 if !self.value.attrs.is_empty() { 2781 formatter.field("attrs", Lite(&self.value.attrs)); 2782 } 2783 formatter.field("vis", Lite(&self.value.vis)); 2784 formatter.field("ident", Lite(&self.value.ident)); 2785 formatter.field("generics", Lite(&self.value.generics)); 2786 if !self.value.bounds.is_empty() { 2787 formatter.field("bounds", Lite(&self.value.bounds)); 2788 } 2789 formatter.finish() 2790 } 2791} 2792impl Debug for Lite<syn::ItemType> { 2793 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2794 let mut formatter = formatter.debug_struct("ItemType"); 2795 if !self.value.attrs.is_empty() { 2796 formatter.field("attrs", Lite(&self.value.attrs)); 2797 } 2798 formatter.field("vis", Lite(&self.value.vis)); 2799 formatter.field("ident", Lite(&self.value.ident)); 2800 formatter.field("generics", Lite(&self.value.generics)); 2801 formatter.field("ty", Lite(&self.value.ty)); 2802 formatter.finish() 2803 } 2804} 2805impl Debug for Lite<syn::ItemUnion> { 2806 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2807 let mut formatter = formatter.debug_struct("ItemUnion"); 2808 if !self.value.attrs.is_empty() { 2809 formatter.field("attrs", Lite(&self.value.attrs)); 2810 } 2811 formatter.field("vis", Lite(&self.value.vis)); 2812 formatter.field("ident", Lite(&self.value.ident)); 2813 formatter.field("generics", Lite(&self.value.generics)); 2814 formatter.field("fields", Lite(&self.value.fields)); 2815 formatter.finish() 2816 } 2817} 2818impl Debug for Lite<syn::ItemUse> { 2819 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2820 let mut formatter = formatter.debug_struct("ItemUse"); 2821 if !self.value.attrs.is_empty() { 2822 formatter.field("attrs", Lite(&self.value.attrs)); 2823 } 2824 formatter.field("vis", Lite(&self.value.vis)); 2825 if self.value.leading_colon.is_some() { 2826 formatter.field("leading_colon", &Present); 2827 } 2828 formatter.field("tree", Lite(&self.value.tree)); 2829 formatter.finish() 2830 } 2831} 2832impl Debug for Lite<syn::Label> { 2833 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2834 let mut formatter = formatter.debug_struct("Label"); 2835 formatter.field("name", Lite(&self.value.name)); 2836 formatter.finish() 2837 } 2838} 2839impl Debug for Lite<syn::Lifetime> { 2840 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2841 let mut formatter = formatter.debug_struct("Lifetime"); 2842 formatter.field("ident", Lite(&self.value.ident)); 2843 formatter.finish() 2844 } 2845} 2846impl Debug for Lite<syn::LifetimeParam> { 2847 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2848 let mut formatter = formatter.debug_struct("LifetimeParam"); 2849 if !self.value.attrs.is_empty() { 2850 formatter.field("attrs", Lite(&self.value.attrs)); 2851 } 2852 formatter.field("lifetime", Lite(&self.value.lifetime)); 2853 if self.value.colon_token.is_some() { 2854 formatter.field("colon_token", &Present); 2855 } 2856 if !self.value.bounds.is_empty() { 2857 formatter.field("bounds", Lite(&self.value.bounds)); 2858 } 2859 formatter.finish() 2860 } 2861} 2862impl Debug for Lite<syn::Lit> { 2863 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2864 match &self.value { 2865 syn::Lit::Str(_val) => write!(formatter, "{:?}", _val.value()), 2866 syn::Lit::ByteStr(_val) => write!(formatter, "{:?}", _val.value()), 2867 syn::Lit::Byte(_val) => write!(formatter, "{:?}", _val.value()), 2868 syn::Lit::Char(_val) => write!(formatter, "{:?}", _val.value()), 2869 syn::Lit::Int(_val) => write!(formatter, "{}", _val), 2870 syn::Lit::Float(_val) => write!(formatter, "{}", _val), 2871 syn::Lit::Bool(_val) => { 2872 let mut formatter = formatter.debug_struct("Lit::Bool"); 2873 formatter.field("value", Lite(&_val.value)); 2874 formatter.finish() 2875 } 2876 syn::Lit::Verbatim(_val) => { 2877 formatter.write_str("Lit::Verbatim")?; 2878 formatter.write_str("(`")?; 2879 Display::fmt(_val, formatter)?; 2880 formatter.write_str("`)")?; 2881 Ok(()) 2882 } 2883 _ => unreachable!(), 2884 } 2885 } 2886} 2887impl Debug for Lite<syn::LitBool> { 2888 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2889 let mut formatter = formatter.debug_struct("LitBool"); 2890 formatter.field("value", Lite(&self.value.value)); 2891 formatter.finish() 2892 } 2893} 2894impl Debug for Lite<syn::LitByte> { 2895 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2896 write!(formatter, "{:?}", self.value.value()) 2897 } 2898} 2899impl Debug for Lite<syn::LitByteStr> { 2900 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2901 write!(formatter, "{:?}", self.value.value()) 2902 } 2903} 2904impl Debug for Lite<syn::LitChar> { 2905 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2906 write!(formatter, "{:?}", self.value.value()) 2907 } 2908} 2909impl Debug for Lite<syn::LitFloat> { 2910 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2911 write!(formatter, "{}", & self.value) 2912 } 2913} 2914impl Debug for Lite<syn::LitInt> { 2915 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2916 write!(formatter, "{}", & self.value) 2917 } 2918} 2919impl Debug for Lite<syn::LitStr> { 2920 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2921 write!(formatter, "{:?}", self.value.value()) 2922 } 2923} 2924impl Debug for Lite<syn::Local> { 2925 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2926 let mut formatter = formatter.debug_struct("Local"); 2927 if !self.value.attrs.is_empty() { 2928 formatter.field("attrs", Lite(&self.value.attrs)); 2929 } 2930 formatter.field("pat", Lite(&self.value.pat)); 2931 if let Some(val) = &self.value.init { 2932 #[derive(RefCast)] 2933 #[repr(transparent)] 2934 struct Print(syn::LocalInit); 2935 impl Debug for Print { 2936 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2937 formatter.write_str("Some(")?; 2938 Debug::fmt(Lite(&self.0), formatter)?; 2939 formatter.write_str(")")?; 2940 Ok(()) 2941 } 2942 } 2943 formatter.field("init", Print::ref_cast(val)); 2944 } 2945 formatter.finish() 2946 } 2947} 2948impl Debug for Lite<syn::LocalInit> { 2949 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2950 let mut formatter = formatter.debug_struct("LocalInit"); 2951 formatter.field("expr", Lite(&self.value.expr)); 2952 if let Some(val) = &self.value.diverge { 2953 #[derive(RefCast)] 2954 #[repr(transparent)] 2955 struct Print((syn::token::Else, Box<syn::Expr>)); 2956 impl Debug for Print { 2957 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2958 formatter.write_str("Some(")?; 2959 Debug::fmt(Lite(&self.0.1), formatter)?; 2960 formatter.write_str(")")?; 2961 Ok(()) 2962 } 2963 } 2964 formatter.field("diverge", Print::ref_cast(val)); 2965 } 2966 formatter.finish() 2967 } 2968} 2969impl Debug for Lite<syn::Macro> { 2970 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2971 let mut formatter = formatter.debug_struct("Macro"); 2972 formatter.field("path", Lite(&self.value.path)); 2973 formatter.field("delimiter", Lite(&self.value.delimiter)); 2974 formatter.field("tokens", Lite(&self.value.tokens)); 2975 formatter.finish() 2976 } 2977} 2978impl Debug for Lite<syn::MacroDelimiter> { 2979 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2980 match &self.value { 2981 syn::MacroDelimiter::Paren(_val) => { 2982 formatter.write_str("MacroDelimiter::Paren")?; 2983 Ok(()) 2984 } 2985 syn::MacroDelimiter::Brace(_val) => { 2986 formatter.write_str("MacroDelimiter::Brace")?; 2987 Ok(()) 2988 } 2989 syn::MacroDelimiter::Bracket(_val) => { 2990 formatter.write_str("MacroDelimiter::Bracket")?; 2991 Ok(()) 2992 } 2993 } 2994 } 2995} 2996impl Debug for Lite<syn::Member> { 2997 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2998 match &self.value { 2999 syn::Member::Named(_val) => { 3000 formatter.write_str("Member::Named")?; 3001 formatter.write_str("(")?; 3002 Debug::fmt(Lite(_val), formatter)?; 3003 formatter.write_str(")")?; 3004 Ok(()) 3005 } 3006 syn::Member::Unnamed(_val) => { 3007 formatter.write_str("Member::Unnamed")?; 3008 formatter.write_str("(")?; 3009 Debug::fmt(Lite(_val), formatter)?; 3010 formatter.write_str(")")?; 3011 Ok(()) 3012 } 3013 } 3014 } 3015} 3016impl Debug for Lite<syn::Meta> { 3017 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3018 match &self.value { 3019 syn::Meta::Path(_val) => { 3020 let mut formatter = formatter.debug_struct("Meta::Path"); 3021 if _val.leading_colon.is_some() { 3022 formatter.field("leading_colon", &Present); 3023 } 3024 if !_val.segments.is_empty() { 3025 formatter.field("segments", Lite(&_val.segments)); 3026 } 3027 formatter.finish() 3028 } 3029 syn::Meta::List(_val) => { 3030 let mut formatter = formatter.debug_struct("Meta::List"); 3031 formatter.field("path", Lite(&_val.path)); 3032 formatter.field("delimiter", Lite(&_val.delimiter)); 3033 formatter.field("tokens", Lite(&_val.tokens)); 3034 formatter.finish() 3035 } 3036 syn::Meta::NameValue(_val) => { 3037 let mut formatter = formatter.debug_struct("Meta::NameValue"); 3038 formatter.field("path", Lite(&_val.path)); 3039 formatter.field("value", Lite(&_val.value)); 3040 formatter.finish() 3041 } 3042 } 3043 } 3044} 3045impl Debug for Lite<syn::MetaList> { 3046 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3047 let mut formatter = formatter.debug_struct("MetaList"); 3048 formatter.field("path", Lite(&self.value.path)); 3049 formatter.field("delimiter", Lite(&self.value.delimiter)); 3050 formatter.field("tokens", Lite(&self.value.tokens)); 3051 formatter.finish() 3052 } 3053} 3054impl Debug for Lite<syn::MetaNameValue> { 3055 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3056 let mut formatter = formatter.debug_struct("MetaNameValue"); 3057 formatter.field("path", Lite(&self.value.path)); 3058 formatter.field("value", Lite(&self.value.value)); 3059 formatter.finish() 3060 } 3061} 3062impl Debug for Lite<syn::ParenthesizedGenericArguments> { 3063 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3064 let mut formatter = formatter.debug_struct("ParenthesizedGenericArguments"); 3065 if !self.value.inputs.is_empty() { 3066 formatter.field("inputs", Lite(&self.value.inputs)); 3067 } 3068 formatter.field("output", Lite(&self.value.output)); 3069 formatter.finish() 3070 } 3071} 3072impl Debug for Lite<syn::Pat> { 3073 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3074 match &self.value { 3075 syn::Pat::Const(_val) => { 3076 formatter.write_str("Pat::Const")?; 3077 formatter.write_str("(")?; 3078 Debug::fmt(Lite(_val), formatter)?; 3079 formatter.write_str(")")?; 3080 Ok(()) 3081 } 3082 syn::Pat::Ident(_val) => { 3083 let mut formatter = formatter.debug_struct("Pat::Ident"); 3084 if !_val.attrs.is_empty() { 3085 formatter.field("attrs", Lite(&_val.attrs)); 3086 } 3087 if _val.by_ref.is_some() { 3088 formatter.field("by_ref", &Present); 3089 } 3090 if _val.mutability.is_some() { 3091 formatter.field("mutability", &Present); 3092 } 3093 formatter.field("ident", Lite(&_val.ident)); 3094 if let Some(val) = &_val.subpat { 3095 #[derive(RefCast)] 3096 #[repr(transparent)] 3097 struct Print((syn::token::At, Box<syn::Pat>)); 3098 impl Debug for Print { 3099 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3100 formatter.write_str("Some(")?; 3101 Debug::fmt(Lite(&self.0.1), formatter)?; 3102 formatter.write_str(")")?; 3103 Ok(()) 3104 } 3105 } 3106 formatter.field("subpat", Print::ref_cast(val)); 3107 } 3108 formatter.finish() 3109 } 3110 syn::Pat::Lit(_val) => { 3111 formatter.write_str("Pat::Lit")?; 3112 formatter.write_str("(")?; 3113 Debug::fmt(Lite(_val), formatter)?; 3114 formatter.write_str(")")?; 3115 Ok(()) 3116 } 3117 syn::Pat::Macro(_val) => { 3118 formatter.write_str("Pat::Macro")?; 3119 formatter.write_str("(")?; 3120 Debug::fmt(Lite(_val), formatter)?; 3121 formatter.write_str(")")?; 3122 Ok(()) 3123 } 3124 syn::Pat::Or(_val) => { 3125 let mut formatter = formatter.debug_struct("Pat::Or"); 3126 if !_val.attrs.is_empty() { 3127 formatter.field("attrs", Lite(&_val.attrs)); 3128 } 3129 if _val.leading_vert.is_some() { 3130 formatter.field("leading_vert", &Present); 3131 } 3132 if !_val.cases.is_empty() { 3133 formatter.field("cases", Lite(&_val.cases)); 3134 } 3135 formatter.finish() 3136 } 3137 syn::Pat::Paren(_val) => { 3138 let mut formatter = formatter.debug_struct("Pat::Paren"); 3139 if !_val.attrs.is_empty() { 3140 formatter.field("attrs", Lite(&_val.attrs)); 3141 } 3142 formatter.field("pat", Lite(&_val.pat)); 3143 formatter.finish() 3144 } 3145 syn::Pat::Path(_val) => { 3146 formatter.write_str("Pat::Path")?; 3147 formatter.write_str("(")?; 3148 Debug::fmt(Lite(_val), formatter)?; 3149 formatter.write_str(")")?; 3150 Ok(()) 3151 } 3152 syn::Pat::Range(_val) => { 3153 formatter.write_str("Pat::Range")?; 3154 formatter.write_str("(")?; 3155 Debug::fmt(Lite(_val), formatter)?; 3156 formatter.write_str(")")?; 3157 Ok(()) 3158 } 3159 syn::Pat::Reference(_val) => { 3160 let mut formatter = formatter.debug_struct("Pat::Reference"); 3161 if !_val.attrs.is_empty() { 3162 formatter.field("attrs", Lite(&_val.attrs)); 3163 } 3164 if _val.mutability.is_some() { 3165 formatter.field("mutability", &Present); 3166 } 3167 formatter.field("pat", Lite(&_val.pat)); 3168 formatter.finish() 3169 } 3170 syn::Pat::Rest(_val) => { 3171 let mut formatter = formatter.debug_struct("Pat::Rest"); 3172 if !_val.attrs.is_empty() { 3173 formatter.field("attrs", Lite(&_val.attrs)); 3174 } 3175 formatter.finish() 3176 } 3177 syn::Pat::Slice(_val) => { 3178 let mut formatter = formatter.debug_struct("Pat::Slice"); 3179 if !_val.attrs.is_empty() { 3180 formatter.field("attrs", Lite(&_val.attrs)); 3181 } 3182 if !_val.elems.is_empty() { 3183 formatter.field("elems", Lite(&_val.elems)); 3184 } 3185 formatter.finish() 3186 } 3187 syn::Pat::Struct(_val) => { 3188 let mut formatter = formatter.debug_struct("Pat::Struct"); 3189 if !_val.attrs.is_empty() { 3190 formatter.field("attrs", Lite(&_val.attrs)); 3191 } 3192 if let Some(val) = &_val.qself { 3193 #[derive(RefCast)] 3194 #[repr(transparent)] 3195 struct Print(syn::QSelf); 3196 impl Debug for Print { 3197 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3198 formatter.write_str("Some(")?; 3199 Debug::fmt(Lite(&self.0), formatter)?; 3200 formatter.write_str(")")?; 3201 Ok(()) 3202 } 3203 } 3204 formatter.field("qself", Print::ref_cast(val)); 3205 } 3206 formatter.field("path", Lite(&_val.path)); 3207 if !_val.fields.is_empty() { 3208 formatter.field("fields", Lite(&_val.fields)); 3209 } 3210 if let Some(val) = &_val.rest { 3211 #[derive(RefCast)] 3212 #[repr(transparent)] 3213 struct Print(syn::PatRest); 3214 impl Debug for Print { 3215 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3216 formatter.write_str("Some(")?; 3217 Debug::fmt(Lite(&self.0), formatter)?; 3218 formatter.write_str(")")?; 3219 Ok(()) 3220 } 3221 } 3222 formatter.field("rest", Print::ref_cast(val)); 3223 } 3224 formatter.finish() 3225 } 3226 syn::Pat::Tuple(_val) => { 3227 let mut formatter = formatter.debug_struct("Pat::Tuple"); 3228 if !_val.attrs.is_empty() { 3229 formatter.field("attrs", Lite(&_val.attrs)); 3230 } 3231 if !_val.elems.is_empty() { 3232 formatter.field("elems", Lite(&_val.elems)); 3233 } 3234 formatter.finish() 3235 } 3236 syn::Pat::TupleStruct(_val) => { 3237 let mut formatter = formatter.debug_struct("Pat::TupleStruct"); 3238 if !_val.attrs.is_empty() { 3239 formatter.field("attrs", Lite(&_val.attrs)); 3240 } 3241 if let Some(val) = &_val.qself { 3242 #[derive(RefCast)] 3243 #[repr(transparent)] 3244 struct Print(syn::QSelf); 3245 impl Debug for Print { 3246 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3247 formatter.write_str("Some(")?; 3248 Debug::fmt(Lite(&self.0), formatter)?; 3249 formatter.write_str(")")?; 3250 Ok(()) 3251 } 3252 } 3253 formatter.field("qself", Print::ref_cast(val)); 3254 } 3255 formatter.field("path", Lite(&_val.path)); 3256 if !_val.elems.is_empty() { 3257 formatter.field("elems", Lite(&_val.elems)); 3258 } 3259 formatter.finish() 3260 } 3261 syn::Pat::Type(_val) => { 3262 let mut formatter = formatter.debug_struct("Pat::Type"); 3263 if !_val.attrs.is_empty() { 3264 formatter.field("attrs", Lite(&_val.attrs)); 3265 } 3266 formatter.field("pat", Lite(&_val.pat)); 3267 formatter.field("ty", Lite(&_val.ty)); 3268 formatter.finish() 3269 } 3270 syn::Pat::Verbatim(_val) => { 3271 formatter.write_str("Pat::Verbatim")?; 3272 formatter.write_str("(`")?; 3273 Display::fmt(_val, formatter)?; 3274 formatter.write_str("`)")?; 3275 Ok(()) 3276 } 3277 syn::Pat::Wild(_val) => { 3278 let mut formatter = formatter.debug_struct("Pat::Wild"); 3279 if !_val.attrs.is_empty() { 3280 formatter.field("attrs", Lite(&_val.attrs)); 3281 } 3282 formatter.finish() 3283 } 3284 _ => unreachable!(), 3285 } 3286 } 3287} 3288impl Debug for Lite<syn::PatIdent> { 3289 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3290 let mut formatter = formatter.debug_struct("PatIdent"); 3291 if !self.value.attrs.is_empty() { 3292 formatter.field("attrs", Lite(&self.value.attrs)); 3293 } 3294 if self.value.by_ref.is_some() { 3295 formatter.field("by_ref", &Present); 3296 } 3297 if self.value.mutability.is_some() { 3298 formatter.field("mutability", &Present); 3299 } 3300 formatter.field("ident", Lite(&self.value.ident)); 3301 if let Some(val) = &self.value.subpat { 3302 #[derive(RefCast)] 3303 #[repr(transparent)] 3304 struct Print((syn::token::At, Box<syn::Pat>)); 3305 impl Debug for Print { 3306 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3307 formatter.write_str("Some(")?; 3308 Debug::fmt(Lite(&self.0.1), formatter)?; 3309 formatter.write_str(")")?; 3310 Ok(()) 3311 } 3312 } 3313 formatter.field("subpat", Print::ref_cast(val)); 3314 } 3315 formatter.finish() 3316 } 3317} 3318impl Debug for Lite<syn::PatOr> { 3319 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3320 let mut formatter = formatter.debug_struct("PatOr"); 3321 if !self.value.attrs.is_empty() { 3322 formatter.field("attrs", Lite(&self.value.attrs)); 3323 } 3324 if self.value.leading_vert.is_some() { 3325 formatter.field("leading_vert", &Present); 3326 } 3327 if !self.value.cases.is_empty() { 3328 formatter.field("cases", Lite(&self.value.cases)); 3329 } 3330 formatter.finish() 3331 } 3332} 3333impl Debug for Lite<syn::PatParen> { 3334 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3335 let mut formatter = formatter.debug_struct("PatParen"); 3336 if !self.value.attrs.is_empty() { 3337 formatter.field("attrs", Lite(&self.value.attrs)); 3338 } 3339 formatter.field("pat", Lite(&self.value.pat)); 3340 formatter.finish() 3341 } 3342} 3343impl Debug for Lite<syn::PatReference> { 3344 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3345 let mut formatter = formatter.debug_struct("PatReference"); 3346 if !self.value.attrs.is_empty() { 3347 formatter.field("attrs", Lite(&self.value.attrs)); 3348 } 3349 if self.value.mutability.is_some() { 3350 formatter.field("mutability", &Present); 3351 } 3352 formatter.field("pat", Lite(&self.value.pat)); 3353 formatter.finish() 3354 } 3355} 3356impl Debug for Lite<syn::PatRest> { 3357 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3358 let mut formatter = formatter.debug_struct("PatRest"); 3359 if !self.value.attrs.is_empty() { 3360 formatter.field("attrs", Lite(&self.value.attrs)); 3361 } 3362 formatter.finish() 3363 } 3364} 3365impl Debug for Lite<syn::PatSlice> { 3366 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3367 let mut formatter = formatter.debug_struct("PatSlice"); 3368 if !self.value.attrs.is_empty() { 3369 formatter.field("attrs", Lite(&self.value.attrs)); 3370 } 3371 if !self.value.elems.is_empty() { 3372 formatter.field("elems", Lite(&self.value.elems)); 3373 } 3374 formatter.finish() 3375 } 3376} 3377impl Debug for Lite<syn::PatStruct> { 3378 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3379 let mut formatter = formatter.debug_struct("PatStruct"); 3380 if !self.value.attrs.is_empty() { 3381 formatter.field("attrs", Lite(&self.value.attrs)); 3382 } 3383 if let Some(val) = &self.value.qself { 3384 #[derive(RefCast)] 3385 #[repr(transparent)] 3386 struct Print(syn::QSelf); 3387 impl Debug for Print { 3388 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3389 formatter.write_str("Some(")?; 3390 Debug::fmt(Lite(&self.0), formatter)?; 3391 formatter.write_str(")")?; 3392 Ok(()) 3393 } 3394 } 3395 formatter.field("qself", Print::ref_cast(val)); 3396 } 3397 formatter.field("path", Lite(&self.value.path)); 3398 if !self.value.fields.is_empty() { 3399 formatter.field("fields", Lite(&self.value.fields)); 3400 } 3401 if let Some(val) = &self.value.rest { 3402 #[derive(RefCast)] 3403 #[repr(transparent)] 3404 struct Print(syn::PatRest); 3405 impl Debug for Print { 3406 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3407 formatter.write_str("Some(")?; 3408 Debug::fmt(Lite(&self.0), formatter)?; 3409 formatter.write_str(")")?; 3410 Ok(()) 3411 } 3412 } 3413 formatter.field("rest", Print::ref_cast(val)); 3414 } 3415 formatter.finish() 3416 } 3417} 3418impl Debug for Lite<syn::PatTuple> { 3419 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3420 let mut formatter = formatter.debug_struct("PatTuple"); 3421 if !self.value.attrs.is_empty() { 3422 formatter.field("attrs", Lite(&self.value.attrs)); 3423 } 3424 if !self.value.elems.is_empty() { 3425 formatter.field("elems", Lite(&self.value.elems)); 3426 } 3427 formatter.finish() 3428 } 3429} 3430impl Debug for Lite<syn::PatTupleStruct> { 3431 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3432 let mut formatter = formatter.debug_struct("PatTupleStruct"); 3433 if !self.value.attrs.is_empty() { 3434 formatter.field("attrs", Lite(&self.value.attrs)); 3435 } 3436 if let Some(val) = &self.value.qself { 3437 #[derive(RefCast)] 3438 #[repr(transparent)] 3439 struct Print(syn::QSelf); 3440 impl Debug for Print { 3441 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3442 formatter.write_str("Some(")?; 3443 Debug::fmt(Lite(&self.0), formatter)?; 3444 formatter.write_str(")")?; 3445 Ok(()) 3446 } 3447 } 3448 formatter.field("qself", Print::ref_cast(val)); 3449 } 3450 formatter.field("path", Lite(&self.value.path)); 3451 if !self.value.elems.is_empty() { 3452 formatter.field("elems", Lite(&self.value.elems)); 3453 } 3454 formatter.finish() 3455 } 3456} 3457impl Debug for Lite<syn::PatType> { 3458 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3459 let mut formatter = formatter.debug_struct("PatType"); 3460 if !self.value.attrs.is_empty() { 3461 formatter.field("attrs", Lite(&self.value.attrs)); 3462 } 3463 formatter.field("pat", Lite(&self.value.pat)); 3464 formatter.field("ty", Lite(&self.value.ty)); 3465 formatter.finish() 3466 } 3467} 3468impl Debug for Lite<syn::PatWild> { 3469 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3470 let mut formatter = formatter.debug_struct("PatWild"); 3471 if !self.value.attrs.is_empty() { 3472 formatter.field("attrs", Lite(&self.value.attrs)); 3473 } 3474 formatter.finish() 3475 } 3476} 3477impl Debug for Lite<syn::Path> { 3478 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3479 let mut formatter = formatter.debug_struct("Path"); 3480 if self.value.leading_colon.is_some() { 3481 formatter.field("leading_colon", &Present); 3482 } 3483 if !self.value.segments.is_empty() { 3484 formatter.field("segments", Lite(&self.value.segments)); 3485 } 3486 formatter.finish() 3487 } 3488} 3489impl Debug for Lite<syn::PathArguments> { 3490 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3491 match &self.value { 3492 syn::PathArguments::None => formatter.write_str("PathArguments::None"), 3493 syn::PathArguments::AngleBracketed(_val) => { 3494 let mut formatter = formatter 3495 .debug_struct("PathArguments::AngleBracketed"); 3496 if _val.colon2_token.is_some() { 3497 formatter.field("colon2_token", &Present); 3498 } 3499 if !_val.args.is_empty() { 3500 formatter.field("args", Lite(&_val.args)); 3501 } 3502 formatter.finish() 3503 } 3504 syn::PathArguments::Parenthesized(_val) => { 3505 let mut formatter = formatter 3506 .debug_struct("PathArguments::Parenthesized"); 3507 if !_val.inputs.is_empty() { 3508 formatter.field("inputs", Lite(&_val.inputs)); 3509 } 3510 formatter.field("output", Lite(&_val.output)); 3511 formatter.finish() 3512 } 3513 } 3514 } 3515} 3516impl Debug for Lite<syn::PathSegment> { 3517 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3518 let mut formatter = formatter.debug_struct("PathSegment"); 3519 formatter.field("ident", Lite(&self.value.ident)); 3520 match self.value.arguments { 3521 syn::PathArguments::None => {} 3522 _ => { 3523 formatter.field("arguments", Lite(&self.value.arguments)); 3524 } 3525 } 3526 formatter.finish() 3527 } 3528} 3529impl Debug for Lite<syn::PredicateLifetime> { 3530 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3531 let mut formatter = formatter.debug_struct("PredicateLifetime"); 3532 formatter.field("lifetime", Lite(&self.value.lifetime)); 3533 if !self.value.bounds.is_empty() { 3534 formatter.field("bounds", Lite(&self.value.bounds)); 3535 } 3536 formatter.finish() 3537 } 3538} 3539impl Debug for Lite<syn::PredicateType> { 3540 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3541 let mut formatter = formatter.debug_struct("PredicateType"); 3542 if let Some(val) = &self.value.lifetimes { 3543 #[derive(RefCast)] 3544 #[repr(transparent)] 3545 struct Print(syn::BoundLifetimes); 3546 impl Debug for Print { 3547 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3548 formatter.write_str("Some(")?; 3549 Debug::fmt(Lite(&self.0), formatter)?; 3550 formatter.write_str(")")?; 3551 Ok(()) 3552 } 3553 } 3554 formatter.field("lifetimes", Print::ref_cast(val)); 3555 } 3556 formatter.field("bounded_ty", Lite(&self.value.bounded_ty)); 3557 if !self.value.bounds.is_empty() { 3558 formatter.field("bounds", Lite(&self.value.bounds)); 3559 } 3560 formatter.finish() 3561 } 3562} 3563impl Debug for Lite<syn::QSelf> { 3564 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3565 let mut formatter = formatter.debug_struct("QSelf"); 3566 formatter.field("ty", Lite(&self.value.ty)); 3567 formatter.field("position", Lite(&self.value.position)); 3568 if self.value.as_token.is_some() { 3569 formatter.field("as_token", &Present); 3570 } 3571 formatter.finish() 3572 } 3573} 3574impl Debug for Lite<syn::RangeLimits> { 3575 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3576 match &self.value { 3577 syn::RangeLimits::HalfOpen(_val) => { 3578 formatter.write_str("RangeLimits::HalfOpen")?; 3579 Ok(()) 3580 } 3581 syn::RangeLimits::Closed(_val) => { 3582 formatter.write_str("RangeLimits::Closed")?; 3583 Ok(()) 3584 } 3585 } 3586 } 3587} 3588impl Debug for Lite<syn::Receiver> { 3589 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3590 let mut formatter = formatter.debug_struct("Receiver"); 3591 if !self.value.attrs.is_empty() { 3592 formatter.field("attrs", Lite(&self.value.attrs)); 3593 } 3594 if let Some(val) = &self.value.reference { 3595 #[derive(RefCast)] 3596 #[repr(transparent)] 3597 struct Print((syn::token::And, Option<syn::Lifetime>)); 3598 impl Debug for Print { 3599 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3600 formatter.write_str("Some(")?; 3601 Debug::fmt( 3602 { 3603 #[derive(RefCast)] 3604 #[repr(transparent)] 3605 struct Print(Option<syn::Lifetime>); 3606 impl Debug for Print { 3607 fn fmt( 3608 &self, 3609 formatter: &mut fmt::Formatter, 3610 ) -> fmt::Result { 3611 match &self.0 { 3612 Some(_val) => { 3613 formatter.write_str("Some(")?; 3614 Debug::fmt(Lite(_val), formatter)?; 3615 formatter.write_str(")")?; 3616 Ok(()) 3617 } 3618 None => formatter.write_str("None"), 3619 } 3620 } 3621 } 3622 Print::ref_cast(&self.0.1) 3623 }, 3624 formatter, 3625 )?; 3626 formatter.write_str(")")?; 3627 Ok(()) 3628 } 3629 } 3630 formatter.field("reference", Print::ref_cast(val)); 3631 } 3632 if self.value.mutability.is_some() { 3633 formatter.field("mutability", &Present); 3634 } 3635 if self.value.colon_token.is_some() { 3636 formatter.field("colon_token", &Present); 3637 } 3638 formatter.field("ty", Lite(&self.value.ty)); 3639 formatter.finish() 3640 } 3641} 3642impl Debug for Lite<syn::ReturnType> { 3643 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3644 match &self.value { 3645 syn::ReturnType::Default => formatter.write_str("ReturnType::Default"), 3646 syn::ReturnType::Type(_v0, _v1) => { 3647 let mut formatter = formatter.debug_tuple("ReturnType::Type"); 3648 formatter.field(Lite(_v1)); 3649 formatter.finish() 3650 } 3651 } 3652 } 3653} 3654impl Debug for Lite<syn::Signature> { 3655 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3656 let mut formatter = formatter.debug_struct("Signature"); 3657 if self.value.constness.is_some() { 3658 formatter.field("constness", &Present); 3659 } 3660 if self.value.asyncness.is_some() { 3661 formatter.field("asyncness", &Present); 3662 } 3663 if self.value.unsafety.is_some() { 3664 formatter.field("unsafety", &Present); 3665 } 3666 if let Some(val) = &self.value.abi { 3667 #[derive(RefCast)] 3668 #[repr(transparent)] 3669 struct Print(syn::Abi); 3670 impl Debug for Print { 3671 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3672 formatter.write_str("Some(")?; 3673 Debug::fmt(Lite(&self.0), formatter)?; 3674 formatter.write_str(")")?; 3675 Ok(()) 3676 } 3677 } 3678 formatter.field("abi", Print::ref_cast(val)); 3679 } 3680 formatter.field("ident", Lite(&self.value.ident)); 3681 formatter.field("generics", Lite(&self.value.generics)); 3682 if !self.value.inputs.is_empty() { 3683 formatter.field("inputs", Lite(&self.value.inputs)); 3684 } 3685 if let Some(val) = &self.value.variadic { 3686 #[derive(RefCast)] 3687 #[repr(transparent)] 3688 struct Print(syn::Variadic); 3689 impl Debug for Print { 3690 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3691 formatter.write_str("Some(")?; 3692 Debug::fmt(Lite(&self.0), formatter)?; 3693 formatter.write_str(")")?; 3694 Ok(()) 3695 } 3696 } 3697 formatter.field("variadic", Print::ref_cast(val)); 3698 } 3699 formatter.field("output", Lite(&self.value.output)); 3700 formatter.finish() 3701 } 3702} 3703impl Debug for Lite<syn::StaticMutability> { 3704 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3705 match &self.value { 3706 syn::StaticMutability::Mut(_val) => { 3707 formatter.write_str("StaticMutability::Mut")?; 3708 Ok(()) 3709 } 3710 syn::StaticMutability::None => formatter.write_str("StaticMutability::None"), 3711 _ => unreachable!(), 3712 } 3713 } 3714} 3715impl Debug for Lite<syn::Stmt> { 3716 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3717 match &self.value { 3718 syn::Stmt::Local(_val) => { 3719 let mut formatter = formatter.debug_struct("Stmt::Local"); 3720 if !_val.attrs.is_empty() { 3721 formatter.field("attrs", Lite(&_val.attrs)); 3722 } 3723 formatter.field("pat", Lite(&_val.pat)); 3724 if let Some(val) = &_val.init { 3725 #[derive(RefCast)] 3726 #[repr(transparent)] 3727 struct Print(syn::LocalInit); 3728 impl Debug for Print { 3729 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3730 formatter.write_str("Some(")?; 3731 Debug::fmt(Lite(&self.0), formatter)?; 3732 formatter.write_str(")")?; 3733 Ok(()) 3734 } 3735 } 3736 formatter.field("init", Print::ref_cast(val)); 3737 } 3738 formatter.finish() 3739 } 3740 syn::Stmt::Item(_val) => { 3741 formatter.write_str("Stmt::Item")?; 3742 formatter.write_str("(")?; 3743 Debug::fmt(Lite(_val), formatter)?; 3744 formatter.write_str(")")?; 3745 Ok(()) 3746 } 3747 syn::Stmt::Expr(_v0, _v1) => { 3748 let mut formatter = formatter.debug_tuple("Stmt::Expr"); 3749 formatter.field(Lite(_v0)); 3750 formatter 3751 .field( 3752 &super::Option { 3753 present: _v1.is_some(), 3754 }, 3755 ); 3756 formatter.finish() 3757 } 3758 syn::Stmt::Macro(_val) => { 3759 let mut formatter = formatter.debug_struct("Stmt::Macro"); 3760 if !_val.attrs.is_empty() { 3761 formatter.field("attrs", Lite(&_val.attrs)); 3762 } 3763 formatter.field("mac", Lite(&_val.mac)); 3764 if _val.semi_token.is_some() { 3765 formatter.field("semi_token", &Present); 3766 } 3767 formatter.finish() 3768 } 3769 } 3770 } 3771} 3772impl Debug for Lite<syn::StmtMacro> { 3773 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3774 let mut formatter = formatter.debug_struct("StmtMacro"); 3775 if !self.value.attrs.is_empty() { 3776 formatter.field("attrs", Lite(&self.value.attrs)); 3777 } 3778 formatter.field("mac", Lite(&self.value.mac)); 3779 if self.value.semi_token.is_some() { 3780 formatter.field("semi_token", &Present); 3781 } 3782 formatter.finish() 3783 } 3784} 3785impl Debug for Lite<syn::TraitBound> { 3786 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3787 let mut formatter = formatter.debug_struct("TraitBound"); 3788 if self.value.paren_token.is_some() { 3789 formatter.field("paren_token", &Present); 3790 } 3791 match self.value.modifier { 3792 syn::TraitBoundModifier::None => {} 3793 _ => { 3794 formatter.field("modifier", Lite(&self.value.modifier)); 3795 } 3796 } 3797 if let Some(val) = &self.value.lifetimes { 3798 #[derive(RefCast)] 3799 #[repr(transparent)] 3800 struct Print(syn::BoundLifetimes); 3801 impl Debug for Print { 3802 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3803 formatter.write_str("Some(")?; 3804 Debug::fmt(Lite(&self.0), formatter)?; 3805 formatter.write_str(")")?; 3806 Ok(()) 3807 } 3808 } 3809 formatter.field("lifetimes", Print::ref_cast(val)); 3810 } 3811 formatter.field("path", Lite(&self.value.path)); 3812 formatter.finish() 3813 } 3814} 3815impl Debug for Lite<syn::TraitBoundModifier> { 3816 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3817 match &self.value { 3818 syn::TraitBoundModifier::None => { 3819 formatter.write_str("TraitBoundModifier::None") 3820 } 3821 syn::TraitBoundModifier::Maybe(_val) => { 3822 formatter.write_str("TraitBoundModifier::Maybe")?; 3823 Ok(()) 3824 } 3825 } 3826 } 3827} 3828impl Debug for Lite<syn::TraitItem> { 3829 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3830 match &self.value { 3831 syn::TraitItem::Const(_val) => { 3832 let mut formatter = formatter.debug_struct("TraitItem::Const"); 3833 if !_val.attrs.is_empty() { 3834 formatter.field("attrs", Lite(&_val.attrs)); 3835 } 3836 formatter.field("ident", Lite(&_val.ident)); 3837 formatter.field("generics", Lite(&_val.generics)); 3838 formatter.field("ty", Lite(&_val.ty)); 3839 if let Some(val) = &_val.default { 3840 #[derive(RefCast)] 3841 #[repr(transparent)] 3842 struct Print((syn::token::Eq, syn::Expr)); 3843 impl Debug for Print { 3844 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3845 formatter.write_str("Some(")?; 3846 Debug::fmt(Lite(&self.0.1), formatter)?; 3847 formatter.write_str(")")?; 3848 Ok(()) 3849 } 3850 } 3851 formatter.field("default", Print::ref_cast(val)); 3852 } 3853 formatter.finish() 3854 } 3855 syn::TraitItem::Fn(_val) => { 3856 let mut formatter = formatter.debug_struct("TraitItem::Fn"); 3857 if !_val.attrs.is_empty() { 3858 formatter.field("attrs", Lite(&_val.attrs)); 3859 } 3860 formatter.field("sig", Lite(&_val.sig)); 3861 if let Some(val) = &_val.default { 3862 #[derive(RefCast)] 3863 #[repr(transparent)] 3864 struct Print(syn::Block); 3865 impl Debug for Print { 3866 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3867 formatter.write_str("Some(")?; 3868 Debug::fmt(Lite(&self.0), formatter)?; 3869 formatter.write_str(")")?; 3870 Ok(()) 3871 } 3872 } 3873 formatter.field("default", Print::ref_cast(val)); 3874 } 3875 if _val.semi_token.is_some() { 3876 formatter.field("semi_token", &Present); 3877 } 3878 formatter.finish() 3879 } 3880 syn::TraitItem::Type(_val) => { 3881 let mut formatter = formatter.debug_struct("TraitItem::Type"); 3882 if !_val.attrs.is_empty() { 3883 formatter.field("attrs", Lite(&_val.attrs)); 3884 } 3885 formatter.field("ident", Lite(&_val.ident)); 3886 formatter.field("generics", Lite(&_val.generics)); 3887 if _val.colon_token.is_some() { 3888 formatter.field("colon_token", &Present); 3889 } 3890 if !_val.bounds.is_empty() { 3891 formatter.field("bounds", Lite(&_val.bounds)); 3892 } 3893 if let Some(val) = &_val.default { 3894 #[derive(RefCast)] 3895 #[repr(transparent)] 3896 struct Print((syn::token::Eq, syn::Type)); 3897 impl Debug for Print { 3898 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3899 formatter.write_str("Some(")?; 3900 Debug::fmt(Lite(&self.0.1), formatter)?; 3901 formatter.write_str(")")?; 3902 Ok(()) 3903 } 3904 } 3905 formatter.field("default", Print::ref_cast(val)); 3906 } 3907 formatter.finish() 3908 } 3909 syn::TraitItem::Macro(_val) => { 3910 let mut formatter = formatter.debug_struct("TraitItem::Macro"); 3911 if !_val.attrs.is_empty() { 3912 formatter.field("attrs", Lite(&_val.attrs)); 3913 } 3914 formatter.field("mac", Lite(&_val.mac)); 3915 if _val.semi_token.is_some() { 3916 formatter.field("semi_token", &Present); 3917 } 3918 formatter.finish() 3919 } 3920 syn::TraitItem::Verbatim(_val) => { 3921 formatter.write_str("TraitItem::Verbatim")?; 3922 formatter.write_str("(`")?; 3923 Display::fmt(_val, formatter)?; 3924 formatter.write_str("`)")?; 3925 Ok(()) 3926 } 3927 _ => unreachable!(), 3928 } 3929 } 3930} 3931impl Debug for Lite<syn::TraitItemConst> { 3932 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3933 let mut formatter = formatter.debug_struct("TraitItemConst"); 3934 if !self.value.attrs.is_empty() { 3935 formatter.field("attrs", Lite(&self.value.attrs)); 3936 } 3937 formatter.field("ident", Lite(&self.value.ident)); 3938 formatter.field("generics", Lite(&self.value.generics)); 3939 formatter.field("ty", Lite(&self.value.ty)); 3940 if let Some(val) = &self.value.default { 3941 #[derive(RefCast)] 3942 #[repr(transparent)] 3943 struct Print((syn::token::Eq, syn::Expr)); 3944 impl Debug for Print { 3945 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3946 formatter.write_str("Some(")?; 3947 Debug::fmt(Lite(&self.0.1), formatter)?; 3948 formatter.write_str(")")?; 3949 Ok(()) 3950 } 3951 } 3952 formatter.field("default", Print::ref_cast(val)); 3953 } 3954 formatter.finish() 3955 } 3956} 3957impl Debug for Lite<syn::TraitItemFn> { 3958 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3959 let mut formatter = formatter.debug_struct("TraitItemFn"); 3960 if !self.value.attrs.is_empty() { 3961 formatter.field("attrs", Lite(&self.value.attrs)); 3962 } 3963 formatter.field("sig", Lite(&self.value.sig)); 3964 if let Some(val) = &self.value.default { 3965 #[derive(RefCast)] 3966 #[repr(transparent)] 3967 struct Print(syn::Block); 3968 impl Debug for Print { 3969 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3970 formatter.write_str("Some(")?; 3971 Debug::fmt(Lite(&self.0), formatter)?; 3972 formatter.write_str(")")?; 3973 Ok(()) 3974 } 3975 } 3976 formatter.field("default", Print::ref_cast(val)); 3977 } 3978 if self.value.semi_token.is_some() { 3979 formatter.field("semi_token", &Present); 3980 } 3981 formatter.finish() 3982 } 3983} 3984impl Debug for Lite<syn::TraitItemMacro> { 3985 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3986 let mut formatter = formatter.debug_struct("TraitItemMacro"); 3987 if !self.value.attrs.is_empty() { 3988 formatter.field("attrs", Lite(&self.value.attrs)); 3989 } 3990 formatter.field("mac", Lite(&self.value.mac)); 3991 if self.value.semi_token.is_some() { 3992 formatter.field("semi_token", &Present); 3993 } 3994 formatter.finish() 3995 } 3996} 3997impl Debug for Lite<syn::TraitItemType> { 3998 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3999 let mut formatter = formatter.debug_struct("TraitItemType"); 4000 if !self.value.attrs.is_empty() { 4001 formatter.field("attrs", Lite(&self.value.attrs)); 4002 } 4003 formatter.field("ident", Lite(&self.value.ident)); 4004 formatter.field("generics", Lite(&self.value.generics)); 4005 if self.value.colon_token.is_some() { 4006 formatter.field("colon_token", &Present); 4007 } 4008 if !self.value.bounds.is_empty() { 4009 formatter.field("bounds", Lite(&self.value.bounds)); 4010 } 4011 if let Some(val) = &self.value.default { 4012 #[derive(RefCast)] 4013 #[repr(transparent)] 4014 struct Print((syn::token::Eq, syn::Type)); 4015 impl Debug for Print { 4016 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4017 formatter.write_str("Some(")?; 4018 Debug::fmt(Lite(&self.0.1), formatter)?; 4019 formatter.write_str(")")?; 4020 Ok(()) 4021 } 4022 } 4023 formatter.field("default", Print::ref_cast(val)); 4024 } 4025 formatter.finish() 4026 } 4027} 4028impl Debug for Lite<syn::Type> { 4029 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4030 match &self.value { 4031 syn::Type::Array(_val) => { 4032 let mut formatter = formatter.debug_struct("Type::Array"); 4033 formatter.field("elem", Lite(&_val.elem)); 4034 formatter.field("len", Lite(&_val.len)); 4035 formatter.finish() 4036 } 4037 syn::Type::BareFn(_val) => { 4038 let mut formatter = formatter.debug_struct("Type::BareFn"); 4039 if let Some(val) = &_val.lifetimes { 4040 #[derive(RefCast)] 4041 #[repr(transparent)] 4042 struct Print(syn::BoundLifetimes); 4043 impl Debug for Print { 4044 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4045 formatter.write_str("Some(")?; 4046 Debug::fmt(Lite(&self.0), formatter)?; 4047 formatter.write_str(")")?; 4048 Ok(()) 4049 } 4050 } 4051 formatter.field("lifetimes", Print::ref_cast(val)); 4052 } 4053 if _val.unsafety.is_some() { 4054 formatter.field("unsafety", &Present); 4055 } 4056 if let Some(val) = &_val.abi { 4057 #[derive(RefCast)] 4058 #[repr(transparent)] 4059 struct Print(syn::Abi); 4060 impl Debug for Print { 4061 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4062 formatter.write_str("Some(")?; 4063 Debug::fmt(Lite(&self.0), formatter)?; 4064 formatter.write_str(")")?; 4065 Ok(()) 4066 } 4067 } 4068 formatter.field("abi", Print::ref_cast(val)); 4069 } 4070 if !_val.inputs.is_empty() { 4071 formatter.field("inputs", Lite(&_val.inputs)); 4072 } 4073 if let Some(val) = &_val.variadic { 4074 #[derive(RefCast)] 4075 #[repr(transparent)] 4076 struct Print(syn::BareVariadic); 4077 impl Debug for Print { 4078 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4079 formatter.write_str("Some(")?; 4080 Debug::fmt(Lite(&self.0), formatter)?; 4081 formatter.write_str(")")?; 4082 Ok(()) 4083 } 4084 } 4085 formatter.field("variadic", Print::ref_cast(val)); 4086 } 4087 formatter.field("output", Lite(&_val.output)); 4088 formatter.finish() 4089 } 4090 syn::Type::Group(_val) => { 4091 let mut formatter = formatter.debug_struct("Type::Group"); 4092 formatter.field("elem", Lite(&_val.elem)); 4093 formatter.finish() 4094 } 4095 syn::Type::ImplTrait(_val) => { 4096 let mut formatter = formatter.debug_struct("Type::ImplTrait"); 4097 if !_val.bounds.is_empty() { 4098 formatter.field("bounds", Lite(&_val.bounds)); 4099 } 4100 formatter.finish() 4101 } 4102 syn::Type::Infer(_val) => { 4103 let mut formatter = formatter.debug_struct("Type::Infer"); 4104 formatter.finish() 4105 } 4106 syn::Type::Macro(_val) => { 4107 let mut formatter = formatter.debug_struct("Type::Macro"); 4108 formatter.field("mac", Lite(&_val.mac)); 4109 formatter.finish() 4110 } 4111 syn::Type::Never(_val) => { 4112 let mut formatter = formatter.debug_struct("Type::Never"); 4113 formatter.finish() 4114 } 4115 syn::Type::Paren(_val) => { 4116 let mut formatter = formatter.debug_struct("Type::Paren"); 4117 formatter.field("elem", Lite(&_val.elem)); 4118 formatter.finish() 4119 } 4120 syn::Type::Path(_val) => { 4121 let mut formatter = formatter.debug_struct("Type::Path"); 4122 if let Some(val) = &_val.qself { 4123 #[derive(RefCast)] 4124 #[repr(transparent)] 4125 struct Print(syn::QSelf); 4126 impl Debug for Print { 4127 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4128 formatter.write_str("Some(")?; 4129 Debug::fmt(Lite(&self.0), formatter)?; 4130 formatter.write_str(")")?; 4131 Ok(()) 4132 } 4133 } 4134 formatter.field("qself", Print::ref_cast(val)); 4135 } 4136 formatter.field("path", Lite(&_val.path)); 4137 formatter.finish() 4138 } 4139 syn::Type::Ptr(_val) => { 4140 let mut formatter = formatter.debug_struct("Type::Ptr"); 4141 if _val.const_token.is_some() { 4142 formatter.field("const_token", &Present); 4143 } 4144 if _val.mutability.is_some() { 4145 formatter.field("mutability", &Present); 4146 } 4147 formatter.field("elem", Lite(&_val.elem)); 4148 formatter.finish() 4149 } 4150 syn::Type::Reference(_val) => { 4151 let mut formatter = formatter.debug_struct("Type::Reference"); 4152 if let Some(val) = &_val.lifetime { 4153 #[derive(RefCast)] 4154 #[repr(transparent)] 4155 struct Print(syn::Lifetime); 4156 impl Debug for Print { 4157 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4158 formatter.write_str("Some(")?; 4159 Debug::fmt(Lite(&self.0), formatter)?; 4160 formatter.write_str(")")?; 4161 Ok(()) 4162 } 4163 } 4164 formatter.field("lifetime", Print::ref_cast(val)); 4165 } 4166 if _val.mutability.is_some() { 4167 formatter.field("mutability", &Present); 4168 } 4169 formatter.field("elem", Lite(&_val.elem)); 4170 formatter.finish() 4171 } 4172 syn::Type::Slice(_val) => { 4173 let mut formatter = formatter.debug_struct("Type::Slice"); 4174 formatter.field("elem", Lite(&_val.elem)); 4175 formatter.finish() 4176 } 4177 syn::Type::TraitObject(_val) => { 4178 let mut formatter = formatter.debug_struct("Type::TraitObject"); 4179 if _val.dyn_token.is_some() { 4180 formatter.field("dyn_token", &Present); 4181 } 4182 if !_val.bounds.is_empty() { 4183 formatter.field("bounds", Lite(&_val.bounds)); 4184 } 4185 formatter.finish() 4186 } 4187 syn::Type::Tuple(_val) => { 4188 let mut formatter = formatter.debug_struct("Type::Tuple"); 4189 if !_val.elems.is_empty() { 4190 formatter.field("elems", Lite(&_val.elems)); 4191 } 4192 formatter.finish() 4193 } 4194 syn::Type::Verbatim(_val) => { 4195 formatter.write_str("Type::Verbatim")?; 4196 formatter.write_str("(`")?; 4197 Display::fmt(_val, formatter)?; 4198 formatter.write_str("`)")?; 4199 Ok(()) 4200 } 4201 _ => unreachable!(), 4202 } 4203 } 4204} 4205impl Debug for Lite<syn::TypeArray> { 4206 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4207 let mut formatter = formatter.debug_struct("TypeArray"); 4208 formatter.field("elem", Lite(&self.value.elem)); 4209 formatter.field("len", Lite(&self.value.len)); 4210 formatter.finish() 4211 } 4212} 4213impl Debug for Lite<syn::TypeBareFn> { 4214 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4215 let mut formatter = formatter.debug_struct("TypeBareFn"); 4216 if let Some(val) = &self.value.lifetimes { 4217 #[derive(RefCast)] 4218 #[repr(transparent)] 4219 struct Print(syn::BoundLifetimes); 4220 impl Debug for Print { 4221 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4222 formatter.write_str("Some(")?; 4223 Debug::fmt(Lite(&self.0), formatter)?; 4224 formatter.write_str(")")?; 4225 Ok(()) 4226 } 4227 } 4228 formatter.field("lifetimes", Print::ref_cast(val)); 4229 } 4230 if self.value.unsafety.is_some() { 4231 formatter.field("unsafety", &Present); 4232 } 4233 if let Some(val) = &self.value.abi { 4234 #[derive(RefCast)] 4235 #[repr(transparent)] 4236 struct Print(syn::Abi); 4237 impl Debug for Print { 4238 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4239 formatter.write_str("Some(")?; 4240 Debug::fmt(Lite(&self.0), formatter)?; 4241 formatter.write_str(")")?; 4242 Ok(()) 4243 } 4244 } 4245 formatter.field("abi", Print::ref_cast(val)); 4246 } 4247 if !self.value.inputs.is_empty() { 4248 formatter.field("inputs", Lite(&self.value.inputs)); 4249 } 4250 if let Some(val) = &self.value.variadic { 4251 #[derive(RefCast)] 4252 #[repr(transparent)] 4253 struct Print(syn::BareVariadic); 4254 impl Debug for Print { 4255 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4256 formatter.write_str("Some(")?; 4257 Debug::fmt(Lite(&self.0), formatter)?; 4258 formatter.write_str(")")?; 4259 Ok(()) 4260 } 4261 } 4262 formatter.field("variadic", Print::ref_cast(val)); 4263 } 4264 formatter.field("output", Lite(&self.value.output)); 4265 formatter.finish() 4266 } 4267} 4268impl Debug for Lite<syn::TypeGroup> { 4269 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4270 let mut formatter = formatter.debug_struct("TypeGroup"); 4271 formatter.field("elem", Lite(&self.value.elem)); 4272 formatter.finish() 4273 } 4274} 4275impl Debug for Lite<syn::TypeImplTrait> { 4276 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4277 let mut formatter = formatter.debug_struct("TypeImplTrait"); 4278 if !self.value.bounds.is_empty() { 4279 formatter.field("bounds", Lite(&self.value.bounds)); 4280 } 4281 formatter.finish() 4282 } 4283} 4284impl Debug for Lite<syn::TypeInfer> { 4285 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4286 let mut formatter = formatter.debug_struct("TypeInfer"); 4287 formatter.finish() 4288 } 4289} 4290impl Debug for Lite<syn::TypeMacro> { 4291 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4292 let mut formatter = formatter.debug_struct("TypeMacro"); 4293 formatter.field("mac", Lite(&self.value.mac)); 4294 formatter.finish() 4295 } 4296} 4297impl Debug for Lite<syn::TypeNever> { 4298 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4299 let mut formatter = formatter.debug_struct("TypeNever"); 4300 formatter.finish() 4301 } 4302} 4303impl Debug for Lite<syn::TypeParam> { 4304 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4305 let mut formatter = formatter.debug_struct("TypeParam"); 4306 if !self.value.attrs.is_empty() { 4307 formatter.field("attrs", Lite(&self.value.attrs)); 4308 } 4309 formatter.field("ident", Lite(&self.value.ident)); 4310 if self.value.colon_token.is_some() { 4311 formatter.field("colon_token", &Present); 4312 } 4313 if !self.value.bounds.is_empty() { 4314 formatter.field("bounds", Lite(&self.value.bounds)); 4315 } 4316 if self.value.eq_token.is_some() { 4317 formatter.field("eq_token", &Present); 4318 } 4319 if let Some(val) = &self.value.default { 4320 #[derive(RefCast)] 4321 #[repr(transparent)] 4322 struct Print(syn::Type); 4323 impl Debug for Print { 4324 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4325 formatter.write_str("Some(")?; 4326 Debug::fmt(Lite(&self.0), formatter)?; 4327 formatter.write_str(")")?; 4328 Ok(()) 4329 } 4330 } 4331 formatter.field("default", Print::ref_cast(val)); 4332 } 4333 formatter.finish() 4334 } 4335} 4336impl Debug for Lite<syn::TypeParamBound> { 4337 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4338 match &self.value { 4339 syn::TypeParamBound::Trait(_val) => { 4340 formatter.write_str("TypeParamBound::Trait")?; 4341 formatter.write_str("(")?; 4342 Debug::fmt(Lite(_val), formatter)?; 4343 formatter.write_str(")")?; 4344 Ok(()) 4345 } 4346 syn::TypeParamBound::Lifetime(_val) => { 4347 let mut formatter = formatter.debug_struct("TypeParamBound::Lifetime"); 4348 formatter.field("ident", Lite(&_val.ident)); 4349 formatter.finish() 4350 } 4351 syn::TypeParamBound::Verbatim(_val) => { 4352 formatter.write_str("TypeParamBound::Verbatim")?; 4353 formatter.write_str("(`")?; 4354 Display::fmt(_val, formatter)?; 4355 formatter.write_str("`)")?; 4356 Ok(()) 4357 } 4358 _ => unreachable!(), 4359 } 4360 } 4361} 4362impl Debug for Lite<syn::TypeParen> { 4363 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4364 let mut formatter = formatter.debug_struct("TypeParen"); 4365 formatter.field("elem", Lite(&self.value.elem)); 4366 formatter.finish() 4367 } 4368} 4369impl Debug for Lite<syn::TypePath> { 4370 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4371 let mut formatter = formatter.debug_struct("TypePath"); 4372 if let Some(val) = &self.value.qself { 4373 #[derive(RefCast)] 4374 #[repr(transparent)] 4375 struct Print(syn::QSelf); 4376 impl Debug for Print { 4377 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4378 formatter.write_str("Some(")?; 4379 Debug::fmt(Lite(&self.0), formatter)?; 4380 formatter.write_str(")")?; 4381 Ok(()) 4382 } 4383 } 4384 formatter.field("qself", Print::ref_cast(val)); 4385 } 4386 formatter.field("path", Lite(&self.value.path)); 4387 formatter.finish() 4388 } 4389} 4390impl Debug for Lite<syn::TypePtr> { 4391 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4392 let mut formatter = formatter.debug_struct("TypePtr"); 4393 if self.value.const_token.is_some() { 4394 formatter.field("const_token", &Present); 4395 } 4396 if self.value.mutability.is_some() { 4397 formatter.field("mutability", &Present); 4398 } 4399 formatter.field("elem", Lite(&self.value.elem)); 4400 formatter.finish() 4401 } 4402} 4403impl Debug for Lite<syn::TypeReference> { 4404 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4405 let mut formatter = formatter.debug_struct("TypeReference"); 4406 if let Some(val) = &self.value.lifetime { 4407 #[derive(RefCast)] 4408 #[repr(transparent)] 4409 struct Print(syn::Lifetime); 4410 impl Debug for Print { 4411 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4412 formatter.write_str("Some(")?; 4413 Debug::fmt(Lite(&self.0), formatter)?; 4414 formatter.write_str(")")?; 4415 Ok(()) 4416 } 4417 } 4418 formatter.field("lifetime", Print::ref_cast(val)); 4419 } 4420 if self.value.mutability.is_some() { 4421 formatter.field("mutability", &Present); 4422 } 4423 formatter.field("elem", Lite(&self.value.elem)); 4424 formatter.finish() 4425 } 4426} 4427impl Debug for Lite<syn::TypeSlice> { 4428 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4429 let mut formatter = formatter.debug_struct("TypeSlice"); 4430 formatter.field("elem", Lite(&self.value.elem)); 4431 formatter.finish() 4432 } 4433} 4434impl Debug for Lite<syn::TypeTraitObject> { 4435 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4436 let mut formatter = formatter.debug_struct("TypeTraitObject"); 4437 if self.value.dyn_token.is_some() { 4438 formatter.field("dyn_token", &Present); 4439 } 4440 if !self.value.bounds.is_empty() { 4441 formatter.field("bounds", Lite(&self.value.bounds)); 4442 } 4443 formatter.finish() 4444 } 4445} 4446impl Debug for Lite<syn::TypeTuple> { 4447 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4448 let mut formatter = formatter.debug_struct("TypeTuple"); 4449 if !self.value.elems.is_empty() { 4450 formatter.field("elems", Lite(&self.value.elems)); 4451 } 4452 formatter.finish() 4453 } 4454} 4455impl Debug for Lite<syn::UnOp> { 4456 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4457 match &self.value { 4458 syn::UnOp::Deref(_val) => { 4459 formatter.write_str("UnOp::Deref")?; 4460 Ok(()) 4461 } 4462 syn::UnOp::Not(_val) => { 4463 formatter.write_str("UnOp::Not")?; 4464 Ok(()) 4465 } 4466 syn::UnOp::Neg(_val) => { 4467 formatter.write_str("UnOp::Neg")?; 4468 Ok(()) 4469 } 4470 _ => unreachable!(), 4471 } 4472 } 4473} 4474impl Debug for Lite<syn::UseGlob> { 4475 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4476 let mut formatter = formatter.debug_struct("UseGlob"); 4477 formatter.finish() 4478 } 4479} 4480impl Debug for Lite<syn::UseGroup> { 4481 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4482 let mut formatter = formatter.debug_struct("UseGroup"); 4483 if !self.value.items.is_empty() { 4484 formatter.field("items", Lite(&self.value.items)); 4485 } 4486 formatter.finish() 4487 } 4488} 4489impl Debug for Lite<syn::UseName> { 4490 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4491 let mut formatter = formatter.debug_struct("UseName"); 4492 formatter.field("ident", Lite(&self.value.ident)); 4493 formatter.finish() 4494 } 4495} 4496impl Debug for Lite<syn::UsePath> { 4497 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4498 let mut formatter = formatter.debug_struct("UsePath"); 4499 formatter.field("ident", Lite(&self.value.ident)); 4500 formatter.field("tree", Lite(&self.value.tree)); 4501 formatter.finish() 4502 } 4503} 4504impl Debug for Lite<syn::UseRename> { 4505 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4506 let mut formatter = formatter.debug_struct("UseRename"); 4507 formatter.field("ident", Lite(&self.value.ident)); 4508 formatter.field("rename", Lite(&self.value.rename)); 4509 formatter.finish() 4510 } 4511} 4512impl Debug for Lite<syn::UseTree> { 4513 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4514 match &self.value { 4515 syn::UseTree::Path(_val) => { 4516 formatter.write_str("UseTree::Path")?; 4517 formatter.write_str("(")?; 4518 Debug::fmt(Lite(_val), formatter)?; 4519 formatter.write_str(")")?; 4520 Ok(()) 4521 } 4522 syn::UseTree::Name(_val) => { 4523 formatter.write_str("UseTree::Name")?; 4524 formatter.write_str("(")?; 4525 Debug::fmt(Lite(_val), formatter)?; 4526 formatter.write_str(")")?; 4527 Ok(()) 4528 } 4529 syn::UseTree::Rename(_val) => { 4530 formatter.write_str("UseTree::Rename")?; 4531 formatter.write_str("(")?; 4532 Debug::fmt(Lite(_val), formatter)?; 4533 formatter.write_str(")")?; 4534 Ok(()) 4535 } 4536 syn::UseTree::Glob(_val) => { 4537 formatter.write_str("UseTree::Glob")?; 4538 formatter.write_str("(")?; 4539 Debug::fmt(Lite(_val), formatter)?; 4540 formatter.write_str(")")?; 4541 Ok(()) 4542 } 4543 syn::UseTree::Group(_val) => { 4544 formatter.write_str("UseTree::Group")?; 4545 formatter.write_str("(")?; 4546 Debug::fmt(Lite(_val), formatter)?; 4547 formatter.write_str(")")?; 4548 Ok(()) 4549 } 4550 } 4551 } 4552} 4553impl Debug for Lite<syn::Variadic> { 4554 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4555 let mut formatter = formatter.debug_struct("Variadic"); 4556 if !self.value.attrs.is_empty() { 4557 formatter.field("attrs", Lite(&self.value.attrs)); 4558 } 4559 if let Some(val) = &self.value.pat { 4560 #[derive(RefCast)] 4561 #[repr(transparent)] 4562 struct Print((Box<syn::Pat>, syn::token::Colon)); 4563 impl Debug for Print { 4564 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4565 formatter.write_str("Some(")?; 4566 Debug::fmt(Lite(&self.0.0), formatter)?; 4567 formatter.write_str(")")?; 4568 Ok(()) 4569 } 4570 } 4571 formatter.field("pat", Print::ref_cast(val)); 4572 } 4573 if self.value.comma.is_some() { 4574 formatter.field("comma", &Present); 4575 } 4576 formatter.finish() 4577 } 4578} 4579impl Debug for Lite<syn::Variant> { 4580 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4581 let mut formatter = formatter.debug_struct("Variant"); 4582 if !self.value.attrs.is_empty() { 4583 formatter.field("attrs", Lite(&self.value.attrs)); 4584 } 4585 formatter.field("ident", Lite(&self.value.ident)); 4586 formatter.field("fields", Lite(&self.value.fields)); 4587 if let Some(val) = &self.value.discriminant { 4588 #[derive(RefCast)] 4589 #[repr(transparent)] 4590 struct Print((syn::token::Eq, syn::Expr)); 4591 impl Debug for Print { 4592 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4593 formatter.write_str("Some(")?; 4594 Debug::fmt(Lite(&self.0.1), formatter)?; 4595 formatter.write_str(")")?; 4596 Ok(()) 4597 } 4598 } 4599 formatter.field("discriminant", Print::ref_cast(val)); 4600 } 4601 formatter.finish() 4602 } 4603} 4604impl Debug for Lite<syn::VisRestricted> { 4605 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4606 let mut formatter = formatter.debug_struct("VisRestricted"); 4607 if self.value.in_token.is_some() { 4608 formatter.field("in_token", &Present); 4609 } 4610 formatter.field("path", Lite(&self.value.path)); 4611 formatter.finish() 4612 } 4613} 4614impl Debug for Lite<syn::Visibility> { 4615 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4616 match &self.value { 4617 syn::Visibility::Public(_val) => { 4618 formatter.write_str("Visibility::Public")?; 4619 Ok(()) 4620 } 4621 syn::Visibility::Restricted(_val) => { 4622 let mut formatter = formatter.debug_struct("Visibility::Restricted"); 4623 if _val.in_token.is_some() { 4624 formatter.field("in_token", &Present); 4625 } 4626 formatter.field("path", Lite(&_val.path)); 4627 formatter.finish() 4628 } 4629 syn::Visibility::Inherited => formatter.write_str("Visibility::Inherited"), 4630 } 4631 } 4632} 4633impl Debug for Lite<syn::WhereClause> { 4634 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4635 let mut formatter = formatter.debug_struct("WhereClause"); 4636 if !self.value.predicates.is_empty() { 4637 formatter.field("predicates", Lite(&self.value.predicates)); 4638 } 4639 formatter.finish() 4640 } 4641} 4642impl Debug for Lite<syn::WherePredicate> { 4643 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4644 match &self.value { 4645 syn::WherePredicate::Lifetime(_val) => { 4646 formatter.write_str("WherePredicate::Lifetime")?; 4647 formatter.write_str("(")?; 4648 Debug::fmt(Lite(_val), formatter)?; 4649 formatter.write_str(")")?; 4650 Ok(()) 4651 } 4652 syn::WherePredicate::Type(_val) => { 4653 formatter.write_str("WherePredicate::Type")?; 4654 formatter.write_str("(")?; 4655 Debug::fmt(Lite(_val), formatter)?; 4656 formatter.write_str(")")?; 4657 Ok(()) 4658 } 4659 _ => unreachable!(), 4660 } 4661 } 4662} 4663impl Debug for Lite<syn::token::Abstract> { 4664 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4665 formatter.write_str("Token![abstract]") 4666 } 4667} 4668impl Debug for Lite<syn::token::And> { 4669 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4670 formatter.write_str("Token![&]") 4671 } 4672} 4673impl Debug for Lite<syn::token::AndAnd> { 4674 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4675 formatter.write_str("Token![&&]") 4676 } 4677} 4678impl Debug for Lite<syn::token::AndEq> { 4679 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4680 formatter.write_str("Token![&=]") 4681 } 4682} 4683impl Debug for Lite<syn::token::As> { 4684 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4685 formatter.write_str("Token![as]") 4686 } 4687} 4688impl Debug for Lite<syn::token::Async> { 4689 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4690 formatter.write_str("Token![async]") 4691 } 4692} 4693impl Debug for Lite<syn::token::At> { 4694 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4695 formatter.write_str("Token![@]") 4696 } 4697} 4698impl Debug for Lite<syn::token::Auto> { 4699 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4700 formatter.write_str("Token![auto]") 4701 } 4702} 4703impl Debug for Lite<syn::token::Await> { 4704 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4705 formatter.write_str("Token![await]") 4706 } 4707} 4708impl Debug for Lite<syn::token::Become> { 4709 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4710 formatter.write_str("Token![become]") 4711 } 4712} 4713impl Debug for Lite<syn::token::Box> { 4714 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4715 formatter.write_str("Token![box]") 4716 } 4717} 4718impl Debug for Lite<syn::token::Break> { 4719 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4720 formatter.write_str("Token![break]") 4721 } 4722} 4723impl Debug for Lite<syn::token::Caret> { 4724 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4725 formatter.write_str("Token![^]") 4726 } 4727} 4728impl Debug for Lite<syn::token::CaretEq> { 4729 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4730 formatter.write_str("Token![^=]") 4731 } 4732} 4733impl Debug for Lite<syn::token::Colon> { 4734 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4735 formatter.write_str("Token![:]") 4736 } 4737} 4738impl Debug for Lite<syn::token::Comma> { 4739 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4740 formatter.write_str("Token![,]") 4741 } 4742} 4743impl Debug for Lite<syn::token::Const> { 4744 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4745 formatter.write_str("Token![const]") 4746 } 4747} 4748impl Debug for Lite<syn::token::Continue> { 4749 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4750 formatter.write_str("Token![continue]") 4751 } 4752} 4753impl Debug for Lite<syn::token::Crate> { 4754 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4755 formatter.write_str("Token![crate]") 4756 } 4757} 4758impl Debug for Lite<syn::token::Default> { 4759 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4760 formatter.write_str("Token![default]") 4761 } 4762} 4763impl Debug for Lite<syn::token::Do> { 4764 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4765 formatter.write_str("Token![do]") 4766 } 4767} 4768impl Debug for Lite<syn::token::Dollar> { 4769 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4770 formatter.write_str("Token![$]") 4771 } 4772} 4773impl Debug for Lite<syn::token::Dot> { 4774 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4775 formatter.write_str("Token![.]") 4776 } 4777} 4778impl Debug for Lite<syn::token::DotDot> { 4779 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4780 formatter.write_str("Token![..]") 4781 } 4782} 4783impl Debug for Lite<syn::token::DotDotDot> { 4784 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4785 formatter.write_str("Token![...]") 4786 } 4787} 4788impl Debug for Lite<syn::token::DotDotEq> { 4789 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4790 formatter.write_str("Token![..=]") 4791 } 4792} 4793impl Debug for Lite<syn::token::Dyn> { 4794 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4795 formatter.write_str("Token![dyn]") 4796 } 4797} 4798impl Debug for Lite<syn::token::Else> { 4799 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4800 formatter.write_str("Token![else]") 4801 } 4802} 4803impl Debug for Lite<syn::token::Enum> { 4804 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4805 formatter.write_str("Token![enum]") 4806 } 4807} 4808impl Debug for Lite<syn::token::Eq> { 4809 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4810 formatter.write_str("Token![=]") 4811 } 4812} 4813impl Debug for Lite<syn::token::EqEq> { 4814 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4815 formatter.write_str("Token![==]") 4816 } 4817} 4818impl Debug for Lite<syn::token::Extern> { 4819 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4820 formatter.write_str("Token![extern]") 4821 } 4822} 4823impl Debug for Lite<syn::token::FatArrow> { 4824 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4825 formatter.write_str("Token![=>]") 4826 } 4827} 4828impl Debug for Lite<syn::token::Final> { 4829 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4830 formatter.write_str("Token![final]") 4831 } 4832} 4833impl Debug for Lite<syn::token::Fn> { 4834 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4835 formatter.write_str("Token![fn]") 4836 } 4837} 4838impl Debug for Lite<syn::token::For> { 4839 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4840 formatter.write_str("Token![for]") 4841 } 4842} 4843impl Debug for Lite<syn::token::Ge> { 4844 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4845 formatter.write_str("Token![>=]") 4846 } 4847} 4848impl Debug for Lite<syn::token::Gt> { 4849 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4850 formatter.write_str("Token![>]") 4851 } 4852} 4853impl Debug for Lite<syn::token::If> { 4854 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4855 formatter.write_str("Token![if]") 4856 } 4857} 4858impl Debug for Lite<syn::token::Impl> { 4859 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4860 formatter.write_str("Token![impl]") 4861 } 4862} 4863impl Debug for Lite<syn::token::In> { 4864 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4865 formatter.write_str("Token![in]") 4866 } 4867} 4868impl Debug for Lite<syn::token::LArrow> { 4869 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4870 formatter.write_str("Token![<-]") 4871 } 4872} 4873impl Debug for Lite<syn::token::Le> { 4874 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4875 formatter.write_str("Token![<=]") 4876 } 4877} 4878impl Debug for Lite<syn::token::Let> { 4879 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4880 formatter.write_str("Token![let]") 4881 } 4882} 4883impl Debug for Lite<syn::token::Loop> { 4884 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4885 formatter.write_str("Token![loop]") 4886 } 4887} 4888impl Debug for Lite<syn::token::Lt> { 4889 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4890 formatter.write_str("Token![<]") 4891 } 4892} 4893impl Debug for Lite<syn::token::Macro> { 4894 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4895 formatter.write_str("Token![macro]") 4896 } 4897} 4898impl Debug for Lite<syn::token::Match> { 4899 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4900 formatter.write_str("Token![match]") 4901 } 4902} 4903impl Debug for Lite<syn::token::Minus> { 4904 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4905 formatter.write_str("Token![-]") 4906 } 4907} 4908impl Debug for Lite<syn::token::MinusEq> { 4909 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4910 formatter.write_str("Token![-=]") 4911 } 4912} 4913impl Debug for Lite<syn::token::Mod> { 4914 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4915 formatter.write_str("Token![mod]") 4916 } 4917} 4918impl Debug for Lite<syn::token::Move> { 4919 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4920 formatter.write_str("Token![move]") 4921 } 4922} 4923impl Debug for Lite<syn::token::Mut> { 4924 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4925 formatter.write_str("Token![mut]") 4926 } 4927} 4928impl Debug for Lite<syn::token::Ne> { 4929 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4930 formatter.write_str("Token![!=]") 4931 } 4932} 4933impl Debug for Lite<syn::token::Not> { 4934 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4935 formatter.write_str("Token![!]") 4936 } 4937} 4938impl Debug for Lite<syn::token::Or> { 4939 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4940 formatter.write_str("Token![|]") 4941 } 4942} 4943impl Debug for Lite<syn::token::OrEq> { 4944 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4945 formatter.write_str("Token![|=]") 4946 } 4947} 4948impl Debug for Lite<syn::token::OrOr> { 4949 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4950 formatter.write_str("Token![||]") 4951 } 4952} 4953impl Debug for Lite<syn::token::Override> { 4954 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4955 formatter.write_str("Token![override]") 4956 } 4957} 4958impl Debug for Lite<syn::token::PathSep> { 4959 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4960 formatter.write_str("Token![::]") 4961 } 4962} 4963impl Debug for Lite<syn::token::Percent> { 4964 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4965 formatter.write_str("Token![%]") 4966 } 4967} 4968impl Debug for Lite<syn::token::PercentEq> { 4969 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4970 formatter.write_str("Token![%=]") 4971 } 4972} 4973impl Debug for Lite<syn::token::Plus> { 4974 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4975 formatter.write_str("Token![+]") 4976 } 4977} 4978impl Debug for Lite<syn::token::PlusEq> { 4979 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4980 formatter.write_str("Token![+=]") 4981 } 4982} 4983impl Debug for Lite<syn::token::Pound> { 4984 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4985 formatter.write_str("Token![#]") 4986 } 4987} 4988impl Debug for Lite<syn::token::Priv> { 4989 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4990 formatter.write_str("Token![priv]") 4991 } 4992} 4993impl Debug for Lite<syn::token::Pub> { 4994 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4995 formatter.write_str("Token![pub]") 4996 } 4997} 4998impl Debug for Lite<syn::token::Question> { 4999 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 5000 formatter.write_str("Token![?]") 5001 } 5002} 5003impl Debug for Lite<syn::token::RArrow> { 5004 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 5005 formatter.write_str("Token![->]") 5006 } 5007} 5008impl Debug for Lite<syn::token::Ref> { 5009 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 5010 formatter.write_str("Token![ref]") 5011 } 5012} 5013impl Debug for Lite<syn::token::Return> { 5014 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 5015 formatter.write_str("Token![return]") 5016 } 5017} 5018impl Debug for Lite<syn::token::SelfType> { 5019 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 5020 formatter.write_str("Token![Self]") 5021 } 5022} 5023impl Debug for Lite<syn::token::SelfValue> { 5024 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 5025 formatter.write_str("Token![self]") 5026 } 5027} 5028impl Debug for Lite<syn::token::Semi> { 5029 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 5030 formatter.write_str("Token![;]") 5031 } 5032} 5033impl Debug for Lite<syn::token::Shl> { 5034 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 5035 formatter.write_str("Token![<<]") 5036 } 5037} 5038impl Debug for Lite<syn::token::ShlEq> { 5039 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 5040 formatter.write_str("Token![<<=]") 5041 } 5042} 5043impl Debug for Lite<syn::token::Shr> { 5044 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 5045 formatter.write_str("Token![>>]") 5046 } 5047} 5048impl Debug for Lite<syn::token::ShrEq> { 5049 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 5050 formatter.write_str("Token![>>=]") 5051 } 5052} 5053impl Debug for Lite<syn::token::Slash> { 5054 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 5055 formatter.write_str("Token![/]") 5056 } 5057} 5058impl Debug for Lite<syn::token::SlashEq> { 5059 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 5060 formatter.write_str("Token![/=]") 5061 } 5062} 5063impl Debug for Lite<syn::token::Star> { 5064 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 5065 formatter.write_str("Token![*]") 5066 } 5067} 5068impl Debug for Lite<syn::token::StarEq> { 5069 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 5070 formatter.write_str("Token![*=]") 5071 } 5072} 5073impl Debug for Lite<syn::token::Static> { 5074 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 5075 formatter.write_str("Token![static]") 5076 } 5077} 5078impl Debug for Lite<syn::token::Struct> { 5079 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 5080 formatter.write_str("Token![struct]") 5081 } 5082} 5083impl Debug for Lite<syn::token::Super> { 5084 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 5085 formatter.write_str("Token![super]") 5086 } 5087} 5088impl Debug for Lite<syn::token::Tilde> { 5089 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 5090 formatter.write_str("Token![~]") 5091 } 5092} 5093impl Debug for Lite<syn::token::Trait> { 5094 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 5095 formatter.write_str("Token![trait]") 5096 } 5097} 5098impl Debug for Lite<syn::token::Try> { 5099 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 5100 formatter.write_str("Token![try]") 5101 } 5102} 5103impl Debug for Lite<syn::token::Type> { 5104 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 5105 formatter.write_str("Token![type]") 5106 } 5107} 5108impl Debug for Lite<syn::token::Typeof> { 5109 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 5110 formatter.write_str("Token![typeof]") 5111 } 5112} 5113impl Debug for Lite<syn::token::Underscore> { 5114 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 5115 formatter.write_str("Token![_]") 5116 } 5117} 5118impl Debug for Lite<syn::token::Union> { 5119 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 5120 formatter.write_str("Token![union]") 5121 } 5122} 5123impl Debug for Lite<syn::token::Unsafe> { 5124 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 5125 formatter.write_str("Token![unsafe]") 5126 } 5127} 5128impl Debug for Lite<syn::token::Unsized> { 5129 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 5130 formatter.write_str("Token![unsized]") 5131 } 5132} 5133impl Debug for Lite<syn::token::Use> { 5134 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 5135 formatter.write_str("Token![use]") 5136 } 5137} 5138impl Debug for Lite<syn::token::Virtual> { 5139 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 5140 formatter.write_str("Token![virtual]") 5141 } 5142} 5143impl Debug for Lite<syn::token::Where> { 5144 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 5145 formatter.write_str("Token![where]") 5146 } 5147} 5148impl Debug for Lite<syn::token::While> { 5149 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 5150 formatter.write_str("Token![while]") 5151 } 5152} 5153impl Debug for Lite<syn::token::Yield> { 5154 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 5155 formatter.write_str("Token![yield]") 5156 } 5157} 5158