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