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