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)] 6 use super::{Lite, Present}; 7 use ref_cast::RefCast; 8 use std::fmt::{self, Debug, Display}; 9 impl Debug for Lite<syn::Abi> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result10 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 } 29 impl Debug for Lite<syn::AngleBracketedGenericArguments> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result30 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 } 41 impl Debug for Lite<syn::Arm> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result42 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 } 69 impl Debug for Lite<syn::AssocConst> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result70 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 } 91 impl Debug for Lite<syn::AssocType> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result92 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 } 113 impl Debug for Lite<syn::AttrStyle> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result114 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 } 124 impl Debug for Lite<syn::Attribute> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result125 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 } 132 impl Debug for Lite<syn::BareFnArg> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result133 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 } 156 impl Debug for Lite<syn::BareVariadic> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result157 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 } 182 impl Debug for Lite<syn::BinOp> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result183 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 } 301 impl Debug for Lite<syn::Block> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result302 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 303 let mut formatter = formatter.debug_struct("Block"); 304 if !self.value.stmts.is_empty() { 305 formatter.field("stmts", Lite(&self.value.stmts)); 306 } 307 formatter.finish() 308 } 309 } 310 impl Debug for Lite<syn::BoundLifetimes> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result311 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 312 let mut formatter = formatter.debug_struct("BoundLifetimes"); 313 if !self.value.lifetimes.is_empty() { 314 formatter.field("lifetimes", Lite(&self.value.lifetimes)); 315 } 316 formatter.finish() 317 } 318 } 319 impl Debug for Lite<syn::ConstParam> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result320 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 321 let mut formatter = formatter.debug_struct("ConstParam"); 322 if !self.value.attrs.is_empty() { 323 formatter.field("attrs", Lite(&self.value.attrs)); 324 } 325 formatter.field("ident", Lite(&self.value.ident)); 326 formatter.field("ty", Lite(&self.value.ty)); 327 if self.value.eq_token.is_some() { 328 formatter.field("eq_token", &Present); 329 } 330 if let Some(val) = &self.value.default { 331 #[derive(RefCast)] 332 #[repr(transparent)] 333 struct Print(syn::Expr); 334 impl Debug for Print { 335 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 336 formatter.write_str("Some(")?; 337 Debug::fmt(Lite(&self.0), formatter)?; 338 formatter.write_str(")")?; 339 Ok(()) 340 } 341 } 342 formatter.field("default", Print::ref_cast(val)); 343 } 344 formatter.finish() 345 } 346 } 347 impl Debug for Lite<syn::Constraint> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result348 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 349 let mut formatter = formatter.debug_struct("Constraint"); 350 formatter.field("ident", Lite(&self.value.ident)); 351 if let Some(val) = &self.value.generics { 352 #[derive(RefCast)] 353 #[repr(transparent)] 354 struct Print(syn::AngleBracketedGenericArguments); 355 impl Debug for Print { 356 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 357 formatter.write_str("Some(")?; 358 Debug::fmt(Lite(&self.0), formatter)?; 359 formatter.write_str(")")?; 360 Ok(()) 361 } 362 } 363 formatter.field("generics", Print::ref_cast(val)); 364 } 365 if !self.value.bounds.is_empty() { 366 formatter.field("bounds", Lite(&self.value.bounds)); 367 } 368 formatter.finish() 369 } 370 } 371 impl Debug for Lite<syn::Data> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result372 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 373 match &self.value { 374 syn::Data::Struct(_val) => { 375 let mut formatter = formatter.debug_struct("Data::Struct"); 376 formatter.field("fields", Lite(&_val.fields)); 377 if _val.semi_token.is_some() { 378 formatter.field("semi_token", &Present); 379 } 380 formatter.finish() 381 } 382 syn::Data::Enum(_val) => { 383 let mut formatter = formatter.debug_struct("Data::Enum"); 384 if !_val.variants.is_empty() { 385 formatter.field("variants", Lite(&_val.variants)); 386 } 387 formatter.finish() 388 } 389 syn::Data::Union(_val) => { 390 let mut formatter = formatter.debug_struct("Data::Union"); 391 formatter.field("fields", Lite(&_val.fields)); 392 formatter.finish() 393 } 394 } 395 } 396 } 397 impl Debug for Lite<syn::DataEnum> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result398 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 399 let mut formatter = formatter.debug_struct("DataEnum"); 400 if !self.value.variants.is_empty() { 401 formatter.field("variants", Lite(&self.value.variants)); 402 } 403 formatter.finish() 404 } 405 } 406 impl Debug for Lite<syn::DataStruct> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result407 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 408 let mut formatter = formatter.debug_struct("DataStruct"); 409 formatter.field("fields", Lite(&self.value.fields)); 410 if self.value.semi_token.is_some() { 411 formatter.field("semi_token", &Present); 412 } 413 formatter.finish() 414 } 415 } 416 impl Debug for Lite<syn::DataUnion> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result417 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 418 let mut formatter = formatter.debug_struct("DataUnion"); 419 formatter.field("fields", Lite(&self.value.fields)); 420 formatter.finish() 421 } 422 } 423 impl Debug for Lite<syn::DeriveInput> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result424 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 425 let mut formatter = formatter.debug_struct("DeriveInput"); 426 if !self.value.attrs.is_empty() { 427 formatter.field("attrs", Lite(&self.value.attrs)); 428 } 429 formatter.field("vis", Lite(&self.value.vis)); 430 formatter.field("ident", Lite(&self.value.ident)); 431 formatter.field("generics", Lite(&self.value.generics)); 432 formatter.field("data", Lite(&self.value.data)); 433 formatter.finish() 434 } 435 } 436 impl Debug for Lite<syn::Expr> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result437 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 438 match &self.value { 439 syn::Expr::Array(_val) => { 440 let mut formatter = formatter.debug_struct("Expr::Array"); 441 if !_val.attrs.is_empty() { 442 formatter.field("attrs", Lite(&_val.attrs)); 443 } 444 if !_val.elems.is_empty() { 445 formatter.field("elems", Lite(&_val.elems)); 446 } 447 formatter.finish() 448 } 449 syn::Expr::Assign(_val) => { 450 let mut formatter = formatter.debug_struct("Expr::Assign"); 451 if !_val.attrs.is_empty() { 452 formatter.field("attrs", Lite(&_val.attrs)); 453 } 454 formatter.field("left", Lite(&_val.left)); 455 formatter.field("right", Lite(&_val.right)); 456 formatter.finish() 457 } 458 syn::Expr::Async(_val) => { 459 let mut formatter = formatter.debug_struct("Expr::Async"); 460 if !_val.attrs.is_empty() { 461 formatter.field("attrs", Lite(&_val.attrs)); 462 } 463 if _val.capture.is_some() { 464 formatter.field("capture", &Present); 465 } 466 formatter.field("block", Lite(&_val.block)); 467 formatter.finish() 468 } 469 syn::Expr::Await(_val) => { 470 let mut formatter = formatter.debug_struct("Expr::Await"); 471 if !_val.attrs.is_empty() { 472 formatter.field("attrs", Lite(&_val.attrs)); 473 } 474 formatter.field("base", Lite(&_val.base)); 475 formatter.finish() 476 } 477 syn::Expr::Binary(_val) => { 478 let mut formatter = formatter.debug_struct("Expr::Binary"); 479 if !_val.attrs.is_empty() { 480 formatter.field("attrs", Lite(&_val.attrs)); 481 } 482 formatter.field("left", Lite(&_val.left)); 483 formatter.field("op", Lite(&_val.op)); 484 formatter.field("right", Lite(&_val.right)); 485 formatter.finish() 486 } 487 syn::Expr::Block(_val) => { 488 let mut formatter = formatter.debug_struct("Expr::Block"); 489 if !_val.attrs.is_empty() { 490 formatter.field("attrs", Lite(&_val.attrs)); 491 } 492 if let Some(val) = &_val.label { 493 #[derive(RefCast)] 494 #[repr(transparent)] 495 struct Print(syn::Label); 496 impl Debug for Print { 497 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 498 formatter.write_str("Some(")?; 499 Debug::fmt(Lite(&self.0), formatter)?; 500 formatter.write_str(")")?; 501 Ok(()) 502 } 503 } 504 formatter.field("label", Print::ref_cast(val)); 505 } 506 formatter.field("block", Lite(&_val.block)); 507 formatter.finish() 508 } 509 syn::Expr::Break(_val) => { 510 let mut formatter = formatter.debug_struct("Expr::Break"); 511 if !_val.attrs.is_empty() { 512 formatter.field("attrs", Lite(&_val.attrs)); 513 } 514 if let Some(val) = &_val.label { 515 #[derive(RefCast)] 516 #[repr(transparent)] 517 struct Print(syn::Lifetime); 518 impl Debug for Print { 519 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 520 formatter.write_str("Some(")?; 521 Debug::fmt(Lite(&self.0), formatter)?; 522 formatter.write_str(")")?; 523 Ok(()) 524 } 525 } 526 formatter.field("label", Print::ref_cast(val)); 527 } 528 if let Some(val) = &_val.expr { 529 #[derive(RefCast)] 530 #[repr(transparent)] 531 struct Print(Box<syn::Expr>); 532 impl Debug for Print { 533 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 534 formatter.write_str("Some(")?; 535 Debug::fmt(Lite(&self.0), formatter)?; 536 formatter.write_str(")")?; 537 Ok(()) 538 } 539 } 540 formatter.field("expr", Print::ref_cast(val)); 541 } 542 formatter.finish() 543 } 544 syn::Expr::Call(_val) => { 545 let mut formatter = formatter.debug_struct("Expr::Call"); 546 if !_val.attrs.is_empty() { 547 formatter.field("attrs", Lite(&_val.attrs)); 548 } 549 formatter.field("func", Lite(&_val.func)); 550 if !_val.args.is_empty() { 551 formatter.field("args", Lite(&_val.args)); 552 } 553 formatter.finish() 554 } 555 syn::Expr::Cast(_val) => { 556 let mut formatter = formatter.debug_struct("Expr::Cast"); 557 if !_val.attrs.is_empty() { 558 formatter.field("attrs", Lite(&_val.attrs)); 559 } 560 formatter.field("expr", Lite(&_val.expr)); 561 formatter.field("ty", Lite(&_val.ty)); 562 formatter.finish() 563 } 564 syn::Expr::Closure(_val) => { 565 let mut formatter = formatter.debug_struct("Expr::Closure"); 566 if !_val.attrs.is_empty() { 567 formatter.field("attrs", Lite(&_val.attrs)); 568 } 569 if let Some(val) = &_val.lifetimes { 570 #[derive(RefCast)] 571 #[repr(transparent)] 572 struct Print(syn::BoundLifetimes); 573 impl Debug for Print { 574 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 575 formatter.write_str("Some(")?; 576 Debug::fmt(Lite(&self.0), formatter)?; 577 formatter.write_str(")")?; 578 Ok(()) 579 } 580 } 581 formatter.field("lifetimes", Print::ref_cast(val)); 582 } 583 if _val.constness.is_some() { 584 formatter.field("constness", &Present); 585 } 586 if _val.movability.is_some() { 587 formatter.field("movability", &Present); 588 } 589 if _val.asyncness.is_some() { 590 formatter.field("asyncness", &Present); 591 } 592 if _val.capture.is_some() { 593 formatter.field("capture", &Present); 594 } 595 if !_val.inputs.is_empty() { 596 formatter.field("inputs", Lite(&_val.inputs)); 597 } 598 formatter.field("output", Lite(&_val.output)); 599 formatter.field("body", Lite(&_val.body)); 600 formatter.finish() 601 } 602 syn::Expr::Const(_val) => { 603 let mut formatter = formatter.debug_struct("Expr::Const"); 604 if !_val.attrs.is_empty() { 605 formatter.field("attrs", Lite(&_val.attrs)); 606 } 607 formatter.field("block", Lite(&_val.block)); 608 formatter.finish() 609 } 610 syn::Expr::Continue(_val) => { 611 let mut formatter = formatter.debug_struct("Expr::Continue"); 612 if !_val.attrs.is_empty() { 613 formatter.field("attrs", Lite(&_val.attrs)); 614 } 615 if let Some(val) = &_val.label { 616 #[derive(RefCast)] 617 #[repr(transparent)] 618 struct Print(syn::Lifetime); 619 impl Debug for Print { 620 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 621 formatter.write_str("Some(")?; 622 Debug::fmt(Lite(&self.0), formatter)?; 623 formatter.write_str(")")?; 624 Ok(()) 625 } 626 } 627 formatter.field("label", Print::ref_cast(val)); 628 } 629 formatter.finish() 630 } 631 syn::Expr::Field(_val) => { 632 let mut formatter = formatter.debug_struct("Expr::Field"); 633 if !_val.attrs.is_empty() { 634 formatter.field("attrs", Lite(&_val.attrs)); 635 } 636 formatter.field("base", Lite(&_val.base)); 637 formatter.field("member", Lite(&_val.member)); 638 formatter.finish() 639 } 640 syn::Expr::ForLoop(_val) => { 641 let mut formatter = formatter.debug_struct("Expr::ForLoop"); 642 if !_val.attrs.is_empty() { 643 formatter.field("attrs", Lite(&_val.attrs)); 644 } 645 if let Some(val) = &_val.label { 646 #[derive(RefCast)] 647 #[repr(transparent)] 648 struct Print(syn::Label); 649 impl Debug for Print { 650 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 651 formatter.write_str("Some(")?; 652 Debug::fmt(Lite(&self.0), formatter)?; 653 formatter.write_str(")")?; 654 Ok(()) 655 } 656 } 657 formatter.field("label", Print::ref_cast(val)); 658 } 659 formatter.field("pat", Lite(&_val.pat)); 660 formatter.field("expr", Lite(&_val.expr)); 661 formatter.field("body", Lite(&_val.body)); 662 formatter.finish() 663 } 664 syn::Expr::Group(_val) => { 665 let mut formatter = formatter.debug_struct("Expr::Group"); 666 if !_val.attrs.is_empty() { 667 formatter.field("attrs", Lite(&_val.attrs)); 668 } 669 formatter.field("expr", Lite(&_val.expr)); 670 formatter.finish() 671 } 672 syn::Expr::If(_val) => { 673 let mut formatter = formatter.debug_struct("Expr::If"); 674 if !_val.attrs.is_empty() { 675 formatter.field("attrs", Lite(&_val.attrs)); 676 } 677 formatter.field("cond", Lite(&_val.cond)); 678 formatter.field("then_branch", Lite(&_val.then_branch)); 679 if let Some(val) = &_val.else_branch { 680 #[derive(RefCast)] 681 #[repr(transparent)] 682 struct Print((syn::token::Else, Box<syn::Expr>)); 683 impl Debug for Print { 684 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 685 formatter.write_str("Some(")?; 686 Debug::fmt(Lite(&self.0.1), formatter)?; 687 formatter.write_str(")")?; 688 Ok(()) 689 } 690 } 691 formatter.field("else_branch", Print::ref_cast(val)); 692 } 693 formatter.finish() 694 } 695 syn::Expr::Index(_val) => { 696 let mut formatter = formatter.debug_struct("Expr::Index"); 697 if !_val.attrs.is_empty() { 698 formatter.field("attrs", Lite(&_val.attrs)); 699 } 700 formatter.field("expr", Lite(&_val.expr)); 701 formatter.field("index", Lite(&_val.index)); 702 formatter.finish() 703 } 704 syn::Expr::Infer(_val) => { 705 let mut formatter = formatter.debug_struct("Expr::Infer"); 706 if !_val.attrs.is_empty() { 707 formatter.field("attrs", Lite(&_val.attrs)); 708 } 709 formatter.finish() 710 } 711 syn::Expr::Let(_val) => { 712 let mut formatter = formatter.debug_struct("Expr::Let"); 713 if !_val.attrs.is_empty() { 714 formatter.field("attrs", Lite(&_val.attrs)); 715 } 716 formatter.field("pat", Lite(&_val.pat)); 717 formatter.field("expr", Lite(&_val.expr)); 718 formatter.finish() 719 } 720 syn::Expr::Lit(_val) => { 721 let mut formatter = formatter.debug_struct("Expr::Lit"); 722 if !_val.attrs.is_empty() { 723 formatter.field("attrs", Lite(&_val.attrs)); 724 } 725 formatter.field("lit", Lite(&_val.lit)); 726 formatter.finish() 727 } 728 syn::Expr::Loop(_val) => { 729 let mut formatter = formatter.debug_struct("Expr::Loop"); 730 if !_val.attrs.is_empty() { 731 formatter.field("attrs", Lite(&_val.attrs)); 732 } 733 if let Some(val) = &_val.label { 734 #[derive(RefCast)] 735 #[repr(transparent)] 736 struct Print(syn::Label); 737 impl Debug for Print { 738 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 739 formatter.write_str("Some(")?; 740 Debug::fmt(Lite(&self.0), formatter)?; 741 formatter.write_str(")")?; 742 Ok(()) 743 } 744 } 745 formatter.field("label", Print::ref_cast(val)); 746 } 747 formatter.field("body", Lite(&_val.body)); 748 formatter.finish() 749 } 750 syn::Expr::Macro(_val) => { 751 let mut formatter = formatter.debug_struct("Expr::Macro"); 752 if !_val.attrs.is_empty() { 753 formatter.field("attrs", Lite(&_val.attrs)); 754 } 755 formatter.field("mac", Lite(&_val.mac)); 756 formatter.finish() 757 } 758 syn::Expr::Match(_val) => { 759 let mut formatter = formatter.debug_struct("Expr::Match"); 760 if !_val.attrs.is_empty() { 761 formatter.field("attrs", Lite(&_val.attrs)); 762 } 763 formatter.field("expr", Lite(&_val.expr)); 764 if !_val.arms.is_empty() { 765 formatter.field("arms", Lite(&_val.arms)); 766 } 767 formatter.finish() 768 } 769 syn::Expr::MethodCall(_val) => { 770 let mut formatter = formatter.debug_struct("Expr::MethodCall"); 771 if !_val.attrs.is_empty() { 772 formatter.field("attrs", Lite(&_val.attrs)); 773 } 774 formatter.field("receiver", Lite(&_val.receiver)); 775 formatter.field("method", Lite(&_val.method)); 776 if let Some(val) = &_val.turbofish { 777 #[derive(RefCast)] 778 #[repr(transparent)] 779 struct Print(syn::AngleBracketedGenericArguments); 780 impl Debug for Print { 781 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 782 formatter.write_str("Some(")?; 783 Debug::fmt(Lite(&self.0), formatter)?; 784 formatter.write_str(")")?; 785 Ok(()) 786 } 787 } 788 formatter.field("turbofish", Print::ref_cast(val)); 789 } 790 if !_val.args.is_empty() { 791 formatter.field("args", Lite(&_val.args)); 792 } 793 formatter.finish() 794 } 795 syn::Expr::Paren(_val) => { 796 let mut formatter = formatter.debug_struct("Expr::Paren"); 797 if !_val.attrs.is_empty() { 798 formatter.field("attrs", Lite(&_val.attrs)); 799 } 800 formatter.field("expr", Lite(&_val.expr)); 801 formatter.finish() 802 } 803 syn::Expr::Path(_val) => { 804 let mut formatter = formatter.debug_struct("Expr::Path"); 805 if !_val.attrs.is_empty() { 806 formatter.field("attrs", Lite(&_val.attrs)); 807 } 808 if let Some(val) = &_val.qself { 809 #[derive(RefCast)] 810 #[repr(transparent)] 811 struct Print(syn::QSelf); 812 impl Debug for Print { 813 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 814 formatter.write_str("Some(")?; 815 Debug::fmt(Lite(&self.0), formatter)?; 816 formatter.write_str(")")?; 817 Ok(()) 818 } 819 } 820 formatter.field("qself", Print::ref_cast(val)); 821 } 822 formatter.field("path", Lite(&_val.path)); 823 formatter.finish() 824 } 825 syn::Expr::Range(_val) => { 826 let mut formatter = formatter.debug_struct("Expr::Range"); 827 if !_val.attrs.is_empty() { 828 formatter.field("attrs", Lite(&_val.attrs)); 829 } 830 if let Some(val) = &_val.start { 831 #[derive(RefCast)] 832 #[repr(transparent)] 833 struct Print(Box<syn::Expr>); 834 impl Debug for Print { 835 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 836 formatter.write_str("Some(")?; 837 Debug::fmt(Lite(&self.0), formatter)?; 838 formatter.write_str(")")?; 839 Ok(()) 840 } 841 } 842 formatter.field("start", Print::ref_cast(val)); 843 } 844 formatter.field("limits", Lite(&_val.limits)); 845 if let Some(val) = &_val.end { 846 #[derive(RefCast)] 847 #[repr(transparent)] 848 struct Print(Box<syn::Expr>); 849 impl Debug for Print { 850 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 851 formatter.write_str("Some(")?; 852 Debug::fmt(Lite(&self.0), formatter)?; 853 formatter.write_str(")")?; 854 Ok(()) 855 } 856 } 857 formatter.field("end", Print::ref_cast(val)); 858 } 859 formatter.finish() 860 } 861 syn::Expr::Reference(_val) => { 862 let mut formatter = formatter.debug_struct("Expr::Reference"); 863 if !_val.attrs.is_empty() { 864 formatter.field("attrs", Lite(&_val.attrs)); 865 } 866 if _val.mutability.is_some() { 867 formatter.field("mutability", &Present); 868 } 869 formatter.field("expr", Lite(&_val.expr)); 870 formatter.finish() 871 } 872 syn::Expr::Repeat(_val) => { 873 let mut formatter = formatter.debug_struct("Expr::Repeat"); 874 if !_val.attrs.is_empty() { 875 formatter.field("attrs", Lite(&_val.attrs)); 876 } 877 formatter.field("expr", Lite(&_val.expr)); 878 formatter.field("len", Lite(&_val.len)); 879 formatter.finish() 880 } 881 syn::Expr::Return(_val) => { 882 let mut formatter = formatter.debug_struct("Expr::Return"); 883 if !_val.attrs.is_empty() { 884 formatter.field("attrs", Lite(&_val.attrs)); 885 } 886 if let Some(val) = &_val.expr { 887 #[derive(RefCast)] 888 #[repr(transparent)] 889 struct Print(Box<syn::Expr>); 890 impl Debug for Print { 891 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 892 formatter.write_str("Some(")?; 893 Debug::fmt(Lite(&self.0), formatter)?; 894 formatter.write_str(")")?; 895 Ok(()) 896 } 897 } 898 formatter.field("expr", Print::ref_cast(val)); 899 } 900 formatter.finish() 901 } 902 syn::Expr::Struct(_val) => { 903 let mut formatter = formatter.debug_struct("Expr::Struct"); 904 if !_val.attrs.is_empty() { 905 formatter.field("attrs", Lite(&_val.attrs)); 906 } 907 if let Some(val) = &_val.qself { 908 #[derive(RefCast)] 909 #[repr(transparent)] 910 struct Print(syn::QSelf); 911 impl Debug for Print { 912 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 913 formatter.write_str("Some(")?; 914 Debug::fmt(Lite(&self.0), formatter)?; 915 formatter.write_str(")")?; 916 Ok(()) 917 } 918 } 919 formatter.field("qself", Print::ref_cast(val)); 920 } 921 formatter.field("path", Lite(&_val.path)); 922 if !_val.fields.is_empty() { 923 formatter.field("fields", Lite(&_val.fields)); 924 } 925 if _val.dot2_token.is_some() { 926 formatter.field("dot2_token", &Present); 927 } 928 if let Some(val) = &_val.rest { 929 #[derive(RefCast)] 930 #[repr(transparent)] 931 struct Print(Box<syn::Expr>); 932 impl Debug for Print { 933 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 934 formatter.write_str("Some(")?; 935 Debug::fmt(Lite(&self.0), formatter)?; 936 formatter.write_str(")")?; 937 Ok(()) 938 } 939 } 940 formatter.field("rest", Print::ref_cast(val)); 941 } 942 formatter.finish() 943 } 944 syn::Expr::Try(_val) => { 945 let mut formatter = formatter.debug_struct("Expr::Try"); 946 if !_val.attrs.is_empty() { 947 formatter.field("attrs", Lite(&_val.attrs)); 948 } 949 formatter.field("expr", Lite(&_val.expr)); 950 formatter.finish() 951 } 952 syn::Expr::TryBlock(_val) => { 953 let mut formatter = formatter.debug_struct("Expr::TryBlock"); 954 if !_val.attrs.is_empty() { 955 formatter.field("attrs", Lite(&_val.attrs)); 956 } 957 formatter.field("block", Lite(&_val.block)); 958 formatter.finish() 959 } 960 syn::Expr::Tuple(_val) => { 961 let mut formatter = formatter.debug_struct("Expr::Tuple"); 962 if !_val.attrs.is_empty() { 963 formatter.field("attrs", Lite(&_val.attrs)); 964 } 965 if !_val.elems.is_empty() { 966 formatter.field("elems", Lite(&_val.elems)); 967 } 968 formatter.finish() 969 } 970 syn::Expr::Unary(_val) => { 971 let mut formatter = formatter.debug_struct("Expr::Unary"); 972 if !_val.attrs.is_empty() { 973 formatter.field("attrs", Lite(&_val.attrs)); 974 } 975 formatter.field("op", Lite(&_val.op)); 976 formatter.field("expr", Lite(&_val.expr)); 977 formatter.finish() 978 } 979 syn::Expr::Unsafe(_val) => { 980 let mut formatter = formatter.debug_struct("Expr::Unsafe"); 981 if !_val.attrs.is_empty() { 982 formatter.field("attrs", Lite(&_val.attrs)); 983 } 984 formatter.field("block", Lite(&_val.block)); 985 formatter.finish() 986 } 987 syn::Expr::Verbatim(_val) => { 988 formatter.write_str("Expr::Verbatim")?; 989 formatter.write_str("(`")?; 990 Display::fmt(_val, formatter)?; 991 formatter.write_str("`)")?; 992 Ok(()) 993 } 994 syn::Expr::While(_val) => { 995 let mut formatter = formatter.debug_struct("Expr::While"); 996 if !_val.attrs.is_empty() { 997 formatter.field("attrs", Lite(&_val.attrs)); 998 } 999 if let Some(val) = &_val.label { 1000 #[derive(RefCast)] 1001 #[repr(transparent)] 1002 struct Print(syn::Label); 1003 impl Debug for Print { 1004 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1005 formatter.write_str("Some(")?; 1006 Debug::fmt(Lite(&self.0), formatter)?; 1007 formatter.write_str(")")?; 1008 Ok(()) 1009 } 1010 } 1011 formatter.field("label", Print::ref_cast(val)); 1012 } 1013 formatter.field("cond", Lite(&_val.cond)); 1014 formatter.field("body", Lite(&_val.body)); 1015 formatter.finish() 1016 } 1017 syn::Expr::Yield(_val) => { 1018 let mut formatter = formatter.debug_struct("Expr::Yield"); 1019 if !_val.attrs.is_empty() { 1020 formatter.field("attrs", Lite(&_val.attrs)); 1021 } 1022 if let Some(val) = &_val.expr { 1023 #[derive(RefCast)] 1024 #[repr(transparent)] 1025 struct Print(Box<syn::Expr>); 1026 impl Debug for Print { 1027 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1028 formatter.write_str("Some(")?; 1029 Debug::fmt(Lite(&self.0), formatter)?; 1030 formatter.write_str(")")?; 1031 Ok(()) 1032 } 1033 } 1034 formatter.field("expr", Print::ref_cast(val)); 1035 } 1036 formatter.finish() 1037 } 1038 _ => unreachable!(), 1039 } 1040 } 1041 } 1042 impl Debug for Lite<syn::ExprArray> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1043 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1044 let mut formatter = formatter.debug_struct("ExprArray"); 1045 if !self.value.attrs.is_empty() { 1046 formatter.field("attrs", Lite(&self.value.attrs)); 1047 } 1048 if !self.value.elems.is_empty() { 1049 formatter.field("elems", Lite(&self.value.elems)); 1050 } 1051 formatter.finish() 1052 } 1053 } 1054 impl Debug for Lite<syn::ExprAssign> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1055 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1056 let mut formatter = formatter.debug_struct("ExprAssign"); 1057 if !self.value.attrs.is_empty() { 1058 formatter.field("attrs", Lite(&self.value.attrs)); 1059 } 1060 formatter.field("left", Lite(&self.value.left)); 1061 formatter.field("right", Lite(&self.value.right)); 1062 formatter.finish() 1063 } 1064 } 1065 impl Debug for Lite<syn::ExprAsync> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1066 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1067 let mut formatter = formatter.debug_struct("ExprAsync"); 1068 if !self.value.attrs.is_empty() { 1069 formatter.field("attrs", Lite(&self.value.attrs)); 1070 } 1071 if self.value.capture.is_some() { 1072 formatter.field("capture", &Present); 1073 } 1074 formatter.field("block", Lite(&self.value.block)); 1075 formatter.finish() 1076 } 1077 } 1078 impl Debug for Lite<syn::ExprAwait> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1079 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1080 let mut formatter = formatter.debug_struct("ExprAwait"); 1081 if !self.value.attrs.is_empty() { 1082 formatter.field("attrs", Lite(&self.value.attrs)); 1083 } 1084 formatter.field("base", Lite(&self.value.base)); 1085 formatter.finish() 1086 } 1087 } 1088 impl Debug for Lite<syn::ExprBinary> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1089 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1090 let mut formatter = formatter.debug_struct("ExprBinary"); 1091 if !self.value.attrs.is_empty() { 1092 formatter.field("attrs", Lite(&self.value.attrs)); 1093 } 1094 formatter.field("left", Lite(&self.value.left)); 1095 formatter.field("op", Lite(&self.value.op)); 1096 formatter.field("right", Lite(&self.value.right)); 1097 formatter.finish() 1098 } 1099 } 1100 impl Debug for Lite<syn::ExprBlock> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1101 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1102 let mut formatter = formatter.debug_struct("ExprBlock"); 1103 if !self.value.attrs.is_empty() { 1104 formatter.field("attrs", Lite(&self.value.attrs)); 1105 } 1106 if let Some(val) = &self.value.label { 1107 #[derive(RefCast)] 1108 #[repr(transparent)] 1109 struct Print(syn::Label); 1110 impl Debug for Print { 1111 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1112 formatter.write_str("Some(")?; 1113 Debug::fmt(Lite(&self.0), formatter)?; 1114 formatter.write_str(")")?; 1115 Ok(()) 1116 } 1117 } 1118 formatter.field("label", Print::ref_cast(val)); 1119 } 1120 formatter.field("block", Lite(&self.value.block)); 1121 formatter.finish() 1122 } 1123 } 1124 impl Debug for Lite<syn::ExprBreak> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1125 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1126 let mut formatter = formatter.debug_struct("ExprBreak"); 1127 if !self.value.attrs.is_empty() { 1128 formatter.field("attrs", Lite(&self.value.attrs)); 1129 } 1130 if let Some(val) = &self.value.label { 1131 #[derive(RefCast)] 1132 #[repr(transparent)] 1133 struct Print(syn::Lifetime); 1134 impl Debug for Print { 1135 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1136 formatter.write_str("Some(")?; 1137 Debug::fmt(Lite(&self.0), formatter)?; 1138 formatter.write_str(")")?; 1139 Ok(()) 1140 } 1141 } 1142 formatter.field("label", Print::ref_cast(val)); 1143 } 1144 if let Some(val) = &self.value.expr { 1145 #[derive(RefCast)] 1146 #[repr(transparent)] 1147 struct Print(Box<syn::Expr>); 1148 impl Debug for Print { 1149 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1150 formatter.write_str("Some(")?; 1151 Debug::fmt(Lite(&self.0), formatter)?; 1152 formatter.write_str(")")?; 1153 Ok(()) 1154 } 1155 } 1156 formatter.field("expr", Print::ref_cast(val)); 1157 } 1158 formatter.finish() 1159 } 1160 } 1161 impl Debug for Lite<syn::ExprCall> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1162 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1163 let mut formatter = formatter.debug_struct("ExprCall"); 1164 if !self.value.attrs.is_empty() { 1165 formatter.field("attrs", Lite(&self.value.attrs)); 1166 } 1167 formatter.field("func", Lite(&self.value.func)); 1168 if !self.value.args.is_empty() { 1169 formatter.field("args", Lite(&self.value.args)); 1170 } 1171 formatter.finish() 1172 } 1173 } 1174 impl Debug for Lite<syn::ExprCast> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1175 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1176 let mut formatter = formatter.debug_struct("ExprCast"); 1177 if !self.value.attrs.is_empty() { 1178 formatter.field("attrs", Lite(&self.value.attrs)); 1179 } 1180 formatter.field("expr", Lite(&self.value.expr)); 1181 formatter.field("ty", Lite(&self.value.ty)); 1182 formatter.finish() 1183 } 1184 } 1185 impl Debug for Lite<syn::ExprClosure> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1186 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1187 let mut formatter = formatter.debug_struct("ExprClosure"); 1188 if !self.value.attrs.is_empty() { 1189 formatter.field("attrs", Lite(&self.value.attrs)); 1190 } 1191 if let Some(val) = &self.value.lifetimes { 1192 #[derive(RefCast)] 1193 #[repr(transparent)] 1194 struct Print(syn::BoundLifetimes); 1195 impl Debug for Print { 1196 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1197 formatter.write_str("Some(")?; 1198 Debug::fmt(Lite(&self.0), formatter)?; 1199 formatter.write_str(")")?; 1200 Ok(()) 1201 } 1202 } 1203 formatter.field("lifetimes", Print::ref_cast(val)); 1204 } 1205 if self.value.constness.is_some() { 1206 formatter.field("constness", &Present); 1207 } 1208 if self.value.movability.is_some() { 1209 formatter.field("movability", &Present); 1210 } 1211 if self.value.asyncness.is_some() { 1212 formatter.field("asyncness", &Present); 1213 } 1214 if self.value.capture.is_some() { 1215 formatter.field("capture", &Present); 1216 } 1217 if !self.value.inputs.is_empty() { 1218 formatter.field("inputs", Lite(&self.value.inputs)); 1219 } 1220 formatter.field("output", Lite(&self.value.output)); 1221 formatter.field("body", Lite(&self.value.body)); 1222 formatter.finish() 1223 } 1224 } 1225 impl Debug for Lite<syn::ExprConst> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1226 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1227 let mut formatter = formatter.debug_struct("ExprConst"); 1228 if !self.value.attrs.is_empty() { 1229 formatter.field("attrs", Lite(&self.value.attrs)); 1230 } 1231 formatter.field("block", Lite(&self.value.block)); 1232 formatter.finish() 1233 } 1234 } 1235 impl Debug for Lite<syn::ExprContinue> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1236 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1237 let mut formatter = formatter.debug_struct("ExprContinue"); 1238 if !self.value.attrs.is_empty() { 1239 formatter.field("attrs", Lite(&self.value.attrs)); 1240 } 1241 if let Some(val) = &self.value.label { 1242 #[derive(RefCast)] 1243 #[repr(transparent)] 1244 struct Print(syn::Lifetime); 1245 impl Debug for Print { 1246 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1247 formatter.write_str("Some(")?; 1248 Debug::fmt(Lite(&self.0), formatter)?; 1249 formatter.write_str(")")?; 1250 Ok(()) 1251 } 1252 } 1253 formatter.field("label", Print::ref_cast(val)); 1254 } 1255 formatter.finish() 1256 } 1257 } 1258 impl Debug for Lite<syn::ExprField> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1259 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1260 let mut formatter = formatter.debug_struct("ExprField"); 1261 if !self.value.attrs.is_empty() { 1262 formatter.field("attrs", Lite(&self.value.attrs)); 1263 } 1264 formatter.field("base", Lite(&self.value.base)); 1265 formatter.field("member", Lite(&self.value.member)); 1266 formatter.finish() 1267 } 1268 } 1269 impl Debug for Lite<syn::ExprForLoop> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1270 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1271 let mut formatter = formatter.debug_struct("ExprForLoop"); 1272 if !self.value.attrs.is_empty() { 1273 formatter.field("attrs", Lite(&self.value.attrs)); 1274 } 1275 if let Some(val) = &self.value.label { 1276 #[derive(RefCast)] 1277 #[repr(transparent)] 1278 struct Print(syn::Label); 1279 impl Debug for Print { 1280 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1281 formatter.write_str("Some(")?; 1282 Debug::fmt(Lite(&self.0), formatter)?; 1283 formatter.write_str(")")?; 1284 Ok(()) 1285 } 1286 } 1287 formatter.field("label", Print::ref_cast(val)); 1288 } 1289 formatter.field("pat", Lite(&self.value.pat)); 1290 formatter.field("expr", Lite(&self.value.expr)); 1291 formatter.field("body", Lite(&self.value.body)); 1292 formatter.finish() 1293 } 1294 } 1295 impl Debug for Lite<syn::ExprGroup> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1296 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1297 let mut formatter = formatter.debug_struct("ExprGroup"); 1298 if !self.value.attrs.is_empty() { 1299 formatter.field("attrs", Lite(&self.value.attrs)); 1300 } 1301 formatter.field("expr", Lite(&self.value.expr)); 1302 formatter.finish() 1303 } 1304 } 1305 impl Debug for Lite<syn::ExprIf> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1306 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1307 let mut formatter = formatter.debug_struct("ExprIf"); 1308 if !self.value.attrs.is_empty() { 1309 formatter.field("attrs", Lite(&self.value.attrs)); 1310 } 1311 formatter.field("cond", Lite(&self.value.cond)); 1312 formatter.field("then_branch", Lite(&self.value.then_branch)); 1313 if let Some(val) = &self.value.else_branch { 1314 #[derive(RefCast)] 1315 #[repr(transparent)] 1316 struct Print((syn::token::Else, Box<syn::Expr>)); 1317 impl Debug for Print { 1318 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1319 formatter.write_str("Some(")?; 1320 Debug::fmt(Lite(&self.0.1), formatter)?; 1321 formatter.write_str(")")?; 1322 Ok(()) 1323 } 1324 } 1325 formatter.field("else_branch", Print::ref_cast(val)); 1326 } 1327 formatter.finish() 1328 } 1329 } 1330 impl Debug for Lite<syn::ExprIndex> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1331 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1332 let mut formatter = formatter.debug_struct("ExprIndex"); 1333 if !self.value.attrs.is_empty() { 1334 formatter.field("attrs", Lite(&self.value.attrs)); 1335 } 1336 formatter.field("expr", Lite(&self.value.expr)); 1337 formatter.field("index", Lite(&self.value.index)); 1338 formatter.finish() 1339 } 1340 } 1341 impl Debug for Lite<syn::ExprInfer> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1342 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1343 let mut formatter = formatter.debug_struct("ExprInfer"); 1344 if !self.value.attrs.is_empty() { 1345 formatter.field("attrs", Lite(&self.value.attrs)); 1346 } 1347 formatter.finish() 1348 } 1349 } 1350 impl Debug for Lite<syn::ExprLet> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1351 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1352 let mut formatter = formatter.debug_struct("ExprLet"); 1353 if !self.value.attrs.is_empty() { 1354 formatter.field("attrs", Lite(&self.value.attrs)); 1355 } 1356 formatter.field("pat", Lite(&self.value.pat)); 1357 formatter.field("expr", Lite(&self.value.expr)); 1358 formatter.finish() 1359 } 1360 } 1361 impl Debug for Lite<syn::ExprLit> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1362 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1363 let mut formatter = formatter.debug_struct("ExprLit"); 1364 if !self.value.attrs.is_empty() { 1365 formatter.field("attrs", Lite(&self.value.attrs)); 1366 } 1367 formatter.field("lit", Lite(&self.value.lit)); 1368 formatter.finish() 1369 } 1370 } 1371 impl Debug for Lite<syn::ExprLoop> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1372 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1373 let mut formatter = formatter.debug_struct("ExprLoop"); 1374 if !self.value.attrs.is_empty() { 1375 formatter.field("attrs", Lite(&self.value.attrs)); 1376 } 1377 if let Some(val) = &self.value.label { 1378 #[derive(RefCast)] 1379 #[repr(transparent)] 1380 struct Print(syn::Label); 1381 impl Debug for Print { 1382 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1383 formatter.write_str("Some(")?; 1384 Debug::fmt(Lite(&self.0), formatter)?; 1385 formatter.write_str(")")?; 1386 Ok(()) 1387 } 1388 } 1389 formatter.field("label", Print::ref_cast(val)); 1390 } 1391 formatter.field("body", Lite(&self.value.body)); 1392 formatter.finish() 1393 } 1394 } 1395 impl Debug for Lite<syn::ExprMacro> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1396 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1397 let mut formatter = formatter.debug_struct("ExprMacro"); 1398 if !self.value.attrs.is_empty() { 1399 formatter.field("attrs", Lite(&self.value.attrs)); 1400 } 1401 formatter.field("mac", Lite(&self.value.mac)); 1402 formatter.finish() 1403 } 1404 } 1405 impl Debug for Lite<syn::ExprMatch> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1406 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1407 let mut formatter = formatter.debug_struct("ExprMatch"); 1408 if !self.value.attrs.is_empty() { 1409 formatter.field("attrs", Lite(&self.value.attrs)); 1410 } 1411 formatter.field("expr", Lite(&self.value.expr)); 1412 if !self.value.arms.is_empty() { 1413 formatter.field("arms", Lite(&self.value.arms)); 1414 } 1415 formatter.finish() 1416 } 1417 } 1418 impl Debug for Lite<syn::ExprMethodCall> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1419 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1420 let mut formatter = formatter.debug_struct("ExprMethodCall"); 1421 if !self.value.attrs.is_empty() { 1422 formatter.field("attrs", Lite(&self.value.attrs)); 1423 } 1424 formatter.field("receiver", Lite(&self.value.receiver)); 1425 formatter.field("method", Lite(&self.value.method)); 1426 if let Some(val) = &self.value.turbofish { 1427 #[derive(RefCast)] 1428 #[repr(transparent)] 1429 struct Print(syn::AngleBracketedGenericArguments); 1430 impl Debug for Print { 1431 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1432 formatter.write_str("Some(")?; 1433 Debug::fmt(Lite(&self.0), formatter)?; 1434 formatter.write_str(")")?; 1435 Ok(()) 1436 } 1437 } 1438 formatter.field("turbofish", Print::ref_cast(val)); 1439 } 1440 if !self.value.args.is_empty() { 1441 formatter.field("args", Lite(&self.value.args)); 1442 } 1443 formatter.finish() 1444 } 1445 } 1446 impl Debug for Lite<syn::ExprParen> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1447 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1448 let mut formatter = formatter.debug_struct("ExprParen"); 1449 if !self.value.attrs.is_empty() { 1450 formatter.field("attrs", Lite(&self.value.attrs)); 1451 } 1452 formatter.field("expr", Lite(&self.value.expr)); 1453 formatter.finish() 1454 } 1455 } 1456 impl Debug for Lite<syn::ExprPath> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1457 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1458 let mut formatter = formatter.debug_struct("ExprPath"); 1459 if !self.value.attrs.is_empty() { 1460 formatter.field("attrs", Lite(&self.value.attrs)); 1461 } 1462 if let Some(val) = &self.value.qself { 1463 #[derive(RefCast)] 1464 #[repr(transparent)] 1465 struct Print(syn::QSelf); 1466 impl Debug for Print { 1467 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1468 formatter.write_str("Some(")?; 1469 Debug::fmt(Lite(&self.0), formatter)?; 1470 formatter.write_str(")")?; 1471 Ok(()) 1472 } 1473 } 1474 formatter.field("qself", Print::ref_cast(val)); 1475 } 1476 formatter.field("path", Lite(&self.value.path)); 1477 formatter.finish() 1478 } 1479 } 1480 impl Debug for Lite<syn::ExprRange> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1481 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1482 let mut formatter = formatter.debug_struct("ExprRange"); 1483 if !self.value.attrs.is_empty() { 1484 formatter.field("attrs", Lite(&self.value.attrs)); 1485 } 1486 if let Some(val) = &self.value.start { 1487 #[derive(RefCast)] 1488 #[repr(transparent)] 1489 struct Print(Box<syn::Expr>); 1490 impl Debug for Print { 1491 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1492 formatter.write_str("Some(")?; 1493 Debug::fmt(Lite(&self.0), formatter)?; 1494 formatter.write_str(")")?; 1495 Ok(()) 1496 } 1497 } 1498 formatter.field("start", Print::ref_cast(val)); 1499 } 1500 formatter.field("limits", Lite(&self.value.limits)); 1501 if let Some(val) = &self.value.end { 1502 #[derive(RefCast)] 1503 #[repr(transparent)] 1504 struct Print(Box<syn::Expr>); 1505 impl Debug for Print { 1506 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1507 formatter.write_str("Some(")?; 1508 Debug::fmt(Lite(&self.0), formatter)?; 1509 formatter.write_str(")")?; 1510 Ok(()) 1511 } 1512 } 1513 formatter.field("end", Print::ref_cast(val)); 1514 } 1515 formatter.finish() 1516 } 1517 } 1518 impl Debug for Lite<syn::ExprReference> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1519 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1520 let mut formatter = formatter.debug_struct("ExprReference"); 1521 if !self.value.attrs.is_empty() { 1522 formatter.field("attrs", Lite(&self.value.attrs)); 1523 } 1524 if self.value.mutability.is_some() { 1525 formatter.field("mutability", &Present); 1526 } 1527 formatter.field("expr", Lite(&self.value.expr)); 1528 formatter.finish() 1529 } 1530 } 1531 impl Debug for Lite<syn::ExprRepeat> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1532 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1533 let mut formatter = formatter.debug_struct("ExprRepeat"); 1534 if !self.value.attrs.is_empty() { 1535 formatter.field("attrs", Lite(&self.value.attrs)); 1536 } 1537 formatter.field("expr", Lite(&self.value.expr)); 1538 formatter.field("len", Lite(&self.value.len)); 1539 formatter.finish() 1540 } 1541 } 1542 impl Debug for Lite<syn::ExprReturn> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1543 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1544 let mut formatter = formatter.debug_struct("ExprReturn"); 1545 if !self.value.attrs.is_empty() { 1546 formatter.field("attrs", Lite(&self.value.attrs)); 1547 } 1548 if let Some(val) = &self.value.expr { 1549 #[derive(RefCast)] 1550 #[repr(transparent)] 1551 struct Print(Box<syn::Expr>); 1552 impl Debug for Print { 1553 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1554 formatter.write_str("Some(")?; 1555 Debug::fmt(Lite(&self.0), formatter)?; 1556 formatter.write_str(")")?; 1557 Ok(()) 1558 } 1559 } 1560 formatter.field("expr", Print::ref_cast(val)); 1561 } 1562 formatter.finish() 1563 } 1564 } 1565 impl Debug for Lite<syn::ExprStruct> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1566 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1567 let mut formatter = formatter.debug_struct("ExprStruct"); 1568 if !self.value.attrs.is_empty() { 1569 formatter.field("attrs", Lite(&self.value.attrs)); 1570 } 1571 if let Some(val) = &self.value.qself { 1572 #[derive(RefCast)] 1573 #[repr(transparent)] 1574 struct Print(syn::QSelf); 1575 impl Debug for Print { 1576 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1577 formatter.write_str("Some(")?; 1578 Debug::fmt(Lite(&self.0), formatter)?; 1579 formatter.write_str(")")?; 1580 Ok(()) 1581 } 1582 } 1583 formatter.field("qself", Print::ref_cast(val)); 1584 } 1585 formatter.field("path", Lite(&self.value.path)); 1586 if !self.value.fields.is_empty() { 1587 formatter.field("fields", Lite(&self.value.fields)); 1588 } 1589 if self.value.dot2_token.is_some() { 1590 formatter.field("dot2_token", &Present); 1591 } 1592 if let Some(val) = &self.value.rest { 1593 #[derive(RefCast)] 1594 #[repr(transparent)] 1595 struct Print(Box<syn::Expr>); 1596 impl Debug for Print { 1597 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1598 formatter.write_str("Some(")?; 1599 Debug::fmt(Lite(&self.0), formatter)?; 1600 formatter.write_str(")")?; 1601 Ok(()) 1602 } 1603 } 1604 formatter.field("rest", Print::ref_cast(val)); 1605 } 1606 formatter.finish() 1607 } 1608 } 1609 impl Debug for Lite<syn::ExprTry> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1610 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1611 let mut formatter = formatter.debug_struct("ExprTry"); 1612 if !self.value.attrs.is_empty() { 1613 formatter.field("attrs", Lite(&self.value.attrs)); 1614 } 1615 formatter.field("expr", Lite(&self.value.expr)); 1616 formatter.finish() 1617 } 1618 } 1619 impl Debug for Lite<syn::ExprTryBlock> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1620 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1621 let mut formatter = formatter.debug_struct("ExprTryBlock"); 1622 if !self.value.attrs.is_empty() { 1623 formatter.field("attrs", Lite(&self.value.attrs)); 1624 } 1625 formatter.field("block", Lite(&self.value.block)); 1626 formatter.finish() 1627 } 1628 } 1629 impl Debug for Lite<syn::ExprTuple> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1630 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1631 let mut formatter = formatter.debug_struct("ExprTuple"); 1632 if !self.value.attrs.is_empty() { 1633 formatter.field("attrs", Lite(&self.value.attrs)); 1634 } 1635 if !self.value.elems.is_empty() { 1636 formatter.field("elems", Lite(&self.value.elems)); 1637 } 1638 formatter.finish() 1639 } 1640 } 1641 impl Debug for Lite<syn::ExprUnary> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1642 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1643 let mut formatter = formatter.debug_struct("ExprUnary"); 1644 if !self.value.attrs.is_empty() { 1645 formatter.field("attrs", Lite(&self.value.attrs)); 1646 } 1647 formatter.field("op", Lite(&self.value.op)); 1648 formatter.field("expr", Lite(&self.value.expr)); 1649 formatter.finish() 1650 } 1651 } 1652 impl Debug for Lite<syn::ExprUnsafe> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1653 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1654 let mut formatter = formatter.debug_struct("ExprUnsafe"); 1655 if !self.value.attrs.is_empty() { 1656 formatter.field("attrs", Lite(&self.value.attrs)); 1657 } 1658 formatter.field("block", Lite(&self.value.block)); 1659 formatter.finish() 1660 } 1661 } 1662 impl Debug for Lite<syn::ExprWhile> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1663 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1664 let mut formatter = formatter.debug_struct("ExprWhile"); 1665 if !self.value.attrs.is_empty() { 1666 formatter.field("attrs", Lite(&self.value.attrs)); 1667 } 1668 if let Some(val) = &self.value.label { 1669 #[derive(RefCast)] 1670 #[repr(transparent)] 1671 struct Print(syn::Label); 1672 impl Debug for Print { 1673 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1674 formatter.write_str("Some(")?; 1675 Debug::fmt(Lite(&self.0), formatter)?; 1676 formatter.write_str(")")?; 1677 Ok(()) 1678 } 1679 } 1680 formatter.field("label", Print::ref_cast(val)); 1681 } 1682 formatter.field("cond", Lite(&self.value.cond)); 1683 formatter.field("body", Lite(&self.value.body)); 1684 formatter.finish() 1685 } 1686 } 1687 impl Debug for Lite<syn::ExprYield> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1688 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1689 let mut formatter = formatter.debug_struct("ExprYield"); 1690 if !self.value.attrs.is_empty() { 1691 formatter.field("attrs", Lite(&self.value.attrs)); 1692 } 1693 if let Some(val) = &self.value.expr { 1694 #[derive(RefCast)] 1695 #[repr(transparent)] 1696 struct Print(Box<syn::Expr>); 1697 impl Debug for Print { 1698 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1699 formatter.write_str("Some(")?; 1700 Debug::fmt(Lite(&self.0), formatter)?; 1701 formatter.write_str(")")?; 1702 Ok(()) 1703 } 1704 } 1705 formatter.field("expr", Print::ref_cast(val)); 1706 } 1707 formatter.finish() 1708 } 1709 } 1710 impl Debug for Lite<syn::Field> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1711 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1712 let mut formatter = formatter.debug_struct("Field"); 1713 if !self.value.attrs.is_empty() { 1714 formatter.field("attrs", Lite(&self.value.attrs)); 1715 } 1716 formatter.field("vis", Lite(&self.value.vis)); 1717 match self.value.mutability { 1718 syn::FieldMutability::None => {} 1719 _ => { 1720 formatter.field("mutability", Lite(&self.value.mutability)); 1721 } 1722 } 1723 if let Some(val) = &self.value.ident { 1724 #[derive(RefCast)] 1725 #[repr(transparent)] 1726 struct Print(proc_macro2::Ident); 1727 impl Debug for Print { 1728 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1729 formatter.write_str("Some(")?; 1730 Debug::fmt(Lite(&self.0), formatter)?; 1731 formatter.write_str(")")?; 1732 Ok(()) 1733 } 1734 } 1735 formatter.field("ident", Print::ref_cast(val)); 1736 } 1737 if self.value.colon_token.is_some() { 1738 formatter.field("colon_token", &Present); 1739 } 1740 formatter.field("ty", Lite(&self.value.ty)); 1741 formatter.finish() 1742 } 1743 } 1744 impl Debug for Lite<syn::FieldMutability> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1745 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1746 match &self.value { 1747 syn::FieldMutability::None => formatter.write_str("FieldMutability::None"), 1748 _ => unreachable!(), 1749 } 1750 } 1751 } 1752 impl Debug for Lite<syn::FieldPat> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1753 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1754 let mut formatter = formatter.debug_struct("FieldPat"); 1755 if !self.value.attrs.is_empty() { 1756 formatter.field("attrs", Lite(&self.value.attrs)); 1757 } 1758 formatter.field("member", Lite(&self.value.member)); 1759 if self.value.colon_token.is_some() { 1760 formatter.field("colon_token", &Present); 1761 } 1762 formatter.field("pat", Lite(&self.value.pat)); 1763 formatter.finish() 1764 } 1765 } 1766 impl Debug for Lite<syn::FieldValue> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1767 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1768 let mut formatter = formatter.debug_struct("FieldValue"); 1769 if !self.value.attrs.is_empty() { 1770 formatter.field("attrs", Lite(&self.value.attrs)); 1771 } 1772 formatter.field("member", Lite(&self.value.member)); 1773 if self.value.colon_token.is_some() { 1774 formatter.field("colon_token", &Present); 1775 } 1776 formatter.field("expr", Lite(&self.value.expr)); 1777 formatter.finish() 1778 } 1779 } 1780 impl Debug for Lite<syn::Fields> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1781 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1782 match &self.value { 1783 syn::Fields::Named(_val) => { 1784 let mut formatter = formatter.debug_struct("Fields::Named"); 1785 if !_val.named.is_empty() { 1786 formatter.field("named", Lite(&_val.named)); 1787 } 1788 formatter.finish() 1789 } 1790 syn::Fields::Unnamed(_val) => { 1791 let mut formatter = formatter.debug_struct("Fields::Unnamed"); 1792 if !_val.unnamed.is_empty() { 1793 formatter.field("unnamed", Lite(&_val.unnamed)); 1794 } 1795 formatter.finish() 1796 } 1797 syn::Fields::Unit => formatter.write_str("Fields::Unit"), 1798 } 1799 } 1800 } 1801 impl Debug for Lite<syn::FieldsNamed> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1802 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1803 let mut formatter = formatter.debug_struct("FieldsNamed"); 1804 if !self.value.named.is_empty() { 1805 formatter.field("named", Lite(&self.value.named)); 1806 } 1807 formatter.finish() 1808 } 1809 } 1810 impl Debug for Lite<syn::FieldsUnnamed> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1811 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1812 let mut formatter = formatter.debug_struct("FieldsUnnamed"); 1813 if !self.value.unnamed.is_empty() { 1814 formatter.field("unnamed", Lite(&self.value.unnamed)); 1815 } 1816 formatter.finish() 1817 } 1818 } 1819 impl Debug for Lite<syn::File> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1820 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1821 let mut formatter = formatter.debug_struct("File"); 1822 if let Some(val) = &self.value.shebang { 1823 #[derive(RefCast)] 1824 #[repr(transparent)] 1825 struct Print(String); 1826 impl Debug for Print { 1827 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1828 formatter.write_str("Some(")?; 1829 Debug::fmt(Lite(&self.0), formatter)?; 1830 formatter.write_str(")")?; 1831 Ok(()) 1832 } 1833 } 1834 formatter.field("shebang", Print::ref_cast(val)); 1835 } 1836 if !self.value.attrs.is_empty() { 1837 formatter.field("attrs", Lite(&self.value.attrs)); 1838 } 1839 if !self.value.items.is_empty() { 1840 formatter.field("items", Lite(&self.value.items)); 1841 } 1842 formatter.finish() 1843 } 1844 } 1845 impl Debug for Lite<syn::FnArg> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1846 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1847 match &self.value { 1848 syn::FnArg::Receiver(_val) => { 1849 formatter.write_str("FnArg::Receiver")?; 1850 formatter.write_str("(")?; 1851 Debug::fmt(Lite(_val), formatter)?; 1852 formatter.write_str(")")?; 1853 Ok(()) 1854 } 1855 syn::FnArg::Typed(_val) => { 1856 formatter.write_str("FnArg::Typed")?; 1857 formatter.write_str("(")?; 1858 Debug::fmt(Lite(_val), formatter)?; 1859 formatter.write_str(")")?; 1860 Ok(()) 1861 } 1862 } 1863 } 1864 } 1865 impl Debug for Lite<syn::ForeignItem> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1866 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1867 match &self.value { 1868 syn::ForeignItem::Fn(_val) => { 1869 let mut formatter = formatter.debug_struct("ForeignItem::Fn"); 1870 if !_val.attrs.is_empty() { 1871 formatter.field("attrs", Lite(&_val.attrs)); 1872 } 1873 formatter.field("vis", Lite(&_val.vis)); 1874 formatter.field("sig", Lite(&_val.sig)); 1875 formatter.finish() 1876 } 1877 syn::ForeignItem::Static(_val) => { 1878 let mut formatter = formatter.debug_struct("ForeignItem::Static"); 1879 if !_val.attrs.is_empty() { 1880 formatter.field("attrs", Lite(&_val.attrs)); 1881 } 1882 formatter.field("vis", Lite(&_val.vis)); 1883 match _val.mutability { 1884 syn::StaticMutability::None => {} 1885 _ => { 1886 formatter.field("mutability", Lite(&_val.mutability)); 1887 } 1888 } 1889 formatter.field("ident", Lite(&_val.ident)); 1890 formatter.field("ty", Lite(&_val.ty)); 1891 formatter.finish() 1892 } 1893 syn::ForeignItem::Type(_val) => { 1894 let mut formatter = formatter.debug_struct("ForeignItem::Type"); 1895 if !_val.attrs.is_empty() { 1896 formatter.field("attrs", Lite(&_val.attrs)); 1897 } 1898 formatter.field("vis", Lite(&_val.vis)); 1899 formatter.field("ident", Lite(&_val.ident)); 1900 formatter.field("generics", Lite(&_val.generics)); 1901 formatter.finish() 1902 } 1903 syn::ForeignItem::Macro(_val) => { 1904 let mut formatter = formatter.debug_struct("ForeignItem::Macro"); 1905 if !_val.attrs.is_empty() { 1906 formatter.field("attrs", Lite(&_val.attrs)); 1907 } 1908 formatter.field("mac", Lite(&_val.mac)); 1909 if _val.semi_token.is_some() { 1910 formatter.field("semi_token", &Present); 1911 } 1912 formatter.finish() 1913 } 1914 syn::ForeignItem::Verbatim(_val) => { 1915 formatter.write_str("ForeignItem::Verbatim")?; 1916 formatter.write_str("(`")?; 1917 Display::fmt(_val, formatter)?; 1918 formatter.write_str("`)")?; 1919 Ok(()) 1920 } 1921 _ => unreachable!(), 1922 } 1923 } 1924 } 1925 impl Debug for Lite<syn::ForeignItemFn> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1926 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1927 let mut formatter = formatter.debug_struct("ForeignItemFn"); 1928 if !self.value.attrs.is_empty() { 1929 formatter.field("attrs", Lite(&self.value.attrs)); 1930 } 1931 formatter.field("vis", Lite(&self.value.vis)); 1932 formatter.field("sig", Lite(&self.value.sig)); 1933 formatter.finish() 1934 } 1935 } 1936 impl Debug for Lite<syn::ForeignItemMacro> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1937 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1938 let mut formatter = formatter.debug_struct("ForeignItemMacro"); 1939 if !self.value.attrs.is_empty() { 1940 formatter.field("attrs", Lite(&self.value.attrs)); 1941 } 1942 formatter.field("mac", Lite(&self.value.mac)); 1943 if self.value.semi_token.is_some() { 1944 formatter.field("semi_token", &Present); 1945 } 1946 formatter.finish() 1947 } 1948 } 1949 impl Debug for Lite<syn::ForeignItemStatic> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1950 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1951 let mut formatter = formatter.debug_struct("ForeignItemStatic"); 1952 if !self.value.attrs.is_empty() { 1953 formatter.field("attrs", Lite(&self.value.attrs)); 1954 } 1955 formatter.field("vis", Lite(&self.value.vis)); 1956 match self.value.mutability { 1957 syn::StaticMutability::None => {} 1958 _ => { 1959 formatter.field("mutability", Lite(&self.value.mutability)); 1960 } 1961 } 1962 formatter.field("ident", Lite(&self.value.ident)); 1963 formatter.field("ty", Lite(&self.value.ty)); 1964 formatter.finish() 1965 } 1966 } 1967 impl Debug for Lite<syn::ForeignItemType> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1968 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1969 let mut formatter = formatter.debug_struct("ForeignItemType"); 1970 if !self.value.attrs.is_empty() { 1971 formatter.field("attrs", Lite(&self.value.attrs)); 1972 } 1973 formatter.field("vis", Lite(&self.value.vis)); 1974 formatter.field("ident", Lite(&self.value.ident)); 1975 formatter.field("generics", Lite(&self.value.generics)); 1976 formatter.finish() 1977 } 1978 } 1979 impl Debug for Lite<syn::GenericArgument> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result1980 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1981 match &self.value { 1982 syn::GenericArgument::Lifetime(_val) => { 1983 formatter.write_str("GenericArgument::Lifetime")?; 1984 formatter.write_str("(")?; 1985 Debug::fmt(Lite(_val), formatter)?; 1986 formatter.write_str(")")?; 1987 Ok(()) 1988 } 1989 syn::GenericArgument::Type(_val) => { 1990 formatter.write_str("GenericArgument::Type")?; 1991 formatter.write_str("(")?; 1992 Debug::fmt(Lite(_val), formatter)?; 1993 formatter.write_str(")")?; 1994 Ok(()) 1995 } 1996 syn::GenericArgument::Const(_val) => { 1997 formatter.write_str("GenericArgument::Const")?; 1998 formatter.write_str("(")?; 1999 Debug::fmt(Lite(_val), formatter)?; 2000 formatter.write_str(")")?; 2001 Ok(()) 2002 } 2003 syn::GenericArgument::AssocType(_val) => { 2004 formatter.write_str("GenericArgument::AssocType")?; 2005 formatter.write_str("(")?; 2006 Debug::fmt(Lite(_val), formatter)?; 2007 formatter.write_str(")")?; 2008 Ok(()) 2009 } 2010 syn::GenericArgument::AssocConst(_val) => { 2011 formatter.write_str("GenericArgument::AssocConst")?; 2012 formatter.write_str("(")?; 2013 Debug::fmt(Lite(_val), formatter)?; 2014 formatter.write_str(")")?; 2015 Ok(()) 2016 } 2017 syn::GenericArgument::Constraint(_val) => { 2018 formatter.write_str("GenericArgument::Constraint")?; 2019 formatter.write_str("(")?; 2020 Debug::fmt(Lite(_val), formatter)?; 2021 formatter.write_str(")")?; 2022 Ok(()) 2023 } 2024 _ => unreachable!(), 2025 } 2026 } 2027 } 2028 impl Debug for Lite<syn::GenericParam> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2029 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2030 match &self.value { 2031 syn::GenericParam::Lifetime(_val) => { 2032 formatter.write_str("GenericParam::Lifetime")?; 2033 formatter.write_str("(")?; 2034 Debug::fmt(Lite(_val), formatter)?; 2035 formatter.write_str(")")?; 2036 Ok(()) 2037 } 2038 syn::GenericParam::Type(_val) => { 2039 formatter.write_str("GenericParam::Type")?; 2040 formatter.write_str("(")?; 2041 Debug::fmt(Lite(_val), formatter)?; 2042 formatter.write_str(")")?; 2043 Ok(()) 2044 } 2045 syn::GenericParam::Const(_val) => { 2046 formatter.write_str("GenericParam::Const")?; 2047 formatter.write_str("(")?; 2048 Debug::fmt(Lite(_val), formatter)?; 2049 formatter.write_str(")")?; 2050 Ok(()) 2051 } 2052 } 2053 } 2054 } 2055 impl Debug for Lite<syn::Generics> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2056 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2057 let mut formatter = formatter.debug_struct("Generics"); 2058 if self.value.lt_token.is_some() { 2059 formatter.field("lt_token", &Present); 2060 } 2061 if !self.value.params.is_empty() { 2062 formatter.field("params", Lite(&self.value.params)); 2063 } 2064 if self.value.gt_token.is_some() { 2065 formatter.field("gt_token", &Present); 2066 } 2067 if let Some(val) = &self.value.where_clause { 2068 #[derive(RefCast)] 2069 #[repr(transparent)] 2070 struct Print(syn::WhereClause); 2071 impl Debug for Print { 2072 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2073 formatter.write_str("Some(")?; 2074 Debug::fmt(Lite(&self.0), formatter)?; 2075 formatter.write_str(")")?; 2076 Ok(()) 2077 } 2078 } 2079 formatter.field("where_clause", Print::ref_cast(val)); 2080 } 2081 formatter.finish() 2082 } 2083 } 2084 impl Debug for Lite<syn::ImplItem> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2085 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2086 match &self.value { 2087 syn::ImplItem::Const(_val) => { 2088 let mut formatter = formatter.debug_struct("ImplItem::Const"); 2089 if !_val.attrs.is_empty() { 2090 formatter.field("attrs", Lite(&_val.attrs)); 2091 } 2092 formatter.field("vis", Lite(&_val.vis)); 2093 if _val.defaultness.is_some() { 2094 formatter.field("defaultness", &Present); 2095 } 2096 formatter.field("ident", Lite(&_val.ident)); 2097 formatter.field("generics", Lite(&_val.generics)); 2098 formatter.field("ty", Lite(&_val.ty)); 2099 formatter.field("expr", Lite(&_val.expr)); 2100 formatter.finish() 2101 } 2102 syn::ImplItem::Fn(_val) => { 2103 let mut formatter = formatter.debug_struct("ImplItem::Fn"); 2104 if !_val.attrs.is_empty() { 2105 formatter.field("attrs", Lite(&_val.attrs)); 2106 } 2107 formatter.field("vis", Lite(&_val.vis)); 2108 if _val.defaultness.is_some() { 2109 formatter.field("defaultness", &Present); 2110 } 2111 formatter.field("sig", Lite(&_val.sig)); 2112 formatter.field("block", Lite(&_val.block)); 2113 formatter.finish() 2114 } 2115 syn::ImplItem::Type(_val) => { 2116 let mut formatter = formatter.debug_struct("ImplItem::Type"); 2117 if !_val.attrs.is_empty() { 2118 formatter.field("attrs", Lite(&_val.attrs)); 2119 } 2120 formatter.field("vis", Lite(&_val.vis)); 2121 if _val.defaultness.is_some() { 2122 formatter.field("defaultness", &Present); 2123 } 2124 formatter.field("ident", Lite(&_val.ident)); 2125 formatter.field("generics", Lite(&_val.generics)); 2126 formatter.field("ty", Lite(&_val.ty)); 2127 formatter.finish() 2128 } 2129 syn::ImplItem::Macro(_val) => { 2130 let mut formatter = formatter.debug_struct("ImplItem::Macro"); 2131 if !_val.attrs.is_empty() { 2132 formatter.field("attrs", Lite(&_val.attrs)); 2133 } 2134 formatter.field("mac", Lite(&_val.mac)); 2135 if _val.semi_token.is_some() { 2136 formatter.field("semi_token", &Present); 2137 } 2138 formatter.finish() 2139 } 2140 syn::ImplItem::Verbatim(_val) => { 2141 formatter.write_str("ImplItem::Verbatim")?; 2142 formatter.write_str("(`")?; 2143 Display::fmt(_val, formatter)?; 2144 formatter.write_str("`)")?; 2145 Ok(()) 2146 } 2147 _ => unreachable!(), 2148 } 2149 } 2150 } 2151 impl Debug for Lite<syn::ImplItemConst> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2152 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2153 let mut formatter = formatter.debug_struct("ImplItemConst"); 2154 if !self.value.attrs.is_empty() { 2155 formatter.field("attrs", Lite(&self.value.attrs)); 2156 } 2157 formatter.field("vis", Lite(&self.value.vis)); 2158 if self.value.defaultness.is_some() { 2159 formatter.field("defaultness", &Present); 2160 } 2161 formatter.field("ident", Lite(&self.value.ident)); 2162 formatter.field("generics", Lite(&self.value.generics)); 2163 formatter.field("ty", Lite(&self.value.ty)); 2164 formatter.field("expr", Lite(&self.value.expr)); 2165 formatter.finish() 2166 } 2167 } 2168 impl Debug for Lite<syn::ImplItemFn> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2169 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2170 let mut formatter = formatter.debug_struct("ImplItemFn"); 2171 if !self.value.attrs.is_empty() { 2172 formatter.field("attrs", Lite(&self.value.attrs)); 2173 } 2174 formatter.field("vis", Lite(&self.value.vis)); 2175 if self.value.defaultness.is_some() { 2176 formatter.field("defaultness", &Present); 2177 } 2178 formatter.field("sig", Lite(&self.value.sig)); 2179 formatter.field("block", Lite(&self.value.block)); 2180 formatter.finish() 2181 } 2182 } 2183 impl Debug for Lite<syn::ImplItemMacro> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2184 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2185 let mut formatter = formatter.debug_struct("ImplItemMacro"); 2186 if !self.value.attrs.is_empty() { 2187 formatter.field("attrs", Lite(&self.value.attrs)); 2188 } 2189 formatter.field("mac", Lite(&self.value.mac)); 2190 if self.value.semi_token.is_some() { 2191 formatter.field("semi_token", &Present); 2192 } 2193 formatter.finish() 2194 } 2195 } 2196 impl Debug for Lite<syn::ImplItemType> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2197 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2198 let mut formatter = formatter.debug_struct("ImplItemType"); 2199 if !self.value.attrs.is_empty() { 2200 formatter.field("attrs", Lite(&self.value.attrs)); 2201 } 2202 formatter.field("vis", Lite(&self.value.vis)); 2203 if self.value.defaultness.is_some() { 2204 formatter.field("defaultness", &Present); 2205 } 2206 formatter.field("ident", Lite(&self.value.ident)); 2207 formatter.field("generics", Lite(&self.value.generics)); 2208 formatter.field("ty", Lite(&self.value.ty)); 2209 formatter.finish() 2210 } 2211 } 2212 impl Debug for Lite<syn::ImplRestriction> { fmt(&self, _formatter: &mut fmt::Formatter) -> fmt::Result2213 fn fmt(&self, _formatter: &mut fmt::Formatter) -> fmt::Result { 2214 unreachable!() 2215 } 2216 } 2217 impl Debug for Lite<syn::Index> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2218 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2219 let mut formatter = formatter.debug_struct("Index"); 2220 formatter.field("index", Lite(&self.value.index)); 2221 formatter.finish() 2222 } 2223 } 2224 impl Debug for Lite<syn::Item> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2225 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2226 match &self.value { 2227 syn::Item::Const(_val) => { 2228 let mut formatter = formatter.debug_struct("Item::Const"); 2229 if !_val.attrs.is_empty() { 2230 formatter.field("attrs", Lite(&_val.attrs)); 2231 } 2232 formatter.field("vis", Lite(&_val.vis)); 2233 formatter.field("ident", Lite(&_val.ident)); 2234 formatter.field("generics", Lite(&_val.generics)); 2235 formatter.field("ty", Lite(&_val.ty)); 2236 formatter.field("expr", Lite(&_val.expr)); 2237 formatter.finish() 2238 } 2239 syn::Item::Enum(_val) => { 2240 let mut formatter = formatter.debug_struct("Item::Enum"); 2241 if !_val.attrs.is_empty() { 2242 formatter.field("attrs", Lite(&_val.attrs)); 2243 } 2244 formatter.field("vis", Lite(&_val.vis)); 2245 formatter.field("ident", Lite(&_val.ident)); 2246 formatter.field("generics", Lite(&_val.generics)); 2247 if !_val.variants.is_empty() { 2248 formatter.field("variants", Lite(&_val.variants)); 2249 } 2250 formatter.finish() 2251 } 2252 syn::Item::ExternCrate(_val) => { 2253 let mut formatter = formatter.debug_struct("Item::ExternCrate"); 2254 if !_val.attrs.is_empty() { 2255 formatter.field("attrs", Lite(&_val.attrs)); 2256 } 2257 formatter.field("vis", Lite(&_val.vis)); 2258 formatter.field("ident", Lite(&_val.ident)); 2259 if let Some(val) = &_val.rename { 2260 #[derive(RefCast)] 2261 #[repr(transparent)] 2262 struct Print((syn::token::As, proc_macro2::Ident)); 2263 impl Debug for Print { 2264 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2265 formatter.write_str("Some(")?; 2266 Debug::fmt(Lite(&self.0.1), formatter)?; 2267 formatter.write_str(")")?; 2268 Ok(()) 2269 } 2270 } 2271 formatter.field("rename", Print::ref_cast(val)); 2272 } 2273 formatter.finish() 2274 } 2275 syn::Item::Fn(_val) => { 2276 let mut formatter = formatter.debug_struct("Item::Fn"); 2277 if !_val.attrs.is_empty() { 2278 formatter.field("attrs", Lite(&_val.attrs)); 2279 } 2280 formatter.field("vis", Lite(&_val.vis)); 2281 formatter.field("sig", Lite(&_val.sig)); 2282 formatter.field("block", Lite(&_val.block)); 2283 formatter.finish() 2284 } 2285 syn::Item::ForeignMod(_val) => { 2286 let mut formatter = formatter.debug_struct("Item::ForeignMod"); 2287 if !_val.attrs.is_empty() { 2288 formatter.field("attrs", Lite(&_val.attrs)); 2289 } 2290 if _val.unsafety.is_some() { 2291 formatter.field("unsafety", &Present); 2292 } 2293 formatter.field("abi", Lite(&_val.abi)); 2294 if !_val.items.is_empty() { 2295 formatter.field("items", Lite(&_val.items)); 2296 } 2297 formatter.finish() 2298 } 2299 syn::Item::Impl(_val) => { 2300 let mut formatter = formatter.debug_struct("Item::Impl"); 2301 if !_val.attrs.is_empty() { 2302 formatter.field("attrs", Lite(&_val.attrs)); 2303 } 2304 if _val.defaultness.is_some() { 2305 formatter.field("defaultness", &Present); 2306 } 2307 if _val.unsafety.is_some() { 2308 formatter.field("unsafety", &Present); 2309 } 2310 formatter.field("generics", Lite(&_val.generics)); 2311 if let Some(val) = &_val.trait_ { 2312 #[derive(RefCast)] 2313 #[repr(transparent)] 2314 struct Print((Option<syn::token::Not>, syn::Path, syn::token::For)); 2315 impl Debug for Print { 2316 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2317 formatter.write_str("Some(")?; 2318 Debug::fmt( 2319 &( 2320 &super::Option { 2321 present: self.0.0.is_some(), 2322 }, 2323 Lite(&self.0.1), 2324 ), 2325 formatter, 2326 )?; 2327 formatter.write_str(")")?; 2328 Ok(()) 2329 } 2330 } 2331 formatter.field("trait_", Print::ref_cast(val)); 2332 } 2333 formatter.field("self_ty", Lite(&_val.self_ty)); 2334 if !_val.items.is_empty() { 2335 formatter.field("items", Lite(&_val.items)); 2336 } 2337 formatter.finish() 2338 } 2339 syn::Item::Macro(_val) => { 2340 let mut formatter = formatter.debug_struct("Item::Macro"); 2341 if !_val.attrs.is_empty() { 2342 formatter.field("attrs", Lite(&_val.attrs)); 2343 } 2344 if let Some(val) = &_val.ident { 2345 #[derive(RefCast)] 2346 #[repr(transparent)] 2347 struct Print(proc_macro2::Ident); 2348 impl Debug for Print { 2349 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2350 formatter.write_str("Some(")?; 2351 Debug::fmt(Lite(&self.0), formatter)?; 2352 formatter.write_str(")")?; 2353 Ok(()) 2354 } 2355 } 2356 formatter.field("ident", Print::ref_cast(val)); 2357 } 2358 formatter.field("mac", Lite(&_val.mac)); 2359 if _val.semi_token.is_some() { 2360 formatter.field("semi_token", &Present); 2361 } 2362 formatter.finish() 2363 } 2364 syn::Item::Mod(_val) => { 2365 let mut formatter = formatter.debug_struct("Item::Mod"); 2366 if !_val.attrs.is_empty() { 2367 formatter.field("attrs", Lite(&_val.attrs)); 2368 } 2369 formatter.field("vis", Lite(&_val.vis)); 2370 if _val.unsafety.is_some() { 2371 formatter.field("unsafety", &Present); 2372 } 2373 formatter.field("ident", Lite(&_val.ident)); 2374 if let Some(val) = &_val.content { 2375 #[derive(RefCast)] 2376 #[repr(transparent)] 2377 struct Print((syn::token::Brace, Vec<syn::Item>)); 2378 impl Debug for Print { 2379 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2380 formatter.write_str("Some(")?; 2381 Debug::fmt(Lite(&self.0.1), formatter)?; 2382 formatter.write_str(")")?; 2383 Ok(()) 2384 } 2385 } 2386 formatter.field("content", Print::ref_cast(val)); 2387 } 2388 if _val.semi.is_some() { 2389 formatter.field("semi", &Present); 2390 } 2391 formatter.finish() 2392 } 2393 syn::Item::Static(_val) => { 2394 let mut formatter = formatter.debug_struct("Item::Static"); 2395 if !_val.attrs.is_empty() { 2396 formatter.field("attrs", Lite(&_val.attrs)); 2397 } 2398 formatter.field("vis", Lite(&_val.vis)); 2399 match _val.mutability { 2400 syn::StaticMutability::None => {} 2401 _ => { 2402 formatter.field("mutability", Lite(&_val.mutability)); 2403 } 2404 } 2405 formatter.field("ident", Lite(&_val.ident)); 2406 formatter.field("ty", Lite(&_val.ty)); 2407 formatter.field("expr", Lite(&_val.expr)); 2408 formatter.finish() 2409 } 2410 syn::Item::Struct(_val) => { 2411 let mut formatter = formatter.debug_struct("Item::Struct"); 2412 if !_val.attrs.is_empty() { 2413 formatter.field("attrs", Lite(&_val.attrs)); 2414 } 2415 formatter.field("vis", Lite(&_val.vis)); 2416 formatter.field("ident", Lite(&_val.ident)); 2417 formatter.field("generics", Lite(&_val.generics)); 2418 formatter.field("fields", Lite(&_val.fields)); 2419 if _val.semi_token.is_some() { 2420 formatter.field("semi_token", &Present); 2421 } 2422 formatter.finish() 2423 } 2424 syn::Item::Trait(_val) => { 2425 let mut formatter = formatter.debug_struct("Item::Trait"); 2426 if !_val.attrs.is_empty() { 2427 formatter.field("attrs", Lite(&_val.attrs)); 2428 } 2429 formatter.field("vis", Lite(&_val.vis)); 2430 if _val.unsafety.is_some() { 2431 formatter.field("unsafety", &Present); 2432 } 2433 if _val.auto_token.is_some() { 2434 formatter.field("auto_token", &Present); 2435 } 2436 if let Some(val) = &_val.restriction { 2437 #[derive(RefCast)] 2438 #[repr(transparent)] 2439 struct Print(syn::ImplRestriction); 2440 impl Debug for Print { 2441 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2442 formatter.write_str("Some(")?; 2443 Debug::fmt(Lite(&self.0), formatter)?; 2444 formatter.write_str(")")?; 2445 Ok(()) 2446 } 2447 } 2448 formatter.field("restriction", Print::ref_cast(val)); 2449 } 2450 formatter.field("ident", Lite(&_val.ident)); 2451 formatter.field("generics", Lite(&_val.generics)); 2452 if _val.colon_token.is_some() { 2453 formatter.field("colon_token", &Present); 2454 } 2455 if !_val.supertraits.is_empty() { 2456 formatter.field("supertraits", Lite(&_val.supertraits)); 2457 } 2458 if !_val.items.is_empty() { 2459 formatter.field("items", Lite(&_val.items)); 2460 } 2461 formatter.finish() 2462 } 2463 syn::Item::TraitAlias(_val) => { 2464 let mut formatter = formatter.debug_struct("Item::TraitAlias"); 2465 if !_val.attrs.is_empty() { 2466 formatter.field("attrs", Lite(&_val.attrs)); 2467 } 2468 formatter.field("vis", Lite(&_val.vis)); 2469 formatter.field("ident", Lite(&_val.ident)); 2470 formatter.field("generics", Lite(&_val.generics)); 2471 if !_val.bounds.is_empty() { 2472 formatter.field("bounds", Lite(&_val.bounds)); 2473 } 2474 formatter.finish() 2475 } 2476 syn::Item::Type(_val) => { 2477 let mut formatter = formatter.debug_struct("Item::Type"); 2478 if !_val.attrs.is_empty() { 2479 formatter.field("attrs", Lite(&_val.attrs)); 2480 } 2481 formatter.field("vis", Lite(&_val.vis)); 2482 formatter.field("ident", Lite(&_val.ident)); 2483 formatter.field("generics", Lite(&_val.generics)); 2484 formatter.field("ty", Lite(&_val.ty)); 2485 formatter.finish() 2486 } 2487 syn::Item::Union(_val) => { 2488 let mut formatter = formatter.debug_struct("Item::Union"); 2489 if !_val.attrs.is_empty() { 2490 formatter.field("attrs", Lite(&_val.attrs)); 2491 } 2492 formatter.field("vis", Lite(&_val.vis)); 2493 formatter.field("ident", Lite(&_val.ident)); 2494 formatter.field("generics", Lite(&_val.generics)); 2495 formatter.field("fields", Lite(&_val.fields)); 2496 formatter.finish() 2497 } 2498 syn::Item::Use(_val) => { 2499 let mut formatter = formatter.debug_struct("Item::Use"); 2500 if !_val.attrs.is_empty() { 2501 formatter.field("attrs", Lite(&_val.attrs)); 2502 } 2503 formatter.field("vis", Lite(&_val.vis)); 2504 if _val.leading_colon.is_some() { 2505 formatter.field("leading_colon", &Present); 2506 } 2507 formatter.field("tree", Lite(&_val.tree)); 2508 formatter.finish() 2509 } 2510 syn::Item::Verbatim(_val) => { 2511 formatter.write_str("Item::Verbatim")?; 2512 formatter.write_str("(`")?; 2513 Display::fmt(_val, formatter)?; 2514 formatter.write_str("`)")?; 2515 Ok(()) 2516 } 2517 _ => unreachable!(), 2518 } 2519 } 2520 } 2521 impl Debug for Lite<syn::ItemConst> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2522 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2523 let mut formatter = formatter.debug_struct("ItemConst"); 2524 if !self.value.attrs.is_empty() { 2525 formatter.field("attrs", Lite(&self.value.attrs)); 2526 } 2527 formatter.field("vis", Lite(&self.value.vis)); 2528 formatter.field("ident", Lite(&self.value.ident)); 2529 formatter.field("generics", Lite(&self.value.generics)); 2530 formatter.field("ty", Lite(&self.value.ty)); 2531 formatter.field("expr", Lite(&self.value.expr)); 2532 formatter.finish() 2533 } 2534 } 2535 impl Debug for Lite<syn::ItemEnum> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2536 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2537 let mut formatter = formatter.debug_struct("ItemEnum"); 2538 if !self.value.attrs.is_empty() { 2539 formatter.field("attrs", Lite(&self.value.attrs)); 2540 } 2541 formatter.field("vis", Lite(&self.value.vis)); 2542 formatter.field("ident", Lite(&self.value.ident)); 2543 formatter.field("generics", Lite(&self.value.generics)); 2544 if !self.value.variants.is_empty() { 2545 formatter.field("variants", Lite(&self.value.variants)); 2546 } 2547 formatter.finish() 2548 } 2549 } 2550 impl Debug for Lite<syn::ItemExternCrate> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2551 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2552 let mut formatter = formatter.debug_struct("ItemExternCrate"); 2553 if !self.value.attrs.is_empty() { 2554 formatter.field("attrs", Lite(&self.value.attrs)); 2555 } 2556 formatter.field("vis", Lite(&self.value.vis)); 2557 formatter.field("ident", Lite(&self.value.ident)); 2558 if let Some(val) = &self.value.rename { 2559 #[derive(RefCast)] 2560 #[repr(transparent)] 2561 struct Print((syn::token::As, proc_macro2::Ident)); 2562 impl Debug for Print { 2563 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2564 formatter.write_str("Some(")?; 2565 Debug::fmt(Lite(&self.0.1), formatter)?; 2566 formatter.write_str(")")?; 2567 Ok(()) 2568 } 2569 } 2570 formatter.field("rename", Print::ref_cast(val)); 2571 } 2572 formatter.finish() 2573 } 2574 } 2575 impl Debug for Lite<syn::ItemFn> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2576 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2577 let mut formatter = formatter.debug_struct("ItemFn"); 2578 if !self.value.attrs.is_empty() { 2579 formatter.field("attrs", Lite(&self.value.attrs)); 2580 } 2581 formatter.field("vis", Lite(&self.value.vis)); 2582 formatter.field("sig", Lite(&self.value.sig)); 2583 formatter.field("block", Lite(&self.value.block)); 2584 formatter.finish() 2585 } 2586 } 2587 impl Debug for Lite<syn::ItemForeignMod> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2588 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2589 let mut formatter = formatter.debug_struct("ItemForeignMod"); 2590 if !self.value.attrs.is_empty() { 2591 formatter.field("attrs", Lite(&self.value.attrs)); 2592 } 2593 if self.value.unsafety.is_some() { 2594 formatter.field("unsafety", &Present); 2595 } 2596 formatter.field("abi", Lite(&self.value.abi)); 2597 if !self.value.items.is_empty() { 2598 formatter.field("items", Lite(&self.value.items)); 2599 } 2600 formatter.finish() 2601 } 2602 } 2603 impl Debug for Lite<syn::ItemImpl> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2604 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2605 let mut formatter = formatter.debug_struct("ItemImpl"); 2606 if !self.value.attrs.is_empty() { 2607 formatter.field("attrs", Lite(&self.value.attrs)); 2608 } 2609 if self.value.defaultness.is_some() { 2610 formatter.field("defaultness", &Present); 2611 } 2612 if self.value.unsafety.is_some() { 2613 formatter.field("unsafety", &Present); 2614 } 2615 formatter.field("generics", Lite(&self.value.generics)); 2616 if let Some(val) = &self.value.trait_ { 2617 #[derive(RefCast)] 2618 #[repr(transparent)] 2619 struct Print((Option<syn::token::Not>, syn::Path, syn::token::For)); 2620 impl Debug for Print { 2621 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2622 formatter.write_str("Some(")?; 2623 Debug::fmt( 2624 &( 2625 &super::Option { 2626 present: self.0.0.is_some(), 2627 }, 2628 Lite(&self.0.1), 2629 ), 2630 formatter, 2631 )?; 2632 formatter.write_str(")")?; 2633 Ok(()) 2634 } 2635 } 2636 formatter.field("trait_", Print::ref_cast(val)); 2637 } 2638 formatter.field("self_ty", Lite(&self.value.self_ty)); 2639 if !self.value.items.is_empty() { 2640 formatter.field("items", Lite(&self.value.items)); 2641 } 2642 formatter.finish() 2643 } 2644 } 2645 impl Debug for Lite<syn::ItemMacro> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2646 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2647 let mut formatter = formatter.debug_struct("ItemMacro"); 2648 if !self.value.attrs.is_empty() { 2649 formatter.field("attrs", Lite(&self.value.attrs)); 2650 } 2651 if let Some(val) = &self.value.ident { 2652 #[derive(RefCast)] 2653 #[repr(transparent)] 2654 struct Print(proc_macro2::Ident); 2655 impl Debug for Print { 2656 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2657 formatter.write_str("Some(")?; 2658 Debug::fmt(Lite(&self.0), formatter)?; 2659 formatter.write_str(")")?; 2660 Ok(()) 2661 } 2662 } 2663 formatter.field("ident", Print::ref_cast(val)); 2664 } 2665 formatter.field("mac", Lite(&self.value.mac)); 2666 if self.value.semi_token.is_some() { 2667 formatter.field("semi_token", &Present); 2668 } 2669 formatter.finish() 2670 } 2671 } 2672 impl Debug for Lite<syn::ItemMod> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2673 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2674 let mut formatter = formatter.debug_struct("ItemMod"); 2675 if !self.value.attrs.is_empty() { 2676 formatter.field("attrs", Lite(&self.value.attrs)); 2677 } 2678 formatter.field("vis", Lite(&self.value.vis)); 2679 if self.value.unsafety.is_some() { 2680 formatter.field("unsafety", &Present); 2681 } 2682 formatter.field("ident", Lite(&self.value.ident)); 2683 if let Some(val) = &self.value.content { 2684 #[derive(RefCast)] 2685 #[repr(transparent)] 2686 struct Print((syn::token::Brace, Vec<syn::Item>)); 2687 impl Debug for Print { 2688 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2689 formatter.write_str("Some(")?; 2690 Debug::fmt(Lite(&self.0.1), formatter)?; 2691 formatter.write_str(")")?; 2692 Ok(()) 2693 } 2694 } 2695 formatter.field("content", Print::ref_cast(val)); 2696 } 2697 if self.value.semi.is_some() { 2698 formatter.field("semi", &Present); 2699 } 2700 formatter.finish() 2701 } 2702 } 2703 impl Debug for Lite<syn::ItemStatic> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2704 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2705 let mut formatter = formatter.debug_struct("ItemStatic"); 2706 if !self.value.attrs.is_empty() { 2707 formatter.field("attrs", Lite(&self.value.attrs)); 2708 } 2709 formatter.field("vis", Lite(&self.value.vis)); 2710 match self.value.mutability { 2711 syn::StaticMutability::None => {} 2712 _ => { 2713 formatter.field("mutability", Lite(&self.value.mutability)); 2714 } 2715 } 2716 formatter.field("ident", Lite(&self.value.ident)); 2717 formatter.field("ty", Lite(&self.value.ty)); 2718 formatter.field("expr", Lite(&self.value.expr)); 2719 formatter.finish() 2720 } 2721 } 2722 impl Debug for Lite<syn::ItemStruct> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2723 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2724 let mut formatter = formatter.debug_struct("ItemStruct"); 2725 if !self.value.attrs.is_empty() { 2726 formatter.field("attrs", Lite(&self.value.attrs)); 2727 } 2728 formatter.field("vis", Lite(&self.value.vis)); 2729 formatter.field("ident", Lite(&self.value.ident)); 2730 formatter.field("generics", Lite(&self.value.generics)); 2731 formatter.field("fields", Lite(&self.value.fields)); 2732 if self.value.semi_token.is_some() { 2733 formatter.field("semi_token", &Present); 2734 } 2735 formatter.finish() 2736 } 2737 } 2738 impl Debug for Lite<syn::ItemTrait> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2739 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2740 let mut formatter = formatter.debug_struct("ItemTrait"); 2741 if !self.value.attrs.is_empty() { 2742 formatter.field("attrs", Lite(&self.value.attrs)); 2743 } 2744 formatter.field("vis", Lite(&self.value.vis)); 2745 if self.value.unsafety.is_some() { 2746 formatter.field("unsafety", &Present); 2747 } 2748 if self.value.auto_token.is_some() { 2749 formatter.field("auto_token", &Present); 2750 } 2751 if let Some(val) = &self.value.restriction { 2752 #[derive(RefCast)] 2753 #[repr(transparent)] 2754 struct Print(syn::ImplRestriction); 2755 impl Debug for Print { 2756 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2757 formatter.write_str("Some(")?; 2758 Debug::fmt(Lite(&self.0), formatter)?; 2759 formatter.write_str(")")?; 2760 Ok(()) 2761 } 2762 } 2763 formatter.field("restriction", Print::ref_cast(val)); 2764 } 2765 formatter.field("ident", Lite(&self.value.ident)); 2766 formatter.field("generics", Lite(&self.value.generics)); 2767 if self.value.colon_token.is_some() { 2768 formatter.field("colon_token", &Present); 2769 } 2770 if !self.value.supertraits.is_empty() { 2771 formatter.field("supertraits", Lite(&self.value.supertraits)); 2772 } 2773 if !self.value.items.is_empty() { 2774 formatter.field("items", Lite(&self.value.items)); 2775 } 2776 formatter.finish() 2777 } 2778 } 2779 impl Debug for Lite<syn::ItemTraitAlias> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2780 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2781 let mut formatter = formatter.debug_struct("ItemTraitAlias"); 2782 if !self.value.attrs.is_empty() { 2783 formatter.field("attrs", Lite(&self.value.attrs)); 2784 } 2785 formatter.field("vis", Lite(&self.value.vis)); 2786 formatter.field("ident", Lite(&self.value.ident)); 2787 formatter.field("generics", Lite(&self.value.generics)); 2788 if !self.value.bounds.is_empty() { 2789 formatter.field("bounds", Lite(&self.value.bounds)); 2790 } 2791 formatter.finish() 2792 } 2793 } 2794 impl Debug for Lite<syn::ItemType> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2795 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2796 let mut formatter = formatter.debug_struct("ItemType"); 2797 if !self.value.attrs.is_empty() { 2798 formatter.field("attrs", Lite(&self.value.attrs)); 2799 } 2800 formatter.field("vis", Lite(&self.value.vis)); 2801 formatter.field("ident", Lite(&self.value.ident)); 2802 formatter.field("generics", Lite(&self.value.generics)); 2803 formatter.field("ty", Lite(&self.value.ty)); 2804 formatter.finish() 2805 } 2806 } 2807 impl Debug for Lite<syn::ItemUnion> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2808 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2809 let mut formatter = formatter.debug_struct("ItemUnion"); 2810 if !self.value.attrs.is_empty() { 2811 formatter.field("attrs", Lite(&self.value.attrs)); 2812 } 2813 formatter.field("vis", Lite(&self.value.vis)); 2814 formatter.field("ident", Lite(&self.value.ident)); 2815 formatter.field("generics", Lite(&self.value.generics)); 2816 formatter.field("fields", Lite(&self.value.fields)); 2817 formatter.finish() 2818 } 2819 } 2820 impl Debug for Lite<syn::ItemUse> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2821 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2822 let mut formatter = formatter.debug_struct("ItemUse"); 2823 if !self.value.attrs.is_empty() { 2824 formatter.field("attrs", Lite(&self.value.attrs)); 2825 } 2826 formatter.field("vis", Lite(&self.value.vis)); 2827 if self.value.leading_colon.is_some() { 2828 formatter.field("leading_colon", &Present); 2829 } 2830 formatter.field("tree", Lite(&self.value.tree)); 2831 formatter.finish() 2832 } 2833 } 2834 impl Debug for Lite<syn::Label> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2835 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2836 let mut formatter = formatter.debug_struct("Label"); 2837 formatter.field("name", Lite(&self.value.name)); 2838 formatter.finish() 2839 } 2840 } 2841 impl Debug for Lite<syn::Lifetime> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2842 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2843 let mut formatter = formatter.debug_struct("Lifetime"); 2844 formatter.field("ident", Lite(&self.value.ident)); 2845 formatter.finish() 2846 } 2847 } 2848 impl Debug for Lite<syn::LifetimeParam> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2849 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2850 let mut formatter = formatter.debug_struct("LifetimeParam"); 2851 if !self.value.attrs.is_empty() { 2852 formatter.field("attrs", Lite(&self.value.attrs)); 2853 } 2854 formatter.field("lifetime", Lite(&self.value.lifetime)); 2855 if self.value.colon_token.is_some() { 2856 formatter.field("colon_token", &Present); 2857 } 2858 if !self.value.bounds.is_empty() { 2859 formatter.field("bounds", Lite(&self.value.bounds)); 2860 } 2861 formatter.finish() 2862 } 2863 } 2864 impl Debug for Lite<syn::Lit> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2865 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2866 match &self.value { 2867 syn::Lit::Str(_val) => write!(formatter, "{:?}", _val.value()), 2868 syn::Lit::ByteStr(_val) => write!(formatter, "{:?}", _val.value()), 2869 syn::Lit::Byte(_val) => write!(formatter, "{:?}", _val.value()), 2870 syn::Lit::Char(_val) => write!(formatter, "{:?}", _val.value()), 2871 syn::Lit::Int(_val) => write!(formatter, "{}", _val), 2872 syn::Lit::Float(_val) => write!(formatter, "{}", _val), 2873 syn::Lit::Bool(_val) => { 2874 let mut formatter = formatter.debug_struct("Lit::Bool"); 2875 formatter.field("value", Lite(&_val.value)); 2876 formatter.finish() 2877 } 2878 syn::Lit::Verbatim(_val) => { 2879 formatter.write_str("Lit::Verbatim")?; 2880 formatter.write_str("(`")?; 2881 Display::fmt(_val, formatter)?; 2882 formatter.write_str("`)")?; 2883 Ok(()) 2884 } 2885 _ => unreachable!(), 2886 } 2887 } 2888 } 2889 impl Debug for Lite<syn::LitBool> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2890 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2891 let mut formatter = formatter.debug_struct("LitBool"); 2892 formatter.field("value", Lite(&self.value.value)); 2893 formatter.finish() 2894 } 2895 } 2896 impl Debug for Lite<syn::LitByte> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2897 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2898 write!(formatter, "{:?}", self.value.value()) 2899 } 2900 } 2901 impl Debug for Lite<syn::LitByteStr> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2902 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2903 write!(formatter, "{:?}", self.value.value()) 2904 } 2905 } 2906 impl Debug for Lite<syn::LitChar> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2907 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2908 write!(formatter, "{:?}", self.value.value()) 2909 } 2910 } 2911 impl Debug for Lite<syn::LitFloat> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2912 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2913 write!(formatter, "{}", & self.value) 2914 } 2915 } 2916 impl Debug for Lite<syn::LitInt> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2917 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2918 write!(formatter, "{}", & self.value) 2919 } 2920 } 2921 impl Debug for Lite<syn::LitStr> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2922 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2923 write!(formatter, "{:?}", self.value.value()) 2924 } 2925 } 2926 impl Debug for Lite<syn::Local> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2927 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2928 let mut formatter = formatter.debug_struct("Local"); 2929 if !self.value.attrs.is_empty() { 2930 formatter.field("attrs", Lite(&self.value.attrs)); 2931 } 2932 formatter.field("pat", Lite(&self.value.pat)); 2933 if let Some(val) = &self.value.init { 2934 #[derive(RefCast)] 2935 #[repr(transparent)] 2936 struct Print(syn::LocalInit); 2937 impl Debug for Print { 2938 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2939 formatter.write_str("Some(")?; 2940 Debug::fmt(Lite(&self.0), formatter)?; 2941 formatter.write_str(")")?; 2942 Ok(()) 2943 } 2944 } 2945 formatter.field("init", Print::ref_cast(val)); 2946 } 2947 formatter.finish() 2948 } 2949 } 2950 impl Debug for Lite<syn::LocalInit> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2951 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2952 let mut formatter = formatter.debug_struct("LocalInit"); 2953 formatter.field("expr", Lite(&self.value.expr)); 2954 if let Some(val) = &self.value.diverge { 2955 #[derive(RefCast)] 2956 #[repr(transparent)] 2957 struct Print((syn::token::Else, Box<syn::Expr>)); 2958 impl Debug for Print { 2959 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2960 formatter.write_str("Some(")?; 2961 Debug::fmt(Lite(&self.0.1), formatter)?; 2962 formatter.write_str(")")?; 2963 Ok(()) 2964 } 2965 } 2966 formatter.field("diverge", Print::ref_cast(val)); 2967 } 2968 formatter.finish() 2969 } 2970 } 2971 impl Debug for Lite<syn::Macro> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2972 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2973 let mut formatter = formatter.debug_struct("Macro"); 2974 formatter.field("path", Lite(&self.value.path)); 2975 formatter.field("delimiter", Lite(&self.value.delimiter)); 2976 formatter.field("tokens", Lite(&self.value.tokens)); 2977 formatter.finish() 2978 } 2979 } 2980 impl Debug for Lite<syn::MacroDelimiter> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2981 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 2982 match &self.value { 2983 syn::MacroDelimiter::Paren(_val) => { 2984 formatter.write_str("MacroDelimiter::Paren")?; 2985 Ok(()) 2986 } 2987 syn::MacroDelimiter::Brace(_val) => { 2988 formatter.write_str("MacroDelimiter::Brace")?; 2989 Ok(()) 2990 } 2991 syn::MacroDelimiter::Bracket(_val) => { 2992 formatter.write_str("MacroDelimiter::Bracket")?; 2993 Ok(()) 2994 } 2995 } 2996 } 2997 } 2998 impl Debug for Lite<syn::Member> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result2999 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3000 match &self.value { 3001 syn::Member::Named(_val) => { 3002 formatter.write_str("Member::Named")?; 3003 formatter.write_str("(")?; 3004 Debug::fmt(Lite(_val), formatter)?; 3005 formatter.write_str(")")?; 3006 Ok(()) 3007 } 3008 syn::Member::Unnamed(_val) => { 3009 formatter.write_str("Member::Unnamed")?; 3010 formatter.write_str("(")?; 3011 Debug::fmt(Lite(_val), formatter)?; 3012 formatter.write_str(")")?; 3013 Ok(()) 3014 } 3015 } 3016 } 3017 } 3018 impl Debug for Lite<syn::Meta> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result3019 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3020 match &self.value { 3021 syn::Meta::Path(_val) => { 3022 let mut formatter = formatter.debug_struct("Meta::Path"); 3023 if _val.leading_colon.is_some() { 3024 formatter.field("leading_colon", &Present); 3025 } 3026 if !_val.segments.is_empty() { 3027 formatter.field("segments", Lite(&_val.segments)); 3028 } 3029 formatter.finish() 3030 } 3031 syn::Meta::List(_val) => { 3032 let mut formatter = formatter.debug_struct("Meta::List"); 3033 formatter.field("path", Lite(&_val.path)); 3034 formatter.field("delimiter", Lite(&_val.delimiter)); 3035 formatter.field("tokens", Lite(&_val.tokens)); 3036 formatter.finish() 3037 } 3038 syn::Meta::NameValue(_val) => { 3039 let mut formatter = formatter.debug_struct("Meta::NameValue"); 3040 formatter.field("path", Lite(&_val.path)); 3041 formatter.field("value", Lite(&_val.value)); 3042 formatter.finish() 3043 } 3044 } 3045 } 3046 } 3047 impl Debug for Lite<syn::MetaList> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result3048 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3049 let mut formatter = formatter.debug_struct("MetaList"); 3050 formatter.field("path", Lite(&self.value.path)); 3051 formatter.field("delimiter", Lite(&self.value.delimiter)); 3052 formatter.field("tokens", Lite(&self.value.tokens)); 3053 formatter.finish() 3054 } 3055 } 3056 impl Debug for Lite<syn::MetaNameValue> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result3057 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3058 let mut formatter = formatter.debug_struct("MetaNameValue"); 3059 formatter.field("path", Lite(&self.value.path)); 3060 formatter.field("value", Lite(&self.value.value)); 3061 formatter.finish() 3062 } 3063 } 3064 impl Debug for Lite<syn::ParenthesizedGenericArguments> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result3065 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3066 let mut formatter = formatter.debug_struct("ParenthesizedGenericArguments"); 3067 if !self.value.inputs.is_empty() { 3068 formatter.field("inputs", Lite(&self.value.inputs)); 3069 } 3070 formatter.field("output", Lite(&self.value.output)); 3071 formatter.finish() 3072 } 3073 } 3074 impl Debug for Lite<syn::Pat> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result3075 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3076 match &self.value { 3077 syn::Pat::Const(_val) => { 3078 formatter.write_str("Pat::Const")?; 3079 formatter.write_str("(")?; 3080 Debug::fmt(Lite(_val), formatter)?; 3081 formatter.write_str(")")?; 3082 Ok(()) 3083 } 3084 syn::Pat::Ident(_val) => { 3085 let mut formatter = formatter.debug_struct("Pat::Ident"); 3086 if !_val.attrs.is_empty() { 3087 formatter.field("attrs", Lite(&_val.attrs)); 3088 } 3089 if _val.by_ref.is_some() { 3090 formatter.field("by_ref", &Present); 3091 } 3092 if _val.mutability.is_some() { 3093 formatter.field("mutability", &Present); 3094 } 3095 formatter.field("ident", Lite(&_val.ident)); 3096 if let Some(val) = &_val.subpat { 3097 #[derive(RefCast)] 3098 #[repr(transparent)] 3099 struct Print((syn::token::At, Box<syn::Pat>)); 3100 impl Debug for Print { 3101 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3102 formatter.write_str("Some(")?; 3103 Debug::fmt(Lite(&self.0.1), formatter)?; 3104 formatter.write_str(")")?; 3105 Ok(()) 3106 } 3107 } 3108 formatter.field("subpat", Print::ref_cast(val)); 3109 } 3110 formatter.finish() 3111 } 3112 syn::Pat::Lit(_val) => { 3113 formatter.write_str("Pat::Lit")?; 3114 formatter.write_str("(")?; 3115 Debug::fmt(Lite(_val), formatter)?; 3116 formatter.write_str(")")?; 3117 Ok(()) 3118 } 3119 syn::Pat::Macro(_val) => { 3120 formatter.write_str("Pat::Macro")?; 3121 formatter.write_str("(")?; 3122 Debug::fmt(Lite(_val), formatter)?; 3123 formatter.write_str(")")?; 3124 Ok(()) 3125 } 3126 syn::Pat::Or(_val) => { 3127 let mut formatter = formatter.debug_struct("Pat::Or"); 3128 if !_val.attrs.is_empty() { 3129 formatter.field("attrs", Lite(&_val.attrs)); 3130 } 3131 if _val.leading_vert.is_some() { 3132 formatter.field("leading_vert", &Present); 3133 } 3134 if !_val.cases.is_empty() { 3135 formatter.field("cases", Lite(&_val.cases)); 3136 } 3137 formatter.finish() 3138 } 3139 syn::Pat::Paren(_val) => { 3140 let mut formatter = formatter.debug_struct("Pat::Paren"); 3141 if !_val.attrs.is_empty() { 3142 formatter.field("attrs", Lite(&_val.attrs)); 3143 } 3144 formatter.field("pat", Lite(&_val.pat)); 3145 formatter.finish() 3146 } 3147 syn::Pat::Path(_val) => { 3148 formatter.write_str("Pat::Path")?; 3149 formatter.write_str("(")?; 3150 Debug::fmt(Lite(_val), formatter)?; 3151 formatter.write_str(")")?; 3152 Ok(()) 3153 } 3154 syn::Pat::Range(_val) => { 3155 formatter.write_str("Pat::Range")?; 3156 formatter.write_str("(")?; 3157 Debug::fmt(Lite(_val), formatter)?; 3158 formatter.write_str(")")?; 3159 Ok(()) 3160 } 3161 syn::Pat::Reference(_val) => { 3162 let mut formatter = formatter.debug_struct("Pat::Reference"); 3163 if !_val.attrs.is_empty() { 3164 formatter.field("attrs", Lite(&_val.attrs)); 3165 } 3166 if _val.mutability.is_some() { 3167 formatter.field("mutability", &Present); 3168 } 3169 formatter.field("pat", Lite(&_val.pat)); 3170 formatter.finish() 3171 } 3172 syn::Pat::Rest(_val) => { 3173 let mut formatter = formatter.debug_struct("Pat::Rest"); 3174 if !_val.attrs.is_empty() { 3175 formatter.field("attrs", Lite(&_val.attrs)); 3176 } 3177 formatter.finish() 3178 } 3179 syn::Pat::Slice(_val) => { 3180 let mut formatter = formatter.debug_struct("Pat::Slice"); 3181 if !_val.attrs.is_empty() { 3182 formatter.field("attrs", Lite(&_val.attrs)); 3183 } 3184 if !_val.elems.is_empty() { 3185 formatter.field("elems", Lite(&_val.elems)); 3186 } 3187 formatter.finish() 3188 } 3189 syn::Pat::Struct(_val) => { 3190 let mut formatter = formatter.debug_struct("Pat::Struct"); 3191 if !_val.attrs.is_empty() { 3192 formatter.field("attrs", Lite(&_val.attrs)); 3193 } 3194 if let Some(val) = &_val.qself { 3195 #[derive(RefCast)] 3196 #[repr(transparent)] 3197 struct Print(syn::QSelf); 3198 impl Debug for Print { 3199 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3200 formatter.write_str("Some(")?; 3201 Debug::fmt(Lite(&self.0), formatter)?; 3202 formatter.write_str(")")?; 3203 Ok(()) 3204 } 3205 } 3206 formatter.field("qself", Print::ref_cast(val)); 3207 } 3208 formatter.field("path", Lite(&_val.path)); 3209 if !_val.fields.is_empty() { 3210 formatter.field("fields", Lite(&_val.fields)); 3211 } 3212 if let Some(val) = &_val.rest { 3213 #[derive(RefCast)] 3214 #[repr(transparent)] 3215 struct Print(syn::PatRest); 3216 impl Debug for Print { 3217 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3218 formatter.write_str("Some(")?; 3219 Debug::fmt(Lite(&self.0), formatter)?; 3220 formatter.write_str(")")?; 3221 Ok(()) 3222 } 3223 } 3224 formatter.field("rest", Print::ref_cast(val)); 3225 } 3226 formatter.finish() 3227 } 3228 syn::Pat::Tuple(_val) => { 3229 let mut formatter = formatter.debug_struct("Pat::Tuple"); 3230 if !_val.attrs.is_empty() { 3231 formatter.field("attrs", Lite(&_val.attrs)); 3232 } 3233 if !_val.elems.is_empty() { 3234 formatter.field("elems", Lite(&_val.elems)); 3235 } 3236 formatter.finish() 3237 } 3238 syn::Pat::TupleStruct(_val) => { 3239 let mut formatter = formatter.debug_struct("Pat::TupleStruct"); 3240 if !_val.attrs.is_empty() { 3241 formatter.field("attrs", Lite(&_val.attrs)); 3242 } 3243 if let Some(val) = &_val.qself { 3244 #[derive(RefCast)] 3245 #[repr(transparent)] 3246 struct Print(syn::QSelf); 3247 impl Debug for Print { 3248 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3249 formatter.write_str("Some(")?; 3250 Debug::fmt(Lite(&self.0), formatter)?; 3251 formatter.write_str(")")?; 3252 Ok(()) 3253 } 3254 } 3255 formatter.field("qself", Print::ref_cast(val)); 3256 } 3257 formatter.field("path", Lite(&_val.path)); 3258 if !_val.elems.is_empty() { 3259 formatter.field("elems", Lite(&_val.elems)); 3260 } 3261 formatter.finish() 3262 } 3263 syn::Pat::Type(_val) => { 3264 let mut formatter = formatter.debug_struct("Pat::Type"); 3265 if !_val.attrs.is_empty() { 3266 formatter.field("attrs", Lite(&_val.attrs)); 3267 } 3268 formatter.field("pat", Lite(&_val.pat)); 3269 formatter.field("ty", Lite(&_val.ty)); 3270 formatter.finish() 3271 } 3272 syn::Pat::Verbatim(_val) => { 3273 formatter.write_str("Pat::Verbatim")?; 3274 formatter.write_str("(`")?; 3275 Display::fmt(_val, formatter)?; 3276 formatter.write_str("`)")?; 3277 Ok(()) 3278 } 3279 syn::Pat::Wild(_val) => { 3280 let mut formatter = formatter.debug_struct("Pat::Wild"); 3281 if !_val.attrs.is_empty() { 3282 formatter.field("attrs", Lite(&_val.attrs)); 3283 } 3284 formatter.finish() 3285 } 3286 _ => unreachable!(), 3287 } 3288 } 3289 } 3290 impl Debug for Lite<syn::PatIdent> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result3291 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3292 let mut formatter = formatter.debug_struct("PatIdent"); 3293 if !self.value.attrs.is_empty() { 3294 formatter.field("attrs", Lite(&self.value.attrs)); 3295 } 3296 if self.value.by_ref.is_some() { 3297 formatter.field("by_ref", &Present); 3298 } 3299 if self.value.mutability.is_some() { 3300 formatter.field("mutability", &Present); 3301 } 3302 formatter.field("ident", Lite(&self.value.ident)); 3303 if let Some(val) = &self.value.subpat { 3304 #[derive(RefCast)] 3305 #[repr(transparent)] 3306 struct Print((syn::token::At, Box<syn::Pat>)); 3307 impl Debug for Print { 3308 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3309 formatter.write_str("Some(")?; 3310 Debug::fmt(Lite(&self.0.1), formatter)?; 3311 formatter.write_str(")")?; 3312 Ok(()) 3313 } 3314 } 3315 formatter.field("subpat", Print::ref_cast(val)); 3316 } 3317 formatter.finish() 3318 } 3319 } 3320 impl Debug for Lite<syn::PatOr> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result3321 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3322 let mut formatter = formatter.debug_struct("PatOr"); 3323 if !self.value.attrs.is_empty() { 3324 formatter.field("attrs", Lite(&self.value.attrs)); 3325 } 3326 if self.value.leading_vert.is_some() { 3327 formatter.field("leading_vert", &Present); 3328 } 3329 if !self.value.cases.is_empty() { 3330 formatter.field("cases", Lite(&self.value.cases)); 3331 } 3332 formatter.finish() 3333 } 3334 } 3335 impl Debug for Lite<syn::PatParen> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result3336 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3337 let mut formatter = formatter.debug_struct("PatParen"); 3338 if !self.value.attrs.is_empty() { 3339 formatter.field("attrs", Lite(&self.value.attrs)); 3340 } 3341 formatter.field("pat", Lite(&self.value.pat)); 3342 formatter.finish() 3343 } 3344 } 3345 impl Debug for Lite<syn::PatReference> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result3346 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3347 let mut formatter = formatter.debug_struct("PatReference"); 3348 if !self.value.attrs.is_empty() { 3349 formatter.field("attrs", Lite(&self.value.attrs)); 3350 } 3351 if self.value.mutability.is_some() { 3352 formatter.field("mutability", &Present); 3353 } 3354 formatter.field("pat", Lite(&self.value.pat)); 3355 formatter.finish() 3356 } 3357 } 3358 impl Debug for Lite<syn::PatRest> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result3359 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3360 let mut formatter = formatter.debug_struct("PatRest"); 3361 if !self.value.attrs.is_empty() { 3362 formatter.field("attrs", Lite(&self.value.attrs)); 3363 } 3364 formatter.finish() 3365 } 3366 } 3367 impl Debug for Lite<syn::PatSlice> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result3368 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3369 let mut formatter = formatter.debug_struct("PatSlice"); 3370 if !self.value.attrs.is_empty() { 3371 formatter.field("attrs", Lite(&self.value.attrs)); 3372 } 3373 if !self.value.elems.is_empty() { 3374 formatter.field("elems", Lite(&self.value.elems)); 3375 } 3376 formatter.finish() 3377 } 3378 } 3379 impl Debug for Lite<syn::PatStruct> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result3380 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3381 let mut formatter = formatter.debug_struct("PatStruct"); 3382 if !self.value.attrs.is_empty() { 3383 formatter.field("attrs", Lite(&self.value.attrs)); 3384 } 3385 if let Some(val) = &self.value.qself { 3386 #[derive(RefCast)] 3387 #[repr(transparent)] 3388 struct Print(syn::QSelf); 3389 impl Debug for Print { 3390 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3391 formatter.write_str("Some(")?; 3392 Debug::fmt(Lite(&self.0), formatter)?; 3393 formatter.write_str(")")?; 3394 Ok(()) 3395 } 3396 } 3397 formatter.field("qself", Print::ref_cast(val)); 3398 } 3399 formatter.field("path", Lite(&self.value.path)); 3400 if !self.value.fields.is_empty() { 3401 formatter.field("fields", Lite(&self.value.fields)); 3402 } 3403 if let Some(val) = &self.value.rest { 3404 #[derive(RefCast)] 3405 #[repr(transparent)] 3406 struct Print(syn::PatRest); 3407 impl Debug for Print { 3408 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3409 formatter.write_str("Some(")?; 3410 Debug::fmt(Lite(&self.0), formatter)?; 3411 formatter.write_str(")")?; 3412 Ok(()) 3413 } 3414 } 3415 formatter.field("rest", Print::ref_cast(val)); 3416 } 3417 formatter.finish() 3418 } 3419 } 3420 impl Debug for Lite<syn::PatTuple> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result3421 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3422 let mut formatter = formatter.debug_struct("PatTuple"); 3423 if !self.value.attrs.is_empty() { 3424 formatter.field("attrs", Lite(&self.value.attrs)); 3425 } 3426 if !self.value.elems.is_empty() { 3427 formatter.field("elems", Lite(&self.value.elems)); 3428 } 3429 formatter.finish() 3430 } 3431 } 3432 impl Debug for Lite<syn::PatTupleStruct> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result3433 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3434 let mut formatter = formatter.debug_struct("PatTupleStruct"); 3435 if !self.value.attrs.is_empty() { 3436 formatter.field("attrs", Lite(&self.value.attrs)); 3437 } 3438 if let Some(val) = &self.value.qself { 3439 #[derive(RefCast)] 3440 #[repr(transparent)] 3441 struct Print(syn::QSelf); 3442 impl Debug for Print { 3443 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3444 formatter.write_str("Some(")?; 3445 Debug::fmt(Lite(&self.0), formatter)?; 3446 formatter.write_str(")")?; 3447 Ok(()) 3448 } 3449 } 3450 formatter.field("qself", Print::ref_cast(val)); 3451 } 3452 formatter.field("path", Lite(&self.value.path)); 3453 if !self.value.elems.is_empty() { 3454 formatter.field("elems", Lite(&self.value.elems)); 3455 } 3456 formatter.finish() 3457 } 3458 } 3459 impl Debug for Lite<syn::PatType> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result3460 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3461 let mut formatter = formatter.debug_struct("PatType"); 3462 if !self.value.attrs.is_empty() { 3463 formatter.field("attrs", Lite(&self.value.attrs)); 3464 } 3465 formatter.field("pat", Lite(&self.value.pat)); 3466 formatter.field("ty", Lite(&self.value.ty)); 3467 formatter.finish() 3468 } 3469 } 3470 impl Debug for Lite<syn::PatWild> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result3471 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3472 let mut formatter = formatter.debug_struct("PatWild"); 3473 if !self.value.attrs.is_empty() { 3474 formatter.field("attrs", Lite(&self.value.attrs)); 3475 } 3476 formatter.finish() 3477 } 3478 } 3479 impl Debug for Lite<syn::Path> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result3480 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3481 let mut formatter = formatter.debug_struct("Path"); 3482 if self.value.leading_colon.is_some() { 3483 formatter.field("leading_colon", &Present); 3484 } 3485 if !self.value.segments.is_empty() { 3486 formatter.field("segments", Lite(&self.value.segments)); 3487 } 3488 formatter.finish() 3489 } 3490 } 3491 impl Debug for Lite<syn::PathArguments> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result3492 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3493 match &self.value { 3494 syn::PathArguments::None => formatter.write_str("PathArguments::None"), 3495 syn::PathArguments::AngleBracketed(_val) => { 3496 let mut formatter = formatter 3497 .debug_struct("PathArguments::AngleBracketed"); 3498 if _val.colon2_token.is_some() { 3499 formatter.field("colon2_token", &Present); 3500 } 3501 if !_val.args.is_empty() { 3502 formatter.field("args", Lite(&_val.args)); 3503 } 3504 formatter.finish() 3505 } 3506 syn::PathArguments::Parenthesized(_val) => { 3507 let mut formatter = formatter 3508 .debug_struct("PathArguments::Parenthesized"); 3509 if !_val.inputs.is_empty() { 3510 formatter.field("inputs", Lite(&_val.inputs)); 3511 } 3512 formatter.field("output", Lite(&_val.output)); 3513 formatter.finish() 3514 } 3515 } 3516 } 3517 } 3518 impl Debug for Lite<syn::PathSegment> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result3519 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3520 let mut formatter = formatter.debug_struct("PathSegment"); 3521 formatter.field("ident", Lite(&self.value.ident)); 3522 match self.value.arguments { 3523 syn::PathArguments::None => {} 3524 _ => { 3525 formatter.field("arguments", Lite(&self.value.arguments)); 3526 } 3527 } 3528 formatter.finish() 3529 } 3530 } 3531 impl Debug for Lite<syn::PredicateLifetime> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result3532 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3533 let mut formatter = formatter.debug_struct("PredicateLifetime"); 3534 formatter.field("lifetime", Lite(&self.value.lifetime)); 3535 if !self.value.bounds.is_empty() { 3536 formatter.field("bounds", Lite(&self.value.bounds)); 3537 } 3538 formatter.finish() 3539 } 3540 } 3541 impl Debug for Lite<syn::PredicateType> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result3542 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3543 let mut formatter = formatter.debug_struct("PredicateType"); 3544 if let Some(val) = &self.value.lifetimes { 3545 #[derive(RefCast)] 3546 #[repr(transparent)] 3547 struct Print(syn::BoundLifetimes); 3548 impl Debug for Print { 3549 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3550 formatter.write_str("Some(")?; 3551 Debug::fmt(Lite(&self.0), formatter)?; 3552 formatter.write_str(")")?; 3553 Ok(()) 3554 } 3555 } 3556 formatter.field("lifetimes", Print::ref_cast(val)); 3557 } 3558 formatter.field("bounded_ty", Lite(&self.value.bounded_ty)); 3559 if !self.value.bounds.is_empty() { 3560 formatter.field("bounds", Lite(&self.value.bounds)); 3561 } 3562 formatter.finish() 3563 } 3564 } 3565 impl Debug for Lite<syn::QSelf> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result3566 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3567 let mut formatter = formatter.debug_struct("QSelf"); 3568 formatter.field("ty", Lite(&self.value.ty)); 3569 formatter.field("position", Lite(&self.value.position)); 3570 if self.value.as_token.is_some() { 3571 formatter.field("as_token", &Present); 3572 } 3573 formatter.finish() 3574 } 3575 } 3576 impl Debug for Lite<syn::RangeLimits> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result3577 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3578 match &self.value { 3579 syn::RangeLimits::HalfOpen(_val) => { 3580 formatter.write_str("RangeLimits::HalfOpen")?; 3581 Ok(()) 3582 } 3583 syn::RangeLimits::Closed(_val) => { 3584 formatter.write_str("RangeLimits::Closed")?; 3585 Ok(()) 3586 } 3587 } 3588 } 3589 } 3590 impl Debug for Lite<syn::Receiver> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result3591 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3592 let mut formatter = formatter.debug_struct("Receiver"); 3593 if !self.value.attrs.is_empty() { 3594 formatter.field("attrs", Lite(&self.value.attrs)); 3595 } 3596 if let Some(val) = &self.value.reference { 3597 #[derive(RefCast)] 3598 #[repr(transparent)] 3599 struct Print((syn::token::And, Option<syn::Lifetime>)); 3600 impl Debug for Print { 3601 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3602 formatter.write_str("Some(")?; 3603 Debug::fmt( 3604 { 3605 #[derive(RefCast)] 3606 #[repr(transparent)] 3607 struct Print(Option<syn::Lifetime>); 3608 impl Debug for Print { 3609 fn fmt( 3610 &self, 3611 formatter: &mut fmt::Formatter, 3612 ) -> fmt::Result { 3613 match &self.0 { 3614 Some(_val) => { 3615 formatter.write_str("Some(")?; 3616 Debug::fmt(Lite(_val), formatter)?; 3617 formatter.write_str(")")?; 3618 Ok(()) 3619 } 3620 None => formatter.write_str("None"), 3621 } 3622 } 3623 } 3624 Print::ref_cast(&self.0.1) 3625 }, 3626 formatter, 3627 )?; 3628 formatter.write_str(")")?; 3629 Ok(()) 3630 } 3631 } 3632 formatter.field("reference", Print::ref_cast(val)); 3633 } 3634 if self.value.mutability.is_some() { 3635 formatter.field("mutability", &Present); 3636 } 3637 if self.value.colon_token.is_some() { 3638 formatter.field("colon_token", &Present); 3639 } 3640 formatter.field("ty", Lite(&self.value.ty)); 3641 formatter.finish() 3642 } 3643 } 3644 impl Debug for Lite<syn::ReturnType> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result3645 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3646 match &self.value { 3647 syn::ReturnType::Default => formatter.write_str("ReturnType::Default"), 3648 syn::ReturnType::Type(_v0, _v1) => { 3649 let mut formatter = formatter.debug_tuple("ReturnType::Type"); 3650 formatter.field(Lite(_v1)); 3651 formatter.finish() 3652 } 3653 } 3654 } 3655 } 3656 impl Debug for Lite<syn::Signature> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result3657 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3658 let mut formatter = formatter.debug_struct("Signature"); 3659 if self.value.constness.is_some() { 3660 formatter.field("constness", &Present); 3661 } 3662 if self.value.asyncness.is_some() { 3663 formatter.field("asyncness", &Present); 3664 } 3665 if self.value.unsafety.is_some() { 3666 formatter.field("unsafety", &Present); 3667 } 3668 if let Some(val) = &self.value.abi { 3669 #[derive(RefCast)] 3670 #[repr(transparent)] 3671 struct Print(syn::Abi); 3672 impl Debug for Print { 3673 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3674 formatter.write_str("Some(")?; 3675 Debug::fmt(Lite(&self.0), formatter)?; 3676 formatter.write_str(")")?; 3677 Ok(()) 3678 } 3679 } 3680 formatter.field("abi", Print::ref_cast(val)); 3681 } 3682 formatter.field("ident", Lite(&self.value.ident)); 3683 formatter.field("generics", Lite(&self.value.generics)); 3684 if !self.value.inputs.is_empty() { 3685 formatter.field("inputs", Lite(&self.value.inputs)); 3686 } 3687 if let Some(val) = &self.value.variadic { 3688 #[derive(RefCast)] 3689 #[repr(transparent)] 3690 struct Print(syn::Variadic); 3691 impl Debug for Print { 3692 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3693 formatter.write_str("Some(")?; 3694 Debug::fmt(Lite(&self.0), formatter)?; 3695 formatter.write_str(")")?; 3696 Ok(()) 3697 } 3698 } 3699 formatter.field("variadic", Print::ref_cast(val)); 3700 } 3701 formatter.field("output", Lite(&self.value.output)); 3702 formatter.finish() 3703 } 3704 } 3705 impl Debug for Lite<syn::StaticMutability> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result3706 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3707 match &self.value { 3708 syn::StaticMutability::Mut(_val) => { 3709 formatter.write_str("StaticMutability::Mut")?; 3710 Ok(()) 3711 } 3712 syn::StaticMutability::None => formatter.write_str("StaticMutability::None"), 3713 _ => unreachable!(), 3714 } 3715 } 3716 } 3717 impl Debug for Lite<syn::Stmt> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result3718 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3719 match &self.value { 3720 syn::Stmt::Local(_val) => { 3721 let mut formatter = formatter.debug_struct("Stmt::Local"); 3722 if !_val.attrs.is_empty() { 3723 formatter.field("attrs", Lite(&_val.attrs)); 3724 } 3725 formatter.field("pat", Lite(&_val.pat)); 3726 if let Some(val) = &_val.init { 3727 #[derive(RefCast)] 3728 #[repr(transparent)] 3729 struct Print(syn::LocalInit); 3730 impl Debug for Print { 3731 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3732 formatter.write_str("Some(")?; 3733 Debug::fmt(Lite(&self.0), formatter)?; 3734 formatter.write_str(")")?; 3735 Ok(()) 3736 } 3737 } 3738 formatter.field("init", Print::ref_cast(val)); 3739 } 3740 formatter.finish() 3741 } 3742 syn::Stmt::Item(_val) => { 3743 formatter.write_str("Stmt::Item")?; 3744 formatter.write_str("(")?; 3745 Debug::fmt(Lite(_val), formatter)?; 3746 formatter.write_str(")")?; 3747 Ok(()) 3748 } 3749 syn::Stmt::Expr(_v0, _v1) => { 3750 let mut formatter = formatter.debug_tuple("Stmt::Expr"); 3751 formatter.field(Lite(_v0)); 3752 formatter 3753 .field( 3754 &super::Option { 3755 present: _v1.is_some(), 3756 }, 3757 ); 3758 formatter.finish() 3759 } 3760 syn::Stmt::Macro(_val) => { 3761 let mut formatter = formatter.debug_struct("Stmt::Macro"); 3762 if !_val.attrs.is_empty() { 3763 formatter.field("attrs", Lite(&_val.attrs)); 3764 } 3765 formatter.field("mac", Lite(&_val.mac)); 3766 if _val.semi_token.is_some() { 3767 formatter.field("semi_token", &Present); 3768 } 3769 formatter.finish() 3770 } 3771 } 3772 } 3773 } 3774 impl Debug for Lite<syn::StmtMacro> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result3775 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3776 let mut formatter = formatter.debug_struct("StmtMacro"); 3777 if !self.value.attrs.is_empty() { 3778 formatter.field("attrs", Lite(&self.value.attrs)); 3779 } 3780 formatter.field("mac", Lite(&self.value.mac)); 3781 if self.value.semi_token.is_some() { 3782 formatter.field("semi_token", &Present); 3783 } 3784 formatter.finish() 3785 } 3786 } 3787 impl Debug for Lite<syn::TraitBound> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result3788 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3789 let mut formatter = formatter.debug_struct("TraitBound"); 3790 if self.value.paren_token.is_some() { 3791 formatter.field("paren_token", &Present); 3792 } 3793 match self.value.modifier { 3794 syn::TraitBoundModifier::None => {} 3795 _ => { 3796 formatter.field("modifier", Lite(&self.value.modifier)); 3797 } 3798 } 3799 if let Some(val) = &self.value.lifetimes { 3800 #[derive(RefCast)] 3801 #[repr(transparent)] 3802 struct Print(syn::BoundLifetimes); 3803 impl Debug for Print { 3804 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3805 formatter.write_str("Some(")?; 3806 Debug::fmt(Lite(&self.0), formatter)?; 3807 formatter.write_str(")")?; 3808 Ok(()) 3809 } 3810 } 3811 formatter.field("lifetimes", Print::ref_cast(val)); 3812 } 3813 formatter.field("path", Lite(&self.value.path)); 3814 formatter.finish() 3815 } 3816 } 3817 impl Debug for Lite<syn::TraitBoundModifier> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result3818 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3819 match &self.value { 3820 syn::TraitBoundModifier::None => { 3821 formatter.write_str("TraitBoundModifier::None") 3822 } 3823 syn::TraitBoundModifier::Maybe(_val) => { 3824 formatter.write_str("TraitBoundModifier::Maybe")?; 3825 Ok(()) 3826 } 3827 } 3828 } 3829 } 3830 impl Debug for Lite<syn::TraitItem> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result3831 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3832 match &self.value { 3833 syn::TraitItem::Const(_val) => { 3834 let mut formatter = formatter.debug_struct("TraitItem::Const"); 3835 if !_val.attrs.is_empty() { 3836 formatter.field("attrs", Lite(&_val.attrs)); 3837 } 3838 formatter.field("ident", Lite(&_val.ident)); 3839 formatter.field("generics", Lite(&_val.generics)); 3840 formatter.field("ty", Lite(&_val.ty)); 3841 if let Some(val) = &_val.default { 3842 #[derive(RefCast)] 3843 #[repr(transparent)] 3844 struct Print((syn::token::Eq, syn::Expr)); 3845 impl Debug for Print { 3846 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3847 formatter.write_str("Some(")?; 3848 Debug::fmt(Lite(&self.0.1), formatter)?; 3849 formatter.write_str(")")?; 3850 Ok(()) 3851 } 3852 } 3853 formatter.field("default", Print::ref_cast(val)); 3854 } 3855 formatter.finish() 3856 } 3857 syn::TraitItem::Fn(_val) => { 3858 let mut formatter = formatter.debug_struct("TraitItem::Fn"); 3859 if !_val.attrs.is_empty() { 3860 formatter.field("attrs", Lite(&_val.attrs)); 3861 } 3862 formatter.field("sig", Lite(&_val.sig)); 3863 if let Some(val) = &_val.default { 3864 #[derive(RefCast)] 3865 #[repr(transparent)] 3866 struct Print(syn::Block); 3867 impl Debug for Print { 3868 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3869 formatter.write_str("Some(")?; 3870 Debug::fmt(Lite(&self.0), formatter)?; 3871 formatter.write_str(")")?; 3872 Ok(()) 3873 } 3874 } 3875 formatter.field("default", Print::ref_cast(val)); 3876 } 3877 if _val.semi_token.is_some() { 3878 formatter.field("semi_token", &Present); 3879 } 3880 formatter.finish() 3881 } 3882 syn::TraitItem::Type(_val) => { 3883 let mut formatter = formatter.debug_struct("TraitItem::Type"); 3884 if !_val.attrs.is_empty() { 3885 formatter.field("attrs", Lite(&_val.attrs)); 3886 } 3887 formatter.field("ident", Lite(&_val.ident)); 3888 formatter.field("generics", Lite(&_val.generics)); 3889 if _val.colon_token.is_some() { 3890 formatter.field("colon_token", &Present); 3891 } 3892 if !_val.bounds.is_empty() { 3893 formatter.field("bounds", Lite(&_val.bounds)); 3894 } 3895 if let Some(val) = &_val.default { 3896 #[derive(RefCast)] 3897 #[repr(transparent)] 3898 struct Print((syn::token::Eq, syn::Type)); 3899 impl Debug for Print { 3900 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3901 formatter.write_str("Some(")?; 3902 Debug::fmt(Lite(&self.0.1), formatter)?; 3903 formatter.write_str(")")?; 3904 Ok(()) 3905 } 3906 } 3907 formatter.field("default", Print::ref_cast(val)); 3908 } 3909 formatter.finish() 3910 } 3911 syn::TraitItem::Macro(_val) => { 3912 let mut formatter = formatter.debug_struct("TraitItem::Macro"); 3913 if !_val.attrs.is_empty() { 3914 formatter.field("attrs", Lite(&_val.attrs)); 3915 } 3916 formatter.field("mac", Lite(&_val.mac)); 3917 if _val.semi_token.is_some() { 3918 formatter.field("semi_token", &Present); 3919 } 3920 formatter.finish() 3921 } 3922 syn::TraitItem::Verbatim(_val) => { 3923 formatter.write_str("TraitItem::Verbatim")?; 3924 formatter.write_str("(`")?; 3925 Display::fmt(_val, formatter)?; 3926 formatter.write_str("`)")?; 3927 Ok(()) 3928 } 3929 _ => unreachable!(), 3930 } 3931 } 3932 } 3933 impl Debug for Lite<syn::TraitItemConst> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result3934 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3935 let mut formatter = formatter.debug_struct("TraitItemConst"); 3936 if !self.value.attrs.is_empty() { 3937 formatter.field("attrs", Lite(&self.value.attrs)); 3938 } 3939 formatter.field("ident", Lite(&self.value.ident)); 3940 formatter.field("generics", Lite(&self.value.generics)); 3941 formatter.field("ty", Lite(&self.value.ty)); 3942 if let Some(val) = &self.value.default { 3943 #[derive(RefCast)] 3944 #[repr(transparent)] 3945 struct Print((syn::token::Eq, syn::Expr)); 3946 impl Debug for Print { 3947 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3948 formatter.write_str("Some(")?; 3949 Debug::fmt(Lite(&self.0.1), formatter)?; 3950 formatter.write_str(")")?; 3951 Ok(()) 3952 } 3953 } 3954 formatter.field("default", Print::ref_cast(val)); 3955 } 3956 formatter.finish() 3957 } 3958 } 3959 impl Debug for Lite<syn::TraitItemFn> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result3960 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3961 let mut formatter = formatter.debug_struct("TraitItemFn"); 3962 if !self.value.attrs.is_empty() { 3963 formatter.field("attrs", Lite(&self.value.attrs)); 3964 } 3965 formatter.field("sig", Lite(&self.value.sig)); 3966 if let Some(val) = &self.value.default { 3967 #[derive(RefCast)] 3968 #[repr(transparent)] 3969 struct Print(syn::Block); 3970 impl Debug for Print { 3971 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3972 formatter.write_str("Some(")?; 3973 Debug::fmt(Lite(&self.0), formatter)?; 3974 formatter.write_str(")")?; 3975 Ok(()) 3976 } 3977 } 3978 formatter.field("default", Print::ref_cast(val)); 3979 } 3980 if self.value.semi_token.is_some() { 3981 formatter.field("semi_token", &Present); 3982 } 3983 formatter.finish() 3984 } 3985 } 3986 impl Debug for Lite<syn::TraitItemMacro> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result3987 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 3988 let mut formatter = formatter.debug_struct("TraitItemMacro"); 3989 if !self.value.attrs.is_empty() { 3990 formatter.field("attrs", Lite(&self.value.attrs)); 3991 } 3992 formatter.field("mac", Lite(&self.value.mac)); 3993 if self.value.semi_token.is_some() { 3994 formatter.field("semi_token", &Present); 3995 } 3996 formatter.finish() 3997 } 3998 } 3999 impl Debug for Lite<syn::TraitItemType> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result4000 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4001 let mut formatter = formatter.debug_struct("TraitItemType"); 4002 if !self.value.attrs.is_empty() { 4003 formatter.field("attrs", Lite(&self.value.attrs)); 4004 } 4005 formatter.field("ident", Lite(&self.value.ident)); 4006 formatter.field("generics", Lite(&self.value.generics)); 4007 if self.value.colon_token.is_some() { 4008 formatter.field("colon_token", &Present); 4009 } 4010 if !self.value.bounds.is_empty() { 4011 formatter.field("bounds", Lite(&self.value.bounds)); 4012 } 4013 if let Some(val) = &self.value.default { 4014 #[derive(RefCast)] 4015 #[repr(transparent)] 4016 struct Print((syn::token::Eq, syn::Type)); 4017 impl Debug for Print { 4018 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4019 formatter.write_str("Some(")?; 4020 Debug::fmt(Lite(&self.0.1), formatter)?; 4021 formatter.write_str(")")?; 4022 Ok(()) 4023 } 4024 } 4025 formatter.field("default", Print::ref_cast(val)); 4026 } 4027 formatter.finish() 4028 } 4029 } 4030 impl Debug for Lite<syn::Type> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result4031 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4032 match &self.value { 4033 syn::Type::Array(_val) => { 4034 let mut formatter = formatter.debug_struct("Type::Array"); 4035 formatter.field("elem", Lite(&_val.elem)); 4036 formatter.field("len", Lite(&_val.len)); 4037 formatter.finish() 4038 } 4039 syn::Type::BareFn(_val) => { 4040 let mut formatter = formatter.debug_struct("Type::BareFn"); 4041 if let Some(val) = &_val.lifetimes { 4042 #[derive(RefCast)] 4043 #[repr(transparent)] 4044 struct Print(syn::BoundLifetimes); 4045 impl Debug for Print { 4046 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4047 formatter.write_str("Some(")?; 4048 Debug::fmt(Lite(&self.0), formatter)?; 4049 formatter.write_str(")")?; 4050 Ok(()) 4051 } 4052 } 4053 formatter.field("lifetimes", Print::ref_cast(val)); 4054 } 4055 if _val.unsafety.is_some() { 4056 formatter.field("unsafety", &Present); 4057 } 4058 if let Some(val) = &_val.abi { 4059 #[derive(RefCast)] 4060 #[repr(transparent)] 4061 struct Print(syn::Abi); 4062 impl Debug for Print { 4063 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4064 formatter.write_str("Some(")?; 4065 Debug::fmt(Lite(&self.0), formatter)?; 4066 formatter.write_str(")")?; 4067 Ok(()) 4068 } 4069 } 4070 formatter.field("abi", Print::ref_cast(val)); 4071 } 4072 if !_val.inputs.is_empty() { 4073 formatter.field("inputs", Lite(&_val.inputs)); 4074 } 4075 if let Some(val) = &_val.variadic { 4076 #[derive(RefCast)] 4077 #[repr(transparent)] 4078 struct Print(syn::BareVariadic); 4079 impl Debug for Print { 4080 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4081 formatter.write_str("Some(")?; 4082 Debug::fmt(Lite(&self.0), formatter)?; 4083 formatter.write_str(")")?; 4084 Ok(()) 4085 } 4086 } 4087 formatter.field("variadic", Print::ref_cast(val)); 4088 } 4089 formatter.field("output", Lite(&_val.output)); 4090 formatter.finish() 4091 } 4092 syn::Type::Group(_val) => { 4093 let mut formatter = formatter.debug_struct("Type::Group"); 4094 formatter.field("elem", Lite(&_val.elem)); 4095 formatter.finish() 4096 } 4097 syn::Type::ImplTrait(_val) => { 4098 let mut formatter = formatter.debug_struct("Type::ImplTrait"); 4099 if !_val.bounds.is_empty() { 4100 formatter.field("bounds", Lite(&_val.bounds)); 4101 } 4102 formatter.finish() 4103 } 4104 syn::Type::Infer(_val) => { 4105 let mut formatter = formatter.debug_struct("Type::Infer"); 4106 formatter.finish() 4107 } 4108 syn::Type::Macro(_val) => { 4109 let mut formatter = formatter.debug_struct("Type::Macro"); 4110 formatter.field("mac", Lite(&_val.mac)); 4111 formatter.finish() 4112 } 4113 syn::Type::Never(_val) => { 4114 let mut formatter = formatter.debug_struct("Type::Never"); 4115 formatter.finish() 4116 } 4117 syn::Type::Paren(_val) => { 4118 let mut formatter = formatter.debug_struct("Type::Paren"); 4119 formatter.field("elem", Lite(&_val.elem)); 4120 formatter.finish() 4121 } 4122 syn::Type::Path(_val) => { 4123 let mut formatter = formatter.debug_struct("Type::Path"); 4124 if let Some(val) = &_val.qself { 4125 #[derive(RefCast)] 4126 #[repr(transparent)] 4127 struct Print(syn::QSelf); 4128 impl Debug for Print { 4129 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4130 formatter.write_str("Some(")?; 4131 Debug::fmt(Lite(&self.0), formatter)?; 4132 formatter.write_str(")")?; 4133 Ok(()) 4134 } 4135 } 4136 formatter.field("qself", Print::ref_cast(val)); 4137 } 4138 formatter.field("path", Lite(&_val.path)); 4139 formatter.finish() 4140 } 4141 syn::Type::Ptr(_val) => { 4142 let mut formatter = formatter.debug_struct("Type::Ptr"); 4143 if _val.const_token.is_some() { 4144 formatter.field("const_token", &Present); 4145 } 4146 if _val.mutability.is_some() { 4147 formatter.field("mutability", &Present); 4148 } 4149 formatter.field("elem", Lite(&_val.elem)); 4150 formatter.finish() 4151 } 4152 syn::Type::Reference(_val) => { 4153 let mut formatter = formatter.debug_struct("Type::Reference"); 4154 if let Some(val) = &_val.lifetime { 4155 #[derive(RefCast)] 4156 #[repr(transparent)] 4157 struct Print(syn::Lifetime); 4158 impl Debug for Print { 4159 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4160 formatter.write_str("Some(")?; 4161 Debug::fmt(Lite(&self.0), formatter)?; 4162 formatter.write_str(")")?; 4163 Ok(()) 4164 } 4165 } 4166 formatter.field("lifetime", Print::ref_cast(val)); 4167 } 4168 if _val.mutability.is_some() { 4169 formatter.field("mutability", &Present); 4170 } 4171 formatter.field("elem", Lite(&_val.elem)); 4172 formatter.finish() 4173 } 4174 syn::Type::Slice(_val) => { 4175 let mut formatter = formatter.debug_struct("Type::Slice"); 4176 formatter.field("elem", Lite(&_val.elem)); 4177 formatter.finish() 4178 } 4179 syn::Type::TraitObject(_val) => { 4180 let mut formatter = formatter.debug_struct("Type::TraitObject"); 4181 if _val.dyn_token.is_some() { 4182 formatter.field("dyn_token", &Present); 4183 } 4184 if !_val.bounds.is_empty() { 4185 formatter.field("bounds", Lite(&_val.bounds)); 4186 } 4187 formatter.finish() 4188 } 4189 syn::Type::Tuple(_val) => { 4190 let mut formatter = formatter.debug_struct("Type::Tuple"); 4191 if !_val.elems.is_empty() { 4192 formatter.field("elems", Lite(&_val.elems)); 4193 } 4194 formatter.finish() 4195 } 4196 syn::Type::Verbatim(_val) => { 4197 formatter.write_str("Type::Verbatim")?; 4198 formatter.write_str("(`")?; 4199 Display::fmt(_val, formatter)?; 4200 formatter.write_str("`)")?; 4201 Ok(()) 4202 } 4203 _ => unreachable!(), 4204 } 4205 } 4206 } 4207 impl Debug for Lite<syn::TypeArray> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result4208 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4209 let mut formatter = formatter.debug_struct("TypeArray"); 4210 formatter.field("elem", Lite(&self.value.elem)); 4211 formatter.field("len", Lite(&self.value.len)); 4212 formatter.finish() 4213 } 4214 } 4215 impl Debug for Lite<syn::TypeBareFn> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result4216 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4217 let mut formatter = formatter.debug_struct("TypeBareFn"); 4218 if let Some(val) = &self.value.lifetimes { 4219 #[derive(RefCast)] 4220 #[repr(transparent)] 4221 struct Print(syn::BoundLifetimes); 4222 impl Debug for Print { 4223 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4224 formatter.write_str("Some(")?; 4225 Debug::fmt(Lite(&self.0), formatter)?; 4226 formatter.write_str(")")?; 4227 Ok(()) 4228 } 4229 } 4230 formatter.field("lifetimes", Print::ref_cast(val)); 4231 } 4232 if self.value.unsafety.is_some() { 4233 formatter.field("unsafety", &Present); 4234 } 4235 if let Some(val) = &self.value.abi { 4236 #[derive(RefCast)] 4237 #[repr(transparent)] 4238 struct Print(syn::Abi); 4239 impl Debug for Print { 4240 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4241 formatter.write_str("Some(")?; 4242 Debug::fmt(Lite(&self.0), formatter)?; 4243 formatter.write_str(")")?; 4244 Ok(()) 4245 } 4246 } 4247 formatter.field("abi", Print::ref_cast(val)); 4248 } 4249 if !self.value.inputs.is_empty() { 4250 formatter.field("inputs", Lite(&self.value.inputs)); 4251 } 4252 if let Some(val) = &self.value.variadic { 4253 #[derive(RefCast)] 4254 #[repr(transparent)] 4255 struct Print(syn::BareVariadic); 4256 impl Debug for Print { 4257 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4258 formatter.write_str("Some(")?; 4259 Debug::fmt(Lite(&self.0), formatter)?; 4260 formatter.write_str(")")?; 4261 Ok(()) 4262 } 4263 } 4264 formatter.field("variadic", Print::ref_cast(val)); 4265 } 4266 formatter.field("output", Lite(&self.value.output)); 4267 formatter.finish() 4268 } 4269 } 4270 impl Debug for Lite<syn::TypeGroup> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result4271 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4272 let mut formatter = formatter.debug_struct("TypeGroup"); 4273 formatter.field("elem", Lite(&self.value.elem)); 4274 formatter.finish() 4275 } 4276 } 4277 impl Debug for Lite<syn::TypeImplTrait> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result4278 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4279 let mut formatter = formatter.debug_struct("TypeImplTrait"); 4280 if !self.value.bounds.is_empty() { 4281 formatter.field("bounds", Lite(&self.value.bounds)); 4282 } 4283 formatter.finish() 4284 } 4285 } 4286 impl Debug for Lite<syn::TypeInfer> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result4287 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4288 let mut formatter = formatter.debug_struct("TypeInfer"); 4289 formatter.finish() 4290 } 4291 } 4292 impl Debug for Lite<syn::TypeMacro> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result4293 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4294 let mut formatter = formatter.debug_struct("TypeMacro"); 4295 formatter.field("mac", Lite(&self.value.mac)); 4296 formatter.finish() 4297 } 4298 } 4299 impl Debug for Lite<syn::TypeNever> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result4300 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4301 let mut formatter = formatter.debug_struct("TypeNever"); 4302 formatter.finish() 4303 } 4304 } 4305 impl Debug for Lite<syn::TypeParam> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result4306 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4307 let mut formatter = formatter.debug_struct("TypeParam"); 4308 if !self.value.attrs.is_empty() { 4309 formatter.field("attrs", Lite(&self.value.attrs)); 4310 } 4311 formatter.field("ident", Lite(&self.value.ident)); 4312 if self.value.colon_token.is_some() { 4313 formatter.field("colon_token", &Present); 4314 } 4315 if !self.value.bounds.is_empty() { 4316 formatter.field("bounds", Lite(&self.value.bounds)); 4317 } 4318 if self.value.eq_token.is_some() { 4319 formatter.field("eq_token", &Present); 4320 } 4321 if let Some(val) = &self.value.default { 4322 #[derive(RefCast)] 4323 #[repr(transparent)] 4324 struct Print(syn::Type); 4325 impl Debug for Print { 4326 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4327 formatter.write_str("Some(")?; 4328 Debug::fmt(Lite(&self.0), formatter)?; 4329 formatter.write_str(")")?; 4330 Ok(()) 4331 } 4332 } 4333 formatter.field("default", Print::ref_cast(val)); 4334 } 4335 formatter.finish() 4336 } 4337 } 4338 impl Debug for Lite<syn::TypeParamBound> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result4339 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4340 match &self.value { 4341 syn::TypeParamBound::Trait(_val) => { 4342 formatter.write_str("TypeParamBound::Trait")?; 4343 formatter.write_str("(")?; 4344 Debug::fmt(Lite(_val), formatter)?; 4345 formatter.write_str(")")?; 4346 Ok(()) 4347 } 4348 syn::TypeParamBound::Lifetime(_val) => { 4349 let mut formatter = formatter.debug_struct("TypeParamBound::Lifetime"); 4350 formatter.field("ident", Lite(&_val.ident)); 4351 formatter.finish() 4352 } 4353 syn::TypeParamBound::Verbatim(_val) => { 4354 formatter.write_str("TypeParamBound::Verbatim")?; 4355 formatter.write_str("(`")?; 4356 Display::fmt(_val, formatter)?; 4357 formatter.write_str("`)")?; 4358 Ok(()) 4359 } 4360 _ => unreachable!(), 4361 } 4362 } 4363 } 4364 impl Debug for Lite<syn::TypeParen> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result4365 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4366 let mut formatter = formatter.debug_struct("TypeParen"); 4367 formatter.field("elem", Lite(&self.value.elem)); 4368 formatter.finish() 4369 } 4370 } 4371 impl Debug for Lite<syn::TypePath> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result4372 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4373 let mut formatter = formatter.debug_struct("TypePath"); 4374 if let Some(val) = &self.value.qself { 4375 #[derive(RefCast)] 4376 #[repr(transparent)] 4377 struct Print(syn::QSelf); 4378 impl Debug for Print { 4379 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4380 formatter.write_str("Some(")?; 4381 Debug::fmt(Lite(&self.0), formatter)?; 4382 formatter.write_str(")")?; 4383 Ok(()) 4384 } 4385 } 4386 formatter.field("qself", Print::ref_cast(val)); 4387 } 4388 formatter.field("path", Lite(&self.value.path)); 4389 formatter.finish() 4390 } 4391 } 4392 impl Debug for Lite<syn::TypePtr> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result4393 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4394 let mut formatter = formatter.debug_struct("TypePtr"); 4395 if self.value.const_token.is_some() { 4396 formatter.field("const_token", &Present); 4397 } 4398 if self.value.mutability.is_some() { 4399 formatter.field("mutability", &Present); 4400 } 4401 formatter.field("elem", Lite(&self.value.elem)); 4402 formatter.finish() 4403 } 4404 } 4405 impl Debug for Lite<syn::TypeReference> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result4406 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4407 let mut formatter = formatter.debug_struct("TypeReference"); 4408 if let Some(val) = &self.value.lifetime { 4409 #[derive(RefCast)] 4410 #[repr(transparent)] 4411 struct Print(syn::Lifetime); 4412 impl Debug for Print { 4413 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4414 formatter.write_str("Some(")?; 4415 Debug::fmt(Lite(&self.0), formatter)?; 4416 formatter.write_str(")")?; 4417 Ok(()) 4418 } 4419 } 4420 formatter.field("lifetime", Print::ref_cast(val)); 4421 } 4422 if self.value.mutability.is_some() { 4423 formatter.field("mutability", &Present); 4424 } 4425 formatter.field("elem", Lite(&self.value.elem)); 4426 formatter.finish() 4427 } 4428 } 4429 impl Debug for Lite<syn::TypeSlice> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result4430 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4431 let mut formatter = formatter.debug_struct("TypeSlice"); 4432 formatter.field("elem", Lite(&self.value.elem)); 4433 formatter.finish() 4434 } 4435 } 4436 impl Debug for Lite<syn::TypeTraitObject> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result4437 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4438 let mut formatter = formatter.debug_struct("TypeTraitObject"); 4439 if self.value.dyn_token.is_some() { 4440 formatter.field("dyn_token", &Present); 4441 } 4442 if !self.value.bounds.is_empty() { 4443 formatter.field("bounds", Lite(&self.value.bounds)); 4444 } 4445 formatter.finish() 4446 } 4447 } 4448 impl Debug for Lite<syn::TypeTuple> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result4449 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4450 let mut formatter = formatter.debug_struct("TypeTuple"); 4451 if !self.value.elems.is_empty() { 4452 formatter.field("elems", Lite(&self.value.elems)); 4453 } 4454 formatter.finish() 4455 } 4456 } 4457 impl Debug for Lite<syn::UnOp> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result4458 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4459 match &self.value { 4460 syn::UnOp::Deref(_val) => { 4461 formatter.write_str("UnOp::Deref")?; 4462 Ok(()) 4463 } 4464 syn::UnOp::Not(_val) => { 4465 formatter.write_str("UnOp::Not")?; 4466 Ok(()) 4467 } 4468 syn::UnOp::Neg(_val) => { 4469 formatter.write_str("UnOp::Neg")?; 4470 Ok(()) 4471 } 4472 _ => unreachable!(), 4473 } 4474 } 4475 } 4476 impl Debug for Lite<syn::UseGlob> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result4477 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4478 let mut formatter = formatter.debug_struct("UseGlob"); 4479 formatter.finish() 4480 } 4481 } 4482 impl Debug for Lite<syn::UseGroup> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result4483 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4484 let mut formatter = formatter.debug_struct("UseGroup"); 4485 if !self.value.items.is_empty() { 4486 formatter.field("items", Lite(&self.value.items)); 4487 } 4488 formatter.finish() 4489 } 4490 } 4491 impl Debug for Lite<syn::UseName> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result4492 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4493 let mut formatter = formatter.debug_struct("UseName"); 4494 formatter.field("ident", Lite(&self.value.ident)); 4495 formatter.finish() 4496 } 4497 } 4498 impl Debug for Lite<syn::UsePath> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result4499 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4500 let mut formatter = formatter.debug_struct("UsePath"); 4501 formatter.field("ident", Lite(&self.value.ident)); 4502 formatter.field("tree", Lite(&self.value.tree)); 4503 formatter.finish() 4504 } 4505 } 4506 impl Debug for Lite<syn::UseRename> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result4507 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4508 let mut formatter = formatter.debug_struct("UseRename"); 4509 formatter.field("ident", Lite(&self.value.ident)); 4510 formatter.field("rename", Lite(&self.value.rename)); 4511 formatter.finish() 4512 } 4513 } 4514 impl Debug for Lite<syn::UseTree> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result4515 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4516 match &self.value { 4517 syn::UseTree::Path(_val) => { 4518 formatter.write_str("UseTree::Path")?; 4519 formatter.write_str("(")?; 4520 Debug::fmt(Lite(_val), formatter)?; 4521 formatter.write_str(")")?; 4522 Ok(()) 4523 } 4524 syn::UseTree::Name(_val) => { 4525 formatter.write_str("UseTree::Name")?; 4526 formatter.write_str("(")?; 4527 Debug::fmt(Lite(_val), formatter)?; 4528 formatter.write_str(")")?; 4529 Ok(()) 4530 } 4531 syn::UseTree::Rename(_val) => { 4532 formatter.write_str("UseTree::Rename")?; 4533 formatter.write_str("(")?; 4534 Debug::fmt(Lite(_val), formatter)?; 4535 formatter.write_str(")")?; 4536 Ok(()) 4537 } 4538 syn::UseTree::Glob(_val) => { 4539 formatter.write_str("UseTree::Glob")?; 4540 formatter.write_str("(")?; 4541 Debug::fmt(Lite(_val), formatter)?; 4542 formatter.write_str(")")?; 4543 Ok(()) 4544 } 4545 syn::UseTree::Group(_val) => { 4546 formatter.write_str("UseTree::Group")?; 4547 formatter.write_str("(")?; 4548 Debug::fmt(Lite(_val), formatter)?; 4549 formatter.write_str(")")?; 4550 Ok(()) 4551 } 4552 } 4553 } 4554 } 4555 impl Debug for Lite<syn::Variadic> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result4556 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4557 let mut formatter = formatter.debug_struct("Variadic"); 4558 if !self.value.attrs.is_empty() { 4559 formatter.field("attrs", Lite(&self.value.attrs)); 4560 } 4561 if let Some(val) = &self.value.pat { 4562 #[derive(RefCast)] 4563 #[repr(transparent)] 4564 struct Print((Box<syn::Pat>, syn::token::Colon)); 4565 impl Debug for Print { 4566 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4567 formatter.write_str("Some(")?; 4568 Debug::fmt(Lite(&self.0.0), formatter)?; 4569 formatter.write_str(")")?; 4570 Ok(()) 4571 } 4572 } 4573 formatter.field("pat", Print::ref_cast(val)); 4574 } 4575 if self.value.comma.is_some() { 4576 formatter.field("comma", &Present); 4577 } 4578 formatter.finish() 4579 } 4580 } 4581 impl Debug for Lite<syn::Variant> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result4582 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4583 let mut formatter = formatter.debug_struct("Variant"); 4584 if !self.value.attrs.is_empty() { 4585 formatter.field("attrs", Lite(&self.value.attrs)); 4586 } 4587 formatter.field("ident", Lite(&self.value.ident)); 4588 formatter.field("fields", Lite(&self.value.fields)); 4589 if let Some(val) = &self.value.discriminant { 4590 #[derive(RefCast)] 4591 #[repr(transparent)] 4592 struct Print((syn::token::Eq, syn::Expr)); 4593 impl Debug for Print { 4594 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4595 formatter.write_str("Some(")?; 4596 Debug::fmt(Lite(&self.0.1), formatter)?; 4597 formatter.write_str(")")?; 4598 Ok(()) 4599 } 4600 } 4601 formatter.field("discriminant", Print::ref_cast(val)); 4602 } 4603 formatter.finish() 4604 } 4605 } 4606 impl Debug for Lite<syn::VisRestricted> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result4607 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4608 let mut formatter = formatter.debug_struct("VisRestricted"); 4609 if self.value.in_token.is_some() { 4610 formatter.field("in_token", &Present); 4611 } 4612 formatter.field("path", Lite(&self.value.path)); 4613 formatter.finish() 4614 } 4615 } 4616 impl Debug for Lite<syn::Visibility> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result4617 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4618 match &self.value { 4619 syn::Visibility::Public(_val) => { 4620 formatter.write_str("Visibility::Public")?; 4621 Ok(()) 4622 } 4623 syn::Visibility::Restricted(_val) => { 4624 let mut formatter = formatter.debug_struct("Visibility::Restricted"); 4625 if _val.in_token.is_some() { 4626 formatter.field("in_token", &Present); 4627 } 4628 formatter.field("path", Lite(&_val.path)); 4629 formatter.finish() 4630 } 4631 syn::Visibility::Inherited => formatter.write_str("Visibility::Inherited"), 4632 } 4633 } 4634 } 4635 impl Debug for Lite<syn::WhereClause> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result4636 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4637 let mut formatter = formatter.debug_struct("WhereClause"); 4638 if !self.value.predicates.is_empty() { 4639 formatter.field("predicates", Lite(&self.value.predicates)); 4640 } 4641 formatter.finish() 4642 } 4643 } 4644 impl Debug for Lite<syn::WherePredicate> { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result4645 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 4646 match &self.value { 4647 syn::WherePredicate::Lifetime(_val) => { 4648 formatter.write_str("WherePredicate::Lifetime")?; 4649 formatter.write_str("(")?; 4650 Debug::fmt(Lite(_val), formatter)?; 4651 formatter.write_str(")")?; 4652 Ok(()) 4653 } 4654 syn::WherePredicate::Type(_val) => { 4655 formatter.write_str("WherePredicate::Type")?; 4656 formatter.write_str("(")?; 4657 Debug::fmt(Lite(_val), formatter)?; 4658 formatter.write_str(")")?; 4659 Ok(()) 4660 } 4661 _ => unreachable!(), 4662 } 4663 } 4664 } 4665