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