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