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