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