]> git.proxmox.com Git - cargo.git/blob - vendor/syn/tests/debug/gen.rs
projects / cargo.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
New upstream version 0.52.0
[cargo.git] / vendor / syn / tests / debug / gen.rs
1 // This file is @generated by syn-internal-codegen.
2 // It is not intended for manual editing.
3
4 use super::{Lite, RefCast};
5 use std::fmt::{self, Debug, Display};
6 impl Debug for Lite<syn::Abi> {
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 }
29 impl 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 }
51 impl 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 }
91 impl 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 }
103 impl 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 }
113 impl 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 }
140 impl 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 }
259 impl 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 }
268 impl 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 }
278 impl 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 }
288 impl 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 }
328 impl 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 }
339 impl 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 }
375 impl 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 }
385 impl 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 }
405 impl 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 }
413 impl 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 }
427 impl 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.asyncness {
595 #[derive(RefCast)]
596 #[repr(transparent)]
597 struct Print(syn::token::Async);
598 impl Debug for Print {
599 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
600 formatter.write_str("Some")?;
601 Ok(())
602 }
603 }
604 formatter.field("asyncness", Print::ref_cast(val));
605 }
606 if let Some(val) = &_val.movability {
607 #[derive(RefCast)]
608 #[repr(transparent)]
609 struct Print(syn::token::Static);
610 impl Debug for Print {
611 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
612 formatter.write_str("Some")?;
613 Ok(())
614 }
615 }
616 formatter.field("movability", Print::ref_cast(val));
617 }
618 if let Some(val) = &_val.capture {
619 #[derive(RefCast)]
620 #[repr(transparent)]
621 struct Print(syn::token::Move);
622 impl Debug for Print {
623 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
624 formatter.write_str("Some")?;
625 Ok(())
626 }
627 }
628 formatter.field("capture", Print::ref_cast(val));
629 }
630 if !_val.inputs.is_empty() {
631 formatter.field("inputs", Lite(&_val.inputs));
632 }
633 formatter.field("output", Lite(&_val.output));
634 formatter.field("body", Lite(&_val.body));
635 formatter.finish()
636 }
637 syn::Expr::Continue(_val) => {
638 let mut formatter = formatter.debug_struct("Expr::Continue");
639 if !_val.attrs.is_empty() {
640 formatter.field("attrs", Lite(&_val.attrs));
641 }
642 if let Some(val) = &_val.label {
643 #[derive(RefCast)]
644 #[repr(transparent)]
645 struct Print(syn::Lifetime);
646 impl Debug for Print {
647 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
648 formatter.write_str("Some")?;
649 let _val = &self.0;
650 formatter.write_str("(")?;
651 Debug::fmt(Lite(_val), formatter)?;
652 formatter.write_str(")")?;
653 Ok(())
654 }
655 }
656 formatter.field("label", Print::ref_cast(val));
657 }
658 formatter.finish()
659 }
660 syn::Expr::Field(_val) => {
661 let mut formatter = formatter.debug_struct("Expr::Field");
662 if !_val.attrs.is_empty() {
663 formatter.field("attrs", Lite(&_val.attrs));
664 }
665 formatter.field("base", Lite(&_val.base));
666 formatter.field("member", Lite(&_val.member));
667 formatter.finish()
668 }
669 syn::Expr::ForLoop(_val) => {
670 let mut formatter = formatter.debug_struct("Expr::ForLoop");
671 if !_val.attrs.is_empty() {
672 formatter.field("attrs", Lite(&_val.attrs));
673 }
674 if let Some(val) = &_val.label {
675 #[derive(RefCast)]
676 #[repr(transparent)]
677 struct Print(syn::Label);
678 impl Debug for Print {
679 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
680 formatter.write_str("Some")?;
681 let _val = &self.0;
682 formatter.write_str("(")?;
683 Debug::fmt(Lite(_val), formatter)?;
684 formatter.write_str(")")?;
685 Ok(())
686 }
687 }
688 formatter.field("label", Print::ref_cast(val));
689 }
690 formatter.field("pat", Lite(&_val.pat));
691 formatter.field("expr", Lite(&_val.expr));
692 formatter.field("body", Lite(&_val.body));
693 formatter.finish()
694 }
695 syn::Expr::Group(_val) => {
696 let mut formatter = formatter.debug_struct("Expr::Group");
697 if !_val.attrs.is_empty() {
698 formatter.field("attrs", Lite(&_val.attrs));
699 }
700 formatter.field("expr", Lite(&_val.expr));
701 formatter.finish()
702 }
703 syn::Expr::If(_val) => {
704 let mut formatter = formatter.debug_struct("Expr::If");
705 if !_val.attrs.is_empty() {
706 formatter.field("attrs", Lite(&_val.attrs));
707 }
708 formatter.field("cond", Lite(&_val.cond));
709 formatter.field("then_branch", Lite(&_val.then_branch));
710 if let Some(val) = &_val.else_branch {
711 #[derive(RefCast)]
712 #[repr(transparent)]
713 struct Print((syn::token::Else, Box<syn::Expr>));
714 impl Debug for Print {
715 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
716 formatter.write_str("Some")?;
717 let _val = &self.0;
718 formatter.write_str("(")?;
719 Debug::fmt(Lite(&_val.1), formatter)?;
720 formatter.write_str(")")?;
721 Ok(())
722 }
723 }
724 formatter.field("else_branch", Print::ref_cast(val));
725 }
726 formatter.finish()
727 }
728 syn::Expr::Index(_val) => {
729 let mut formatter = formatter.debug_struct("Expr::Index");
730 if !_val.attrs.is_empty() {
731 formatter.field("attrs", Lite(&_val.attrs));
732 }
733 formatter.field("expr", Lite(&_val.expr));
734 formatter.field("index", Lite(&_val.index));
735 formatter.finish()
736 }
737 syn::Expr::Let(_val) => {
738 let mut formatter = formatter.debug_struct("Expr::Let");
739 if !_val.attrs.is_empty() {
740 formatter.field("attrs", Lite(&_val.attrs));
741 }
742 formatter.field("pat", Lite(&_val.pat));
743 formatter.field("expr", Lite(&_val.expr));
744 formatter.finish()
745 }
746 syn::Expr::Lit(_val) => {
747 let mut formatter = formatter.debug_struct("Expr::Lit");
748 if !_val.attrs.is_empty() {
749 formatter.field("attrs", Lite(&_val.attrs));
750 }
751 formatter.field("lit", Lite(&_val.lit));
752 formatter.finish()
753 }
754 syn::Expr::Loop(_val) => {
755 let mut formatter = formatter.debug_struct("Expr::Loop");
756 if !_val.attrs.is_empty() {
757 formatter.field("attrs", Lite(&_val.attrs));
758 }
759 if let Some(val) = &_val.label {
760 #[derive(RefCast)]
761 #[repr(transparent)]
762 struct Print(syn::Label);
763 impl Debug for Print {
764 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
765 formatter.write_str("Some")?;
766 let _val = &self.0;
767 formatter.write_str("(")?;
768 Debug::fmt(Lite(_val), formatter)?;
769 formatter.write_str(")")?;
770 Ok(())
771 }
772 }
773 formatter.field("label", Print::ref_cast(val));
774 }
775 formatter.field("body", Lite(&_val.body));
776 formatter.finish()
777 }
778 syn::Expr::Macro(_val) => {
779 let mut formatter = formatter.debug_struct("Expr::Macro");
780 if !_val.attrs.is_empty() {
781 formatter.field("attrs", Lite(&_val.attrs));
782 }
783 formatter.field("mac", Lite(&_val.mac));
784 formatter.finish()
785 }
786 syn::Expr::Match(_val) => {
787 let mut formatter = formatter.debug_struct("Expr::Match");
788 if !_val.attrs.is_empty() {
789 formatter.field("attrs", Lite(&_val.attrs));
790 }
791 formatter.field("expr", Lite(&_val.expr));
792 if !_val.arms.is_empty() {
793 formatter.field("arms", Lite(&_val.arms));
794 }
795 formatter.finish()
796 }
797 syn::Expr::MethodCall(_val) => {
798 let mut formatter = formatter.debug_struct("Expr::MethodCall");
799 if !_val.attrs.is_empty() {
800 formatter.field("attrs", Lite(&_val.attrs));
801 }
802 formatter.field("receiver", Lite(&_val.receiver));
803 formatter.field("method", Lite(&_val.method));
804 if let Some(val) = &_val.turbofish {
805 #[derive(RefCast)]
806 #[repr(transparent)]
807 struct Print(syn::MethodTurbofish);
808 impl Debug for Print {
809 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
810 formatter.write_str("Some")?;
811 let _val = &self.0;
812 formatter.write_str("(")?;
813 Debug::fmt(Lite(_val), formatter)?;
814 formatter.write_str(")")?;
815 Ok(())
816 }
817 }
818 formatter.field("turbofish", Print::ref_cast(val));
819 }
820 if !_val.args.is_empty() {
821 formatter.field("args", Lite(&_val.args));
822 }
823 formatter.finish()
824 }
825 syn::Expr::Paren(_val) => {
826 let mut formatter = formatter.debug_struct("Expr::Paren");
827 if !_val.attrs.is_empty() {
828 formatter.field("attrs", Lite(&_val.attrs));
829 }
830 formatter.field("expr", Lite(&_val.expr));
831 formatter.finish()
832 }
833 syn::Expr::Path(_val) => {
834 let mut formatter = formatter.debug_struct("Expr::Path");
835 if !_val.attrs.is_empty() {
836 formatter.field("attrs", Lite(&_val.attrs));
837 }
838 if let Some(val) = &_val.qself {
839 #[derive(RefCast)]
840 #[repr(transparent)]
841 struct Print(syn::QSelf);
842 impl Debug for Print {
843 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
844 formatter.write_str("Some")?;
845 let _val = &self.0;
846 formatter.write_str("(")?;
847 Debug::fmt(Lite(_val), formatter)?;
848 formatter.write_str(")")?;
849 Ok(())
850 }
851 }
852 formatter.field("qself", Print::ref_cast(val));
853 }
854 formatter.field("path", Lite(&_val.path));
855 formatter.finish()
856 }
857 syn::Expr::Range(_val) => {
858 let mut formatter = formatter.debug_struct("Expr::Range");
859 if !_val.attrs.is_empty() {
860 formatter.field("attrs", Lite(&_val.attrs));
861 }
862 if let Some(val) = &_val.from {
863 #[derive(RefCast)]
864 #[repr(transparent)]
865 struct Print(Box<syn::Expr>);
866 impl Debug for Print {
867 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
868 formatter.write_str("Some")?;
869 let _val = &self.0;
870 formatter.write_str("(")?;
871 Debug::fmt(Lite(_val), formatter)?;
872 formatter.write_str(")")?;
873 Ok(())
874 }
875 }
876 formatter.field("from", Print::ref_cast(val));
877 }
878 formatter.field("limits", Lite(&_val.limits));
879 if let Some(val) = &_val.to {
880 #[derive(RefCast)]
881 #[repr(transparent)]
882 struct Print(Box<syn::Expr>);
883 impl Debug for Print {
884 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
885 formatter.write_str("Some")?;
886 let _val = &self.0;
887 formatter.write_str("(")?;
888 Debug::fmt(Lite(_val), formatter)?;
889 formatter.write_str(")")?;
890 Ok(())
891 }
892 }
893 formatter.field("to", Print::ref_cast(val));
894 }
895 formatter.finish()
896 }
897 syn::Expr::Reference(_val) => {
898 let mut formatter = formatter.debug_struct("Expr::Reference");
899 if !_val.attrs.is_empty() {
900 formatter.field("attrs", Lite(&_val.attrs));
901 }
902 if let Some(val) = &_val.mutability {
903 #[derive(RefCast)]
904 #[repr(transparent)]
905 struct Print(syn::token::Mut);
906 impl Debug for Print {
907 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
908 formatter.write_str("Some")?;
909 Ok(())
910 }
911 }
912 formatter.field("mutability", Print::ref_cast(val));
913 }
914 formatter.field("expr", Lite(&_val.expr));
915 formatter.finish()
916 }
917 syn::Expr::Repeat(_val) => {
918 let mut formatter = formatter.debug_struct("Expr::Repeat");
919 if !_val.attrs.is_empty() {
920 formatter.field("attrs", Lite(&_val.attrs));
921 }
922 formatter.field("expr", Lite(&_val.expr));
923 formatter.field("len", Lite(&_val.len));
924 formatter.finish()
925 }
926 syn::Expr::Return(_val) => {
927 let mut formatter = formatter.debug_struct("Expr::Return");
928 if !_val.attrs.is_empty() {
929 formatter.field("attrs", Lite(&_val.attrs));
930 }
931 if let Some(val) = &_val.expr {
932 #[derive(RefCast)]
933 #[repr(transparent)]
934 struct Print(Box<syn::Expr>);
935 impl Debug for Print {
936 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
937 formatter.write_str("Some")?;
938 let _val = &self.0;
939 formatter.write_str("(")?;
940 Debug::fmt(Lite(_val), formatter)?;
941 formatter.write_str(")")?;
942 Ok(())
943 }
944 }
945 formatter.field("expr", Print::ref_cast(val));
946 }
947 formatter.finish()
948 }
949 syn::Expr::Struct(_val) => {
950 let mut formatter = formatter.debug_struct("Expr::Struct");
951 if !_val.attrs.is_empty() {
952 formatter.field("attrs", Lite(&_val.attrs));
953 }
954 formatter.field("path", Lite(&_val.path));
955 if !_val.fields.is_empty() {
956 formatter.field("fields", Lite(&_val.fields));
957 }
958 if let Some(val) = &_val.dot2_token {
959 #[derive(RefCast)]
960 #[repr(transparent)]
961 struct Print(syn::token::Dot2);
962 impl Debug for Print {
963 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
964 formatter.write_str("Some")?;
965 Ok(())
966 }
967 }
968 formatter.field("dot2_token", Print::ref_cast(val));
969 }
970 if let Some(val) = &_val.rest {
971 #[derive(RefCast)]
972 #[repr(transparent)]
973 struct Print(Box<syn::Expr>);
974 impl Debug for Print {
975 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
976 formatter.write_str("Some")?;
977 let _val = &self.0;
978 formatter.write_str("(")?;
979 Debug::fmt(Lite(_val), formatter)?;
980 formatter.write_str(")")?;
981 Ok(())
982 }
983 }
984 formatter.field("rest", Print::ref_cast(val));
985 }
986 formatter.finish()
987 }
988 syn::Expr::Try(_val) => {
989 let mut formatter = formatter.debug_struct("Expr::Try");
990 if !_val.attrs.is_empty() {
991 formatter.field("attrs", Lite(&_val.attrs));
992 }
993 formatter.field("expr", Lite(&_val.expr));
994 formatter.finish()
995 }
996 syn::Expr::TryBlock(_val) => {
997 let mut formatter = formatter.debug_struct("Expr::TryBlock");
998 if !_val.attrs.is_empty() {
999 formatter.field("attrs", Lite(&_val.attrs));
1000 }
1001 formatter.field("block", Lite(&_val.block));
1002 formatter.finish()
1003 }
1004 syn::Expr::Tuple(_val) => {
1005 let mut formatter = formatter.debug_struct("Expr::Tuple");
1006 if !_val.attrs.is_empty() {
1007 formatter.field("attrs", Lite(&_val.attrs));
1008 }
1009 if !_val.elems.is_empty() {
1010 formatter.field("elems", Lite(&_val.elems));
1011 }
1012 formatter.finish()
1013 }
1014 syn::Expr::Type(_val) => {
1015 let mut formatter = formatter.debug_struct("Expr::Type");
1016 if !_val.attrs.is_empty() {
1017 formatter.field("attrs", Lite(&_val.attrs));
1018 }
1019 formatter.field("expr", Lite(&_val.expr));
1020 formatter.field("ty", Lite(&_val.ty));
1021 formatter.finish()
1022 }
1023 syn::Expr::Unary(_val) => {
1024 let mut formatter = formatter.debug_struct("Expr::Unary");
1025 if !_val.attrs.is_empty() {
1026 formatter.field("attrs", Lite(&_val.attrs));
1027 }
1028 formatter.field("op", Lite(&_val.op));
1029 formatter.field("expr", Lite(&_val.expr));
1030 formatter.finish()
1031 }
1032 syn::Expr::Unsafe(_val) => {
1033 let mut formatter = formatter.debug_struct("Expr::Unsafe");
1034 if !_val.attrs.is_empty() {
1035 formatter.field("attrs", Lite(&_val.attrs));
1036 }
1037 formatter.field("block", Lite(&_val.block));
1038 formatter.finish()
1039 }
1040 syn::Expr::Verbatim(_val) => {
1041 formatter.write_str("Verbatim")?;
1042 formatter.write_str("(`")?;
1043 Display::fmt(_val, formatter)?;
1044 formatter.write_str("`)")?;
1045 Ok(())
1046 }
1047 syn::Expr::While(_val) => {
1048 let mut formatter = formatter.debug_struct("Expr::While");
1049 if !_val.attrs.is_empty() {
1050 formatter.field("attrs", Lite(&_val.attrs));
1051 }
1052 if let Some(val) = &_val.label {
1053 #[derive(RefCast)]
1054 #[repr(transparent)]
1055 struct Print(syn::Label);
1056 impl Debug for Print {
1057 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1058 formatter.write_str("Some")?;
1059 let _val = &self.0;
1060 formatter.write_str("(")?;
1061 Debug::fmt(Lite(_val), formatter)?;
1062 formatter.write_str(")")?;
1063 Ok(())
1064 }
1065 }
1066 formatter.field("label", Print::ref_cast(val));
1067 }
1068 formatter.field("cond", Lite(&_val.cond));
1069 formatter.field("body", Lite(&_val.body));
1070 formatter.finish()
1071 }
1072 syn::Expr::Yield(_val) => {
1073 let mut formatter = formatter.debug_struct("Expr::Yield");
1074 if !_val.attrs.is_empty() {
1075 formatter.field("attrs", Lite(&_val.attrs));
1076 }
1077 if let Some(val) = &_val.expr {
1078 #[derive(RefCast)]
1079 #[repr(transparent)]
1080 struct Print(Box<syn::Expr>);
1081 impl Debug for Print {
1082 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1083 formatter.write_str("Some")?;
1084 let _val = &self.0;
1085 formatter.write_str("(")?;
1086 Debug::fmt(Lite(_val), formatter)?;
1087 formatter.write_str(")")?;
1088 Ok(())
1089 }
1090 }
1091 formatter.field("expr", Print::ref_cast(val));
1092 }
1093 formatter.finish()
1094 }
1095 _ => unreachable!(),
1096 }
1097 }
1098 }
1099 impl Debug for Lite<syn::ExprArray> {
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 }
1112 impl 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 }
1124 impl 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 }
1137 impl 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 }
1160 impl 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 }
1171 impl 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 }
1184 impl 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 }
1211 impl 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 }
1222 impl 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 }
1264 impl 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 }
1278 impl 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 }
1290 impl 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.asyncness {
1298 #[derive(RefCast)]
1299 #[repr(transparent)]
1300 struct Print(syn::token::Async);
1301 impl Debug for Print {
1302 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1303 formatter.write_str("Some")?;
1304 Ok(())
1305 }
1306 }
1307 formatter.field("asyncness", Print::ref_cast(val));
1308 }
1309 if let Some(val) = &_val.movability {
1310 #[derive(RefCast)]
1311 #[repr(transparent)]
1312 struct Print(syn::token::Static);
1313 impl Debug for Print {
1314 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1315 formatter.write_str("Some")?;
1316 Ok(())
1317 }
1318 }
1319 formatter.field("movability", Print::ref_cast(val));
1320 }
1321 if let Some(val) = &_val.capture {
1322 #[derive(RefCast)]
1323 #[repr(transparent)]
1324 struct Print(syn::token::Move);
1325 impl Debug for Print {
1326 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1327 formatter.write_str("Some")?;
1328 Ok(())
1329 }
1330 }
1331 formatter.field("capture", Print::ref_cast(val));
1332 }
1333 if !_val.inputs.is_empty() {
1334 formatter.field("inputs", Lite(&_val.inputs));
1335 }
1336 formatter.field("output", Lite(&_val.output));
1337 formatter.field("body", Lite(&_val.body));
1338 formatter.finish()
1339 }
1340 }
1341 impl Debug for Lite<syn::ExprContinue> {
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 }
1367 impl 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 }
1379 impl 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 }
1408 impl 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 }
1419 impl 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 }
1447 impl 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 }
1459 impl 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 }
1471 impl 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 }
1482 impl 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 }
1509 impl 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 }
1520 impl 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 }
1534 impl 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 }
1565 impl 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 }
1576 impl 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 }
1603 impl 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 }
1646 impl 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 }
1669 impl 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 }
1681 impl 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 }
1707 impl 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 }
1749 impl 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 }
1760 impl 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 }
1771 impl 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 }
1784 impl 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 }
1796 impl 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 }
1808 impl 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 }
1819 impl 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 }
1847 impl 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 }
1873 impl 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 }
1913 impl 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 }
1937 impl 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 }
1961 impl 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 }
1983 impl 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 }
1993 impl 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 }
2003 impl 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 }
2032 impl 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 }
2053 impl 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 }
2128 impl 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 }
2140 impl 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 }
2163 impl 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 }
2188 impl 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 }
2200 impl 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::Binding(_val) => {
2219 formatter.write_str("Binding")?;
2220 formatter.write_str("(")?;
2221 Debug::fmt(Lite(_val), formatter)?;
2222 formatter.write_str(")")?;
2223 Ok(())
2224 }
2225 syn::GenericArgument::Constraint(_val) => {
2226 formatter.write_str("Constraint")?;
2227 formatter.write_str("(")?;
2228 Debug::fmt(Lite(_val), formatter)?;
2229 formatter.write_str(")")?;
2230 Ok(())
2231 }
2232 syn::GenericArgument::Const(_val) => {
2233 formatter.write_str("Const")?;
2234 formatter.write_str("(")?;
2235 Debug::fmt(Lite(_val), formatter)?;
2236 formatter.write_str(")")?;
2237 Ok(())
2238 }
2239 }
2240 }
2241 }
2242 impl Debug for Lite<syn::GenericMethodArgument> {
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 }
2263 impl 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 }
2291 impl 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 }
2341 impl 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 }
2444 impl 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 }
2470 impl 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 }
2493 impl 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 }
2518 impl 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 }
2544 impl 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 }
2552 impl 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 {
2677 match &self.0 {
2678 Some(_val) => {
2679 formatter.write_str("Some")?;
2680 Ok(())
2681 }
2682 None => formatter.write_str("None"),
2683 }
2684 }
2685 }
2686 Print::ref_cast(&_val.0)
2687 },
2688 Lite(&_val.1),
2689 ),
2690 formatter,
2691 )?;
2692 formatter.write_str(")")?;
2693 Ok(())
2694 }
2695 }
2696 formatter.field("trait_", Print::ref_cast(val));
2697 }
2698 formatter.field("self_ty", Lite(&_val.self_ty));
2699 if !_val.items.is_empty() {
2700 formatter.field("items", Lite(&_val.items));
2701 }
2702 formatter.finish()
2703 }
2704 syn::Item::Macro(_val) => {
2705 let mut formatter = formatter.debug_struct("Item::Macro");
2706 if !_val.attrs.is_empty() {
2707 formatter.field("attrs", Lite(&_val.attrs));
2708 }
2709 if let Some(val) = &_val.ident {
2710 #[derive(RefCast)]
2711 #[repr(transparent)]
2712 struct Print(proc_macro2::Ident);
2713 impl Debug for Print {
2714 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2715 formatter.write_str("Some")?;
2716 let _val = &self.0;
2717 formatter.write_str("(")?;
2718 Debug::fmt(Lite(_val), formatter)?;
2719 formatter.write_str(")")?;
2720 Ok(())
2721 }
2722 }
2723 formatter.field("ident", Print::ref_cast(val));
2724 }
2725 formatter.field("mac", Lite(&_val.mac));
2726 if let Some(val) = &_val.semi_token {
2727 #[derive(RefCast)]
2728 #[repr(transparent)]
2729 struct Print(syn::token::Semi);
2730 impl Debug for Print {
2731 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2732 formatter.write_str("Some")?;
2733 Ok(())
2734 }
2735 }
2736 formatter.field("semi_token", Print::ref_cast(val));
2737 }
2738 formatter.finish()
2739 }
2740 syn::Item::Macro2(_val) => {
2741 let mut formatter = formatter.debug_struct("Item::Macro2");
2742 if !_val.attrs.is_empty() {
2743 formatter.field("attrs", Lite(&_val.attrs));
2744 }
2745 formatter.field("vis", Lite(&_val.vis));
2746 formatter.field("ident", Lite(&_val.ident));
2747 formatter.field("rules", Lite(&_val.rules));
2748 formatter.finish()
2749 }
2750 syn::Item::Mod(_val) => {
2751 let mut formatter = formatter.debug_struct("Item::Mod");
2752 if !_val.attrs.is_empty() {
2753 formatter.field("attrs", Lite(&_val.attrs));
2754 }
2755 formatter.field("vis", Lite(&_val.vis));
2756 formatter.field("ident", Lite(&_val.ident));
2757 if let Some(val) = &_val.content {
2758 #[derive(RefCast)]
2759 #[repr(transparent)]
2760 struct Print((syn::token::Brace, Vec<syn::Item>));
2761 impl Debug for Print {
2762 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2763 formatter.write_str("Some")?;
2764 let _val = &self.0;
2765 formatter.write_str("(")?;
2766 Debug::fmt(Lite(&_val.1), formatter)?;
2767 formatter.write_str(")")?;
2768 Ok(())
2769 }
2770 }
2771 formatter.field("content", Print::ref_cast(val));
2772 }
2773 if let Some(val) = &_val.semi {
2774 #[derive(RefCast)]
2775 #[repr(transparent)]
2776 struct Print(syn::token::Semi);
2777 impl Debug for Print {
2778 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2779 formatter.write_str("Some")?;
2780 Ok(())
2781 }
2782 }
2783 formatter.field("semi", Print::ref_cast(val));
2784 }
2785 formatter.finish()
2786 }
2787 syn::Item::Static(_val) => {
2788 let mut formatter = formatter.debug_struct("Item::Static");
2789 if !_val.attrs.is_empty() {
2790 formatter.field("attrs", Lite(&_val.attrs));
2791 }
2792 formatter.field("vis", Lite(&_val.vis));
2793 if let Some(val) = &_val.mutability {
2794 #[derive(RefCast)]
2795 #[repr(transparent)]
2796 struct Print(syn::token::Mut);
2797 impl Debug for Print {
2798 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2799 formatter.write_str("Some")?;
2800 Ok(())
2801 }
2802 }
2803 formatter.field("mutability", Print::ref_cast(val));
2804 }
2805 formatter.field("ident", Lite(&_val.ident));
2806 formatter.field("ty", Lite(&_val.ty));
2807 formatter.field("expr", Lite(&_val.expr));
2808 formatter.finish()
2809 }
2810 syn::Item::Struct(_val) => {
2811 let mut formatter = formatter.debug_struct("Item::Struct");
2812 if !_val.attrs.is_empty() {
2813 formatter.field("attrs", Lite(&_val.attrs));
2814 }
2815 formatter.field("vis", Lite(&_val.vis));
2816 formatter.field("ident", Lite(&_val.ident));
2817 formatter.field("generics", Lite(&_val.generics));
2818 formatter.field("fields", Lite(&_val.fields));
2819 if let Some(val) = &_val.semi_token {
2820 #[derive(RefCast)]
2821 #[repr(transparent)]
2822 struct Print(syn::token::Semi);
2823 impl Debug for Print {
2824 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2825 formatter.write_str("Some")?;
2826 Ok(())
2827 }
2828 }
2829 formatter.field("semi_token", Print::ref_cast(val));
2830 }
2831 formatter.finish()
2832 }
2833 syn::Item::Trait(_val) => {
2834 let mut formatter = formatter.debug_struct("Item::Trait");
2835 if !_val.attrs.is_empty() {
2836 formatter.field("attrs", Lite(&_val.attrs));
2837 }
2838 formatter.field("vis", Lite(&_val.vis));
2839 if let Some(val) = &_val.unsafety {
2840 #[derive(RefCast)]
2841 #[repr(transparent)]
2842 struct Print(syn::token::Unsafe);
2843 impl Debug for Print {
2844 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2845 formatter.write_str("Some")?;
2846 Ok(())
2847 }
2848 }
2849 formatter.field("unsafety", Print::ref_cast(val));
2850 }
2851 if let Some(val) = &_val.auto_token {
2852 #[derive(RefCast)]
2853 #[repr(transparent)]
2854 struct Print(syn::token::Auto);
2855 impl Debug for Print {
2856 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2857 formatter.write_str("Some")?;
2858 Ok(())
2859 }
2860 }
2861 formatter.field("auto_token", Print::ref_cast(val));
2862 }
2863 formatter.field("ident", Lite(&_val.ident));
2864 formatter.field("generics", Lite(&_val.generics));
2865 if let Some(val) = &_val.colon_token {
2866 #[derive(RefCast)]
2867 #[repr(transparent)]
2868 struct Print(syn::token::Colon);
2869 impl Debug for Print {
2870 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2871 formatter.write_str("Some")?;
2872 Ok(())
2873 }
2874 }
2875 formatter.field("colon_token", Print::ref_cast(val));
2876 }
2877 if !_val.supertraits.is_empty() {
2878 formatter.field("supertraits", Lite(&_val.supertraits));
2879 }
2880 if !_val.items.is_empty() {
2881 formatter.field("items", Lite(&_val.items));
2882 }
2883 formatter.finish()
2884 }
2885 syn::Item::TraitAlias(_val) => {
2886 let mut formatter = formatter.debug_struct("Item::TraitAlias");
2887 if !_val.attrs.is_empty() {
2888 formatter.field("attrs", Lite(&_val.attrs));
2889 }
2890 formatter.field("vis", Lite(&_val.vis));
2891 formatter.field("ident", Lite(&_val.ident));
2892 formatter.field("generics", Lite(&_val.generics));
2893 if !_val.bounds.is_empty() {
2894 formatter.field("bounds", Lite(&_val.bounds));
2895 }
2896 formatter.finish()
2897 }
2898 syn::Item::Type(_val) => {
2899 let mut formatter = formatter.debug_struct("Item::Type");
2900 if !_val.attrs.is_empty() {
2901 formatter.field("attrs", Lite(&_val.attrs));
2902 }
2903 formatter.field("vis", Lite(&_val.vis));
2904 formatter.field("ident", Lite(&_val.ident));
2905 formatter.field("generics", Lite(&_val.generics));
2906 formatter.field("ty", Lite(&_val.ty));
2907 formatter.finish()
2908 }
2909 syn::Item::Union(_val) => {
2910 let mut formatter = formatter.debug_struct("Item::Union");
2911 if !_val.attrs.is_empty() {
2912 formatter.field("attrs", Lite(&_val.attrs));
2913 }
2914 formatter.field("vis", Lite(&_val.vis));
2915 formatter.field("ident", Lite(&_val.ident));
2916 formatter.field("generics", Lite(&_val.generics));
2917 formatter.field("fields", Lite(&_val.fields));
2918 formatter.finish()
2919 }
2920 syn::Item::Use(_val) => {
2921 let mut formatter = formatter.debug_struct("Item::Use");
2922 if !_val.attrs.is_empty() {
2923 formatter.field("attrs", Lite(&_val.attrs));
2924 }
2925 formatter.field("vis", Lite(&_val.vis));
2926 if let Some(val) = &_val.leading_colon {
2927 #[derive(RefCast)]
2928 #[repr(transparent)]
2929 struct Print(syn::token::Colon2);
2930 impl Debug for Print {
2931 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2932 formatter.write_str("Some")?;
2933 Ok(())
2934 }
2935 }
2936 formatter.field("leading_colon", Print::ref_cast(val));
2937 }
2938 formatter.field("tree", Lite(&_val.tree));
2939 formatter.finish()
2940 }
2941 syn::Item::Verbatim(_val) => {
2942 formatter.write_str("Verbatim")?;
2943 formatter.write_str("(`")?;
2944 Display::fmt(_val, formatter)?;
2945 formatter.write_str("`)")?;
2946 Ok(())
2947 }
2948 _ => unreachable!(),
2949 }
2950 }
2951 }
2952 impl Debug for Lite<syn::ItemConst> {
2953 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2954 let _val = &self.value;
2955 let mut formatter = formatter.debug_struct("ItemConst");
2956 if !_val.attrs.is_empty() {
2957 formatter.field("attrs", Lite(&_val.attrs));
2958 }
2959 formatter.field("vis", Lite(&_val.vis));
2960 formatter.field("ident", Lite(&_val.ident));
2961 formatter.field("ty", Lite(&_val.ty));
2962 formatter.field("expr", Lite(&_val.expr));
2963 formatter.finish()
2964 }
2965 }
2966 impl Debug for Lite<syn::ItemEnum> {
2967 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2968 let _val = &self.value;
2969 let mut formatter = formatter.debug_struct("ItemEnum");
2970 if !_val.attrs.is_empty() {
2971 formatter.field("attrs", Lite(&_val.attrs));
2972 }
2973 formatter.field("vis", Lite(&_val.vis));
2974 formatter.field("ident", Lite(&_val.ident));
2975 formatter.field("generics", Lite(&_val.generics));
2976 if !_val.variants.is_empty() {
2977 formatter.field("variants", Lite(&_val.variants));
2978 }
2979 formatter.finish()
2980 }
2981 }
2982 impl Debug for Lite<syn::ItemExternCrate> {
2983 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2984 let _val = &self.value;
2985 let mut formatter = formatter.debug_struct("ItemExternCrate");
2986 if !_val.attrs.is_empty() {
2987 formatter.field("attrs", Lite(&_val.attrs));
2988 }
2989 formatter.field("vis", Lite(&_val.vis));
2990 formatter.field("ident", Lite(&_val.ident));
2991 if let Some(val) = &_val.rename {
2992 #[derive(RefCast)]
2993 #[repr(transparent)]
2994 struct Print((syn::token::As, proc_macro2::Ident));
2995 impl Debug for Print {
2996 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2997 formatter.write_str("Some")?;
2998 let _val = &self.0;
2999 formatter.write_str("(")?;
3000 Debug::fmt(Lite(&_val.1), formatter)?;
3001 formatter.write_str(")")?;
3002 Ok(())
3003 }
3004 }
3005 formatter.field("rename", Print::ref_cast(val));
3006 }
3007 formatter.finish()
3008 }
3009 }
3010 impl Debug for Lite<syn::ItemFn> {
3011 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3012 let _val = &self.value;
3013 let mut formatter = formatter.debug_struct("ItemFn");
3014 if !_val.attrs.is_empty() {
3015 formatter.field("attrs", Lite(&_val.attrs));
3016 }
3017 formatter.field("vis", Lite(&_val.vis));
3018 formatter.field("sig", Lite(&_val.sig));
3019 formatter.field("block", Lite(&_val.block));
3020 formatter.finish()
3021 }
3022 }
3023 impl Debug for Lite<syn::ItemForeignMod> {
3024 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3025 let _val = &self.value;
3026 let mut formatter = formatter.debug_struct("ItemForeignMod");
3027 if !_val.attrs.is_empty() {
3028 formatter.field("attrs", Lite(&_val.attrs));
3029 }
3030 formatter.field("abi", Lite(&_val.abi));
3031 if !_val.items.is_empty() {
3032 formatter.field("items", Lite(&_val.items));
3033 }
3034 formatter.finish()
3035 }
3036 }
3037 impl Debug for Lite<syn::ItemImpl> {
3038 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3039 let _val = &self.value;
3040 let mut formatter = formatter.debug_struct("ItemImpl");
3041 if !_val.attrs.is_empty() {
3042 formatter.field("attrs", Lite(&_val.attrs));
3043 }
3044 if let Some(val) = &_val.defaultness {
3045 #[derive(RefCast)]
3046 #[repr(transparent)]
3047 struct Print(syn::token::Default);
3048 impl Debug for Print {
3049 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3050 formatter.write_str("Some")?;
3051 Ok(())
3052 }
3053 }
3054 formatter.field("defaultness", Print::ref_cast(val));
3055 }
3056 if let Some(val) = &_val.unsafety {
3057 #[derive(RefCast)]
3058 #[repr(transparent)]
3059 struct Print(syn::token::Unsafe);
3060 impl Debug for Print {
3061 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3062 formatter.write_str("Some")?;
3063 Ok(())
3064 }
3065 }
3066 formatter.field("unsafety", Print::ref_cast(val));
3067 }
3068 formatter.field("generics", Lite(&_val.generics));
3069 if let Some(val) = &_val.trait_ {
3070 #[derive(RefCast)]
3071 #[repr(transparent)]
3072 struct Print((Option<syn::token::Bang>, syn::Path, syn::token::For));
3073 impl Debug for Print {
3074 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3075 formatter.write_str("Some")?;
3076 let _val = &self.0;
3077 formatter.write_str("(")?;
3078 Debug::fmt(
3079 &(
3080 {
3081 #[derive(RefCast)]
3082 #[repr(transparent)]
3083 struct Print(Option<syn::token::Bang>);
3084 impl Debug for Print {
3085 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3086 match &self.0 {
3087 Some(_val) => {
3088 formatter.write_str("Some")?;
3089 Ok(())
3090 }
3091 None => formatter.write_str("None"),
3092 }
3093 }
3094 }
3095 Print::ref_cast(&_val.0)
3096 },
3097 Lite(&_val.1),
3098 ),
3099 formatter,
3100 )?;
3101 formatter.write_str(")")?;
3102 Ok(())
3103 }
3104 }
3105 formatter.field("trait_", Print::ref_cast(val));
3106 }
3107 formatter.field("self_ty", Lite(&_val.self_ty));
3108 if !_val.items.is_empty() {
3109 formatter.field("items", Lite(&_val.items));
3110 }
3111 formatter.finish()
3112 }
3113 }
3114 impl Debug for Lite<syn::ItemMacro> {
3115 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3116 let _val = &self.value;
3117 let mut formatter = formatter.debug_struct("ItemMacro");
3118 if !_val.attrs.is_empty() {
3119 formatter.field("attrs", Lite(&_val.attrs));
3120 }
3121 if let Some(val) = &_val.ident {
3122 #[derive(RefCast)]
3123 #[repr(transparent)]
3124 struct Print(proc_macro2::Ident);
3125 impl Debug for Print {
3126 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3127 formatter.write_str("Some")?;
3128 let _val = &self.0;
3129 formatter.write_str("(")?;
3130 Debug::fmt(Lite(_val), formatter)?;
3131 formatter.write_str(")")?;
3132 Ok(())
3133 }
3134 }
3135 formatter.field("ident", Print::ref_cast(val));
3136 }
3137 formatter.field("mac", Lite(&_val.mac));
3138 if let Some(val) = &_val.semi_token {
3139 #[derive(RefCast)]
3140 #[repr(transparent)]
3141 struct Print(syn::token::Semi);
3142 impl Debug for Print {
3143 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3144 formatter.write_str("Some")?;
3145 Ok(())
3146 }
3147 }
3148 formatter.field("semi_token", Print::ref_cast(val));
3149 }
3150 formatter.finish()
3151 }
3152 }
3153 impl Debug for Lite<syn::ItemMacro2> {
3154 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3155 let _val = &self.value;
3156 let mut formatter = formatter.debug_struct("ItemMacro2");
3157 if !_val.attrs.is_empty() {
3158 formatter.field("attrs", Lite(&_val.attrs));
3159 }
3160 formatter.field("vis", Lite(&_val.vis));
3161 formatter.field("ident", Lite(&_val.ident));
3162 formatter.field("rules", Lite(&_val.rules));
3163 formatter.finish()
3164 }
3165 }
3166 impl Debug for Lite<syn::ItemMod> {
3167 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3168 let _val = &self.value;
3169 let mut formatter = formatter.debug_struct("ItemMod");
3170 if !_val.attrs.is_empty() {
3171 formatter.field("attrs", Lite(&_val.attrs));
3172 }
3173 formatter.field("vis", Lite(&_val.vis));
3174 formatter.field("ident", Lite(&_val.ident));
3175 if let Some(val) = &_val.content {
3176 #[derive(RefCast)]
3177 #[repr(transparent)]
3178 struct Print((syn::token::Brace, Vec<syn::Item>));
3179 impl Debug for Print {
3180 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3181 formatter.write_str("Some")?;
3182 let _val = &self.0;
3183 formatter.write_str("(")?;
3184 Debug::fmt(Lite(&_val.1), formatter)?;
3185 formatter.write_str(")")?;
3186 Ok(())
3187 }
3188 }
3189 formatter.field("content", Print::ref_cast(val));
3190 }
3191 if let Some(val) = &_val.semi {
3192 #[derive(RefCast)]
3193 #[repr(transparent)]
3194 struct Print(syn::token::Semi);
3195 impl Debug for Print {
3196 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3197 formatter.write_str("Some")?;
3198 Ok(())
3199 }
3200 }
3201 formatter.field("semi", Print::ref_cast(val));
3202 }
3203 formatter.finish()
3204 }
3205 }
3206 impl Debug for Lite<syn::ItemStatic> {
3207 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3208 let _val = &self.value;
3209 let mut formatter = formatter.debug_struct("ItemStatic");
3210 if !_val.attrs.is_empty() {
3211 formatter.field("attrs", Lite(&_val.attrs));
3212 }
3213 formatter.field("vis", Lite(&_val.vis));
3214 if let Some(val) = &_val.mutability {
3215 #[derive(RefCast)]
3216 #[repr(transparent)]
3217 struct Print(syn::token::Mut);
3218 impl Debug for Print {
3219 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3220 formatter.write_str("Some")?;
3221 Ok(())
3222 }
3223 }
3224 formatter.field("mutability", Print::ref_cast(val));
3225 }
3226 formatter.field("ident", Lite(&_val.ident));
3227 formatter.field("ty", Lite(&_val.ty));
3228 formatter.field("expr", Lite(&_val.expr));
3229 formatter.finish()
3230 }
3231 }
3232 impl Debug for Lite<syn::ItemStruct> {
3233 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3234 let _val = &self.value;
3235 let mut formatter = formatter.debug_struct("ItemStruct");
3236 if !_val.attrs.is_empty() {
3237 formatter.field("attrs", Lite(&_val.attrs));
3238 }
3239 formatter.field("vis", Lite(&_val.vis));
3240 formatter.field("ident", Lite(&_val.ident));
3241 formatter.field("generics", Lite(&_val.generics));
3242 formatter.field("fields", Lite(&_val.fields));
3243 if let Some(val) = &_val.semi_token {
3244 #[derive(RefCast)]
3245 #[repr(transparent)]
3246 struct Print(syn::token::Semi);
3247 impl Debug for Print {
3248 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3249 formatter.write_str("Some")?;
3250 Ok(())
3251 }
3252 }
3253 formatter.field("semi_token", Print::ref_cast(val));
3254 }
3255 formatter.finish()
3256 }
3257 }
3258 impl Debug for Lite<syn::ItemTrait> {
3259 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3260 let _val = &self.value;
3261 let mut formatter = formatter.debug_struct("ItemTrait");
3262 if !_val.attrs.is_empty() {
3263 formatter.field("attrs", Lite(&_val.attrs));
3264 }
3265 formatter.field("vis", Lite(&_val.vis));
3266 if let Some(val) = &_val.unsafety {
3267 #[derive(RefCast)]
3268 #[repr(transparent)]
3269 struct Print(syn::token::Unsafe);
3270 impl Debug for Print {
3271 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3272 formatter.write_str("Some")?;
3273 Ok(())
3274 }
3275 }
3276 formatter.field("unsafety", Print::ref_cast(val));
3277 }
3278 if let Some(val) = &_val.auto_token {
3279 #[derive(RefCast)]
3280 #[repr(transparent)]
3281 struct Print(syn::token::Auto);
3282 impl Debug for Print {
3283 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3284 formatter.write_str("Some")?;
3285 Ok(())
3286 }
3287 }
3288 formatter.field("auto_token", Print::ref_cast(val));
3289 }
3290 formatter.field("ident", Lite(&_val.ident));
3291 formatter.field("generics", Lite(&_val.generics));
3292 if let Some(val) = &_val.colon_token {
3293 #[derive(RefCast)]
3294 #[repr(transparent)]
3295 struct Print(syn::token::Colon);
3296 impl Debug for Print {
3297 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3298 formatter.write_str("Some")?;
3299 Ok(())
3300 }
3301 }
3302 formatter.field("colon_token", Print::ref_cast(val));
3303 }
3304 if !_val.supertraits.is_empty() {
3305 formatter.field("supertraits", Lite(&_val.supertraits));
3306 }
3307 if !_val.items.is_empty() {
3308 formatter.field("items", Lite(&_val.items));
3309 }
3310 formatter.finish()
3311 }
3312 }
3313 impl Debug for Lite<syn::ItemTraitAlias> {
3314 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3315 let _val = &self.value;
3316 let mut formatter = formatter.debug_struct("ItemTraitAlias");
3317 if !_val.attrs.is_empty() {
3318 formatter.field("attrs", Lite(&_val.attrs));
3319 }
3320 formatter.field("vis", Lite(&_val.vis));
3321 formatter.field("ident", Lite(&_val.ident));
3322 formatter.field("generics", Lite(&_val.generics));
3323 if !_val.bounds.is_empty() {
3324 formatter.field("bounds", Lite(&_val.bounds));
3325 }
3326 formatter.finish()
3327 }
3328 }
3329 impl Debug for Lite<syn::ItemType> {
3330 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3331 let _val = &self.value;
3332 let mut formatter = formatter.debug_struct("ItemType");
3333 if !_val.attrs.is_empty() {
3334 formatter.field("attrs", Lite(&_val.attrs));
3335 }
3336 formatter.field("vis", Lite(&_val.vis));
3337 formatter.field("ident", Lite(&_val.ident));
3338 formatter.field("generics", Lite(&_val.generics));
3339 formatter.field("ty", Lite(&_val.ty));
3340 formatter.finish()
3341 }
3342 }
3343 impl Debug for Lite<syn::ItemUnion> {
3344 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3345 let _val = &self.value;
3346 let mut formatter = formatter.debug_struct("ItemUnion");
3347 if !_val.attrs.is_empty() {
3348 formatter.field("attrs", Lite(&_val.attrs));
3349 }
3350 formatter.field("vis", Lite(&_val.vis));
3351 formatter.field("ident", Lite(&_val.ident));
3352 formatter.field("generics", Lite(&_val.generics));
3353 formatter.field("fields", Lite(&_val.fields));
3354 formatter.finish()
3355 }
3356 }
3357 impl Debug for Lite<syn::ItemUse> {
3358 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3359 let _val = &self.value;
3360 let mut formatter = formatter.debug_struct("ItemUse");
3361 if !_val.attrs.is_empty() {
3362 formatter.field("attrs", Lite(&_val.attrs));
3363 }
3364 formatter.field("vis", Lite(&_val.vis));
3365 if let Some(val) = &_val.leading_colon {
3366 #[derive(RefCast)]
3367 #[repr(transparent)]
3368 struct Print(syn::token::Colon2);
3369 impl Debug for Print {
3370 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3371 formatter.write_str("Some")?;
3372 Ok(())
3373 }
3374 }
3375 formatter.field("leading_colon", Print::ref_cast(val));
3376 }
3377 formatter.field("tree", Lite(&_val.tree));
3378 formatter.finish()
3379 }
3380 }
3381 impl Debug for Lite<syn::Label> {
3382 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3383 let _val = &self.value;
3384 let mut formatter = formatter.debug_struct("Label");
3385 formatter.field("name", Lite(&_val.name));
3386 formatter.finish()
3387 }
3388 }
3389 impl Debug for Lite<syn::Lifetime> {
3390 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3391 let _val = &self.value;
3392 let mut formatter = formatter.debug_struct("Lifetime");
3393 formatter.field("ident", Lite(&_val.ident));
3394 formatter.finish()
3395 }
3396 }
3397 impl Debug for Lite<syn::LifetimeDef> {
3398 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3399 let _val = &self.value;
3400 let mut formatter = formatter.debug_struct("LifetimeDef");
3401 if !_val.attrs.is_empty() {
3402 formatter.field("attrs", Lite(&_val.attrs));
3403 }
3404 formatter.field("lifetime", Lite(&_val.lifetime));
3405 if let Some(val) = &_val.colon_token {
3406 #[derive(RefCast)]
3407 #[repr(transparent)]
3408 struct Print(syn::token::Colon);
3409 impl Debug for Print {
3410 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3411 formatter.write_str("Some")?;
3412 Ok(())
3413 }
3414 }
3415 formatter.field("colon_token", Print::ref_cast(val));
3416 }
3417 if !_val.bounds.is_empty() {
3418 formatter.field("bounds", Lite(&_val.bounds));
3419 }
3420 formatter.finish()
3421 }
3422 }
3423 impl Debug for Lite<syn::Lit> {
3424 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3425 let _val = &self.value;
3426 match _val {
3427 syn::Lit::Str(_val) => {
3428 write!(formatter, "{:?}", _val.value())
3429 }
3430 syn::Lit::ByteStr(_val) => {
3431 write!(formatter, "{:?}", _val.value())
3432 }
3433 syn::Lit::Byte(_val) => {
3434 write!(formatter, "{:?}", _val.value())
3435 }
3436 syn::Lit::Char(_val) => {
3437 write!(formatter, "{:?}", _val.value())
3438 }
3439 syn::Lit::Int(_val) => {
3440 write!(formatter, "{}", _val)
3441 }
3442 syn::Lit::Float(_val) => {
3443 write!(formatter, "{}", _val)
3444 }
3445 syn::Lit::Bool(_val) => {
3446 let mut formatter = formatter.debug_struct("Lit::Bool");
3447 formatter.field("value", Lite(&_val.value));
3448 formatter.finish()
3449 }
3450 syn::Lit::Verbatim(_val) => {
3451 formatter.write_str("Verbatim")?;
3452 formatter.write_str("(`")?;
3453 Display::fmt(_val, formatter)?;
3454 formatter.write_str("`)")?;
3455 Ok(())
3456 }
3457 }
3458 }
3459 }
3460 impl Debug for Lite<syn::LitBool> {
3461 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3462 let _val = &self.value;
3463 let mut formatter = formatter.debug_struct("LitBool");
3464 formatter.field("value", Lite(&_val.value));
3465 formatter.finish()
3466 }
3467 }
3468 impl Debug for Lite<syn::LitByte> {
3469 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3470 let _val = &self.value;
3471 write!(formatter, "{:?}", _val.value())
3472 }
3473 }
3474 impl Debug for Lite<syn::LitByteStr> {
3475 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3476 let _val = &self.value;
3477 write!(formatter, "{:?}", _val.value())
3478 }
3479 }
3480 impl Debug for Lite<syn::LitChar> {
3481 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3482 let _val = &self.value;
3483 write!(formatter, "{:?}", _val.value())
3484 }
3485 }
3486 impl Debug for Lite<syn::LitFloat> {
3487 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3488 let _val = &self.value;
3489 write!(formatter, "{}", _val)
3490 }
3491 }
3492 impl Debug for Lite<syn::LitInt> {
3493 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3494 let _val = &self.value;
3495 write!(formatter, "{}", _val)
3496 }
3497 }
3498 impl Debug for Lite<syn::LitStr> {
3499 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3500 let _val = &self.value;
3501 write!(formatter, "{:?}", _val.value())
3502 }
3503 }
3504 impl Debug for Lite<syn::Local> {
3505 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3506 let _val = &self.value;
3507 let mut formatter = formatter.debug_struct("Local");
3508 if !_val.attrs.is_empty() {
3509 formatter.field("attrs", Lite(&_val.attrs));
3510 }
3511 formatter.field("pat", Lite(&_val.pat));
3512 if let Some(val) = &_val.init {
3513 #[derive(RefCast)]
3514 #[repr(transparent)]
3515 struct Print((syn::token::Eq, Box<syn::Expr>));
3516 impl Debug for Print {
3517 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3518 formatter.write_str("Some")?;
3519 let _val = &self.0;
3520 formatter.write_str("(")?;
3521 Debug::fmt(Lite(&_val.1), formatter)?;
3522 formatter.write_str(")")?;
3523 Ok(())
3524 }
3525 }
3526 formatter.field("init", Print::ref_cast(val));
3527 }
3528 formatter.finish()
3529 }
3530 }
3531 impl Debug for Lite<syn::Macro> {
3532 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3533 let _val = &self.value;
3534 let mut formatter = formatter.debug_struct("Macro");
3535 formatter.field("path", Lite(&_val.path));
3536 formatter.field("delimiter", Lite(&_val.delimiter));
3537 formatter.field("tokens", Lite(&_val.tokens));
3538 formatter.finish()
3539 }
3540 }
3541 impl Debug for Lite<syn::MacroDelimiter> {
3542 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3543 let _val = &self.value;
3544 match _val {
3545 syn::MacroDelimiter::Paren(_val) => {
3546 formatter.write_str("Paren")?;
3547 Ok(())
3548 }
3549 syn::MacroDelimiter::Brace(_val) => {
3550 formatter.write_str("Brace")?;
3551 Ok(())
3552 }
3553 syn::MacroDelimiter::Bracket(_val) => {
3554 formatter.write_str("Bracket")?;
3555 Ok(())
3556 }
3557 }
3558 }
3559 }
3560 impl Debug for Lite<syn::Member> {
3561 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3562 let _val = &self.value;
3563 match _val {
3564 syn::Member::Named(_val) => {
3565 formatter.write_str("Named")?;
3566 formatter.write_str("(")?;
3567 Debug::fmt(Lite(_val), formatter)?;
3568 formatter.write_str(")")?;
3569 Ok(())
3570 }
3571 syn::Member::Unnamed(_val) => {
3572 formatter.write_str("Unnamed")?;
3573 formatter.write_str("(")?;
3574 Debug::fmt(Lite(_val), formatter)?;
3575 formatter.write_str(")")?;
3576 Ok(())
3577 }
3578 }
3579 }
3580 }
3581 impl Debug for Lite<syn::Meta> {
3582 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3583 let _val = &self.value;
3584 match _val {
3585 syn::Meta::Path(_val) => {
3586 formatter.write_str("Path")?;
3587 formatter.write_str("(")?;
3588 Debug::fmt(Lite(_val), formatter)?;
3589 formatter.write_str(")")?;
3590 Ok(())
3591 }
3592 syn::Meta::List(_val) => {
3593 let mut formatter = formatter.debug_struct("Meta::List");
3594 formatter.field("path", Lite(&_val.path));
3595 if !_val.nested.is_empty() {
3596 formatter.field("nested", Lite(&_val.nested));
3597 }
3598 formatter.finish()
3599 }
3600 syn::Meta::NameValue(_val) => {
3601 let mut formatter = formatter.debug_struct("Meta::NameValue");
3602 formatter.field("path", Lite(&_val.path));
3603 formatter.field("lit", Lite(&_val.lit));
3604 formatter.finish()
3605 }
3606 }
3607 }
3608 }
3609 impl Debug for Lite<syn::MetaList> {
3610 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3611 let _val = &self.value;
3612 let mut formatter = formatter.debug_struct("MetaList");
3613 formatter.field("path", Lite(&_val.path));
3614 if !_val.nested.is_empty() {
3615 formatter.field("nested", Lite(&_val.nested));
3616 }
3617 formatter.finish()
3618 }
3619 }
3620 impl Debug for Lite<syn::MetaNameValue> {
3621 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3622 let _val = &self.value;
3623 let mut formatter = formatter.debug_struct("MetaNameValue");
3624 formatter.field("path", Lite(&_val.path));
3625 formatter.field("lit", Lite(&_val.lit));
3626 formatter.finish()
3627 }
3628 }
3629 impl Debug for Lite<syn::MethodTurbofish> {
3630 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3631 let _val = &self.value;
3632 let mut formatter = formatter.debug_struct("MethodTurbofish");
3633 if !_val.args.is_empty() {
3634 formatter.field("args", Lite(&_val.args));
3635 }
3636 formatter.finish()
3637 }
3638 }
3639 impl Debug for Lite<syn::NestedMeta> {
3640 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3641 let _val = &self.value;
3642 match _val {
3643 syn::NestedMeta::Meta(_val) => {
3644 formatter.write_str("Meta")?;
3645 formatter.write_str("(")?;
3646 Debug::fmt(Lite(_val), formatter)?;
3647 formatter.write_str(")")?;
3648 Ok(())
3649 }
3650 syn::NestedMeta::Lit(_val) => {
3651 formatter.write_str("Lit")?;
3652 formatter.write_str("(")?;
3653 Debug::fmt(Lite(_val), formatter)?;
3654 formatter.write_str(")")?;
3655 Ok(())
3656 }
3657 }
3658 }
3659 }
3660 impl Debug for Lite<syn::ParenthesizedGenericArguments> {
3661 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3662 let _val = &self.value;
3663 let mut formatter = formatter.debug_struct("ParenthesizedGenericArguments");
3664 if !_val.inputs.is_empty() {
3665 formatter.field("inputs", Lite(&_val.inputs));
3666 }
3667 formatter.field("output", Lite(&_val.output));
3668 formatter.finish()
3669 }
3670 }
3671 impl Debug for Lite<syn::Pat> {
3672 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3673 let _val = &self.value;
3674 match _val {
3675 syn::Pat::Box(_val) => {
3676 let mut formatter = formatter.debug_struct("Pat::Box");
3677 if !_val.attrs.is_empty() {
3678 formatter.field("attrs", Lite(&_val.attrs));
3679 }
3680 formatter.field("pat", Lite(&_val.pat));
3681 formatter.finish()
3682 }
3683 syn::Pat::Ident(_val) => {
3684 let mut formatter = formatter.debug_struct("Pat::Ident");
3685 if !_val.attrs.is_empty() {
3686 formatter.field("attrs", Lite(&_val.attrs));
3687 }
3688 if let Some(val) = &_val.by_ref {
3689 #[derive(RefCast)]
3690 #[repr(transparent)]
3691 struct Print(syn::token::Ref);
3692 impl Debug for Print {
3693 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3694 formatter.write_str("Some")?;
3695 Ok(())
3696 }
3697 }
3698 formatter.field("by_ref", Print::ref_cast(val));
3699 }
3700 if let Some(val) = &_val.mutability {
3701 #[derive(RefCast)]
3702 #[repr(transparent)]
3703 struct Print(syn::token::Mut);
3704 impl Debug for Print {
3705 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3706 formatter.write_str("Some")?;
3707 Ok(())
3708 }
3709 }
3710 formatter.field("mutability", Print::ref_cast(val));
3711 }
3712 formatter.field("ident", Lite(&_val.ident));
3713 if let Some(val) = &_val.subpat {
3714 #[derive(RefCast)]
3715 #[repr(transparent)]
3716 struct Print((syn::token::At, Box<syn::Pat>));
3717 impl Debug for Print {
3718 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3719 formatter.write_str("Some")?;
3720 let _val = &self.0;
3721 formatter.write_str("(")?;
3722 Debug::fmt(Lite(&_val.1), formatter)?;
3723 formatter.write_str(")")?;
3724 Ok(())
3725 }
3726 }
3727 formatter.field("subpat", Print::ref_cast(val));
3728 }
3729 formatter.finish()
3730 }
3731 syn::Pat::Lit(_val) => {
3732 let mut formatter = formatter.debug_struct("Pat::Lit");
3733 if !_val.attrs.is_empty() {
3734 formatter.field("attrs", Lite(&_val.attrs));
3735 }
3736 formatter.field("expr", Lite(&_val.expr));
3737 formatter.finish()
3738 }
3739 syn::Pat::Macro(_val) => {
3740 let mut formatter = formatter.debug_struct("Pat::Macro");
3741 if !_val.attrs.is_empty() {
3742 formatter.field("attrs", Lite(&_val.attrs));
3743 }
3744 formatter.field("mac", Lite(&_val.mac));
3745 formatter.finish()
3746 }
3747 syn::Pat::Or(_val) => {
3748 let mut formatter = formatter.debug_struct("Pat::Or");
3749 if !_val.attrs.is_empty() {
3750 formatter.field("attrs", Lite(&_val.attrs));
3751 }
3752 if let Some(val) = &_val.leading_vert {
3753 #[derive(RefCast)]
3754 #[repr(transparent)]
3755 struct Print(syn::token::Or);
3756 impl Debug for Print {
3757 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3758 formatter.write_str("Some")?;
3759 Ok(())
3760 }
3761 }
3762 formatter.field("leading_vert", Print::ref_cast(val));
3763 }
3764 if !_val.cases.is_empty() {
3765 formatter.field("cases", Lite(&_val.cases));
3766 }
3767 formatter.finish()
3768 }
3769 syn::Pat::Path(_val) => {
3770 let mut formatter = formatter.debug_struct("Pat::Path");
3771 if !_val.attrs.is_empty() {
3772 formatter.field("attrs", Lite(&_val.attrs));
3773 }
3774 if let Some(val) = &_val.qself {
3775 #[derive(RefCast)]
3776 #[repr(transparent)]
3777 struct Print(syn::QSelf);
3778 impl Debug for Print {
3779 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3780 formatter.write_str("Some")?;
3781 let _val = &self.0;
3782 formatter.write_str("(")?;
3783 Debug::fmt(Lite(_val), formatter)?;
3784 formatter.write_str(")")?;
3785 Ok(())
3786 }
3787 }
3788 formatter.field("qself", Print::ref_cast(val));
3789 }
3790 formatter.field("path", Lite(&_val.path));
3791 formatter.finish()
3792 }
3793 syn::Pat::Range(_val) => {
3794 let mut formatter = formatter.debug_struct("Pat::Range");
3795 if !_val.attrs.is_empty() {
3796 formatter.field("attrs", Lite(&_val.attrs));
3797 }
3798 formatter.field("lo", Lite(&_val.lo));
3799 formatter.field("limits", Lite(&_val.limits));
3800 formatter.field("hi", Lite(&_val.hi));
3801 formatter.finish()
3802 }
3803 syn::Pat::Reference(_val) => {
3804 let mut formatter = formatter.debug_struct("Pat::Reference");
3805 if !_val.attrs.is_empty() {
3806 formatter.field("attrs", Lite(&_val.attrs));
3807 }
3808 if let Some(val) = &_val.mutability {
3809 #[derive(RefCast)]
3810 #[repr(transparent)]
3811 struct Print(syn::token::Mut);
3812 impl Debug for Print {
3813 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3814 formatter.write_str("Some")?;
3815 Ok(())
3816 }
3817 }
3818 formatter.field("mutability", Print::ref_cast(val));
3819 }
3820 formatter.field("pat", Lite(&_val.pat));
3821 formatter.finish()
3822 }
3823 syn::Pat::Rest(_val) => {
3824 let mut formatter = formatter.debug_struct("Pat::Rest");
3825 if !_val.attrs.is_empty() {
3826 formatter.field("attrs", Lite(&_val.attrs));
3827 }
3828 formatter.finish()
3829 }
3830 syn::Pat::Slice(_val) => {
3831 let mut formatter = formatter.debug_struct("Pat::Slice");
3832 if !_val.attrs.is_empty() {
3833 formatter.field("attrs", Lite(&_val.attrs));
3834 }
3835 if !_val.elems.is_empty() {
3836 formatter.field("elems", Lite(&_val.elems));
3837 }
3838 formatter.finish()
3839 }
3840 syn::Pat::Struct(_val) => {
3841 let mut formatter = formatter.debug_struct("Pat::Struct");
3842 if !_val.attrs.is_empty() {
3843 formatter.field("attrs", Lite(&_val.attrs));
3844 }
3845 formatter.field("path", Lite(&_val.path));
3846 if !_val.fields.is_empty() {
3847 formatter.field("fields", Lite(&_val.fields));
3848 }
3849 if let Some(val) = &_val.dot2_token {
3850 #[derive(RefCast)]
3851 #[repr(transparent)]
3852 struct Print(syn::token::Dot2);
3853 impl Debug for Print {
3854 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3855 formatter.write_str("Some")?;
3856 Ok(())
3857 }
3858 }
3859 formatter.field("dot2_token", Print::ref_cast(val));
3860 }
3861 formatter.finish()
3862 }
3863 syn::Pat::Tuple(_val) => {
3864 let mut formatter = formatter.debug_struct("Pat::Tuple");
3865 if !_val.attrs.is_empty() {
3866 formatter.field("attrs", Lite(&_val.attrs));
3867 }
3868 if !_val.elems.is_empty() {
3869 formatter.field("elems", Lite(&_val.elems));
3870 }
3871 formatter.finish()
3872 }
3873 syn::Pat::TupleStruct(_val) => {
3874 let mut formatter = formatter.debug_struct("Pat::TupleStruct");
3875 if !_val.attrs.is_empty() {
3876 formatter.field("attrs", Lite(&_val.attrs));
3877 }
3878 formatter.field("path", Lite(&_val.path));
3879 formatter.field("pat", Lite(&_val.pat));
3880 formatter.finish()
3881 }
3882 syn::Pat::Type(_val) => {
3883 let mut formatter = formatter.debug_struct("Pat::Type");
3884 if !_val.attrs.is_empty() {
3885 formatter.field("attrs", Lite(&_val.attrs));
3886 }
3887 formatter.field("pat", Lite(&_val.pat));
3888 formatter.field("ty", Lite(&_val.ty));
3889 formatter.finish()
3890 }
3891 syn::Pat::Verbatim(_val) => {
3892 formatter.write_str("Verbatim")?;
3893 formatter.write_str("(`")?;
3894 Display::fmt(_val, formatter)?;
3895 formatter.write_str("`)")?;
3896 Ok(())
3897 }
3898 syn::Pat::Wild(_val) => {
3899 let mut formatter = formatter.debug_struct("Pat::Wild");
3900 if !_val.attrs.is_empty() {
3901 formatter.field("attrs", Lite(&_val.attrs));
3902 }
3903 formatter.finish()
3904 }
3905 _ => unreachable!(),
3906 }
3907 }
3908 }
3909 impl Debug for Lite<syn::PatBox> {
3910 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3911 let _val = &self.value;
3912 let mut formatter = formatter.debug_struct("PatBox");
3913 if !_val.attrs.is_empty() {
3914 formatter.field("attrs", Lite(&_val.attrs));
3915 }
3916 formatter.field("pat", Lite(&_val.pat));
3917 formatter.finish()
3918 }
3919 }
3920 impl Debug for Lite<syn::PatIdent> {
3921 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3922 let _val = &self.value;
3923 let mut formatter = formatter.debug_struct("PatIdent");
3924 if !_val.attrs.is_empty() {
3925 formatter.field("attrs", Lite(&_val.attrs));
3926 }
3927 if let Some(val) = &_val.by_ref {
3928 #[derive(RefCast)]
3929 #[repr(transparent)]
3930 struct Print(syn::token::Ref);
3931 impl Debug for Print {
3932 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3933 formatter.write_str("Some")?;
3934 Ok(())
3935 }
3936 }
3937 formatter.field("by_ref", Print::ref_cast(val));
3938 }
3939 if let Some(val) = &_val.mutability {
3940 #[derive(RefCast)]
3941 #[repr(transparent)]
3942 struct Print(syn::token::Mut);
3943 impl Debug for Print {
3944 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3945 formatter.write_str("Some")?;
3946 Ok(())
3947 }
3948 }
3949 formatter.field("mutability", Print::ref_cast(val));
3950 }
3951 formatter.field("ident", Lite(&_val.ident));
3952 if let Some(val) = &_val.subpat {
3953 #[derive(RefCast)]
3954 #[repr(transparent)]
3955 struct Print((syn::token::At, Box<syn::Pat>));
3956 impl Debug for Print {
3957 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3958 formatter.write_str("Some")?;
3959 let _val = &self.0;
3960 formatter.write_str("(")?;
3961 Debug::fmt(Lite(&_val.1), formatter)?;
3962 formatter.write_str(")")?;
3963 Ok(())
3964 }
3965 }
3966 formatter.field("subpat", Print::ref_cast(val));
3967 }
3968 formatter.finish()
3969 }
3970 }
3971 impl Debug for Lite<syn::PatLit> {
3972 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3973 let _val = &self.value;
3974 let mut formatter = formatter.debug_struct("PatLit");
3975 if !_val.attrs.is_empty() {
3976 formatter.field("attrs", Lite(&_val.attrs));
3977 }
3978 formatter.field("expr", Lite(&_val.expr));
3979 formatter.finish()
3980 }
3981 }
3982 impl Debug for Lite<syn::PatMacro> {
3983 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3984 let _val = &self.value;
3985 let mut formatter = formatter.debug_struct("PatMacro");
3986 if !_val.attrs.is_empty() {
3987 formatter.field("attrs", Lite(&_val.attrs));
3988 }
3989 formatter.field("mac", Lite(&_val.mac));
3990 formatter.finish()
3991 }
3992 }
3993 impl Debug for Lite<syn::PatOr> {
3994 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3995 let _val = &self.value;
3996 let mut formatter = formatter.debug_struct("PatOr");
3997 if !_val.attrs.is_empty() {
3998 formatter.field("attrs", Lite(&_val.attrs));
3999 }
4000 if let Some(val) = &_val.leading_vert {
4001 #[derive(RefCast)]
4002 #[repr(transparent)]
4003 struct Print(syn::token::Or);
4004 impl Debug for Print {
4005 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4006 formatter.write_str("Some")?;
4007 Ok(())
4008 }
4009 }
4010 formatter.field("leading_vert", Print::ref_cast(val));
4011 }
4012 if !_val.cases.is_empty() {
4013 formatter.field("cases", Lite(&_val.cases));
4014 }
4015 formatter.finish()
4016 }
4017 }
4018 impl Debug for Lite<syn::PatPath> {
4019 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4020 let _val = &self.value;
4021 let mut formatter = formatter.debug_struct("PatPath");
4022 if !_val.attrs.is_empty() {
4023 formatter.field("attrs", Lite(&_val.attrs));
4024 }
4025 if let Some(val) = &_val.qself {
4026 #[derive(RefCast)]
4027 #[repr(transparent)]
4028 struct Print(syn::QSelf);
4029 impl Debug for Print {
4030 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4031 formatter.write_str("Some")?;
4032 let _val = &self.0;
4033 formatter.write_str("(")?;
4034 Debug::fmt(Lite(_val), formatter)?;
4035 formatter.write_str(")")?;
4036 Ok(())
4037 }
4038 }
4039 formatter.field("qself", Print::ref_cast(val));
4040 }
4041 formatter.field("path", Lite(&_val.path));
4042 formatter.finish()
4043 }
4044 }
4045 impl Debug for Lite<syn::PatRange> {
4046 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4047 let _val = &self.value;
4048 let mut formatter = formatter.debug_struct("PatRange");
4049 if !_val.attrs.is_empty() {
4050 formatter.field("attrs", Lite(&_val.attrs));
4051 }
4052 formatter.field("lo", Lite(&_val.lo));
4053 formatter.field("limits", Lite(&_val.limits));
4054 formatter.field("hi", Lite(&_val.hi));
4055 formatter.finish()
4056 }
4057 }
4058 impl Debug for Lite<syn::PatReference> {
4059 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4060 let _val = &self.value;
4061 let mut formatter = formatter.debug_struct("PatReference");
4062 if !_val.attrs.is_empty() {
4063 formatter.field("attrs", Lite(&_val.attrs));
4064 }
4065 if let Some(val) = &_val.mutability {
4066 #[derive(RefCast)]
4067 #[repr(transparent)]
4068 struct Print(syn::token::Mut);
4069 impl Debug for Print {
4070 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4071 formatter.write_str("Some")?;
4072 Ok(())
4073 }
4074 }
4075 formatter.field("mutability", Print::ref_cast(val));
4076 }
4077 formatter.field("pat", Lite(&_val.pat));
4078 formatter.finish()
4079 }
4080 }
4081 impl Debug for Lite<syn::PatRest> {
4082 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4083 let _val = &self.value;
4084 let mut formatter = formatter.debug_struct("PatRest");
4085 if !_val.attrs.is_empty() {
4086 formatter.field("attrs", Lite(&_val.attrs));
4087 }
4088 formatter.finish()
4089 }
4090 }
4091 impl Debug for Lite<syn::PatSlice> {
4092 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4093 let _val = &self.value;
4094 let mut formatter = formatter.debug_struct("PatSlice");
4095 if !_val.attrs.is_empty() {
4096 formatter.field("attrs", Lite(&_val.attrs));
4097 }
4098 if !_val.elems.is_empty() {
4099 formatter.field("elems", Lite(&_val.elems));
4100 }
4101 formatter.finish()
4102 }
4103 }
4104 impl Debug for Lite<syn::PatStruct> {
4105 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4106 let _val = &self.value;
4107 let mut formatter = formatter.debug_struct("PatStruct");
4108 if !_val.attrs.is_empty() {
4109 formatter.field("attrs", Lite(&_val.attrs));
4110 }
4111 formatter.field("path", Lite(&_val.path));
4112 if !_val.fields.is_empty() {
4113 formatter.field("fields", Lite(&_val.fields));
4114 }
4115 if let Some(val) = &_val.dot2_token {
4116 #[derive(RefCast)]
4117 #[repr(transparent)]
4118 struct Print(syn::token::Dot2);
4119 impl Debug for Print {
4120 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4121 formatter.write_str("Some")?;
4122 Ok(())
4123 }
4124 }
4125 formatter.field("dot2_token", Print::ref_cast(val));
4126 }
4127 formatter.finish()
4128 }
4129 }
4130 impl Debug for Lite<syn::PatTuple> {
4131 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4132 let _val = &self.value;
4133 let mut formatter = formatter.debug_struct("PatTuple");
4134 if !_val.attrs.is_empty() {
4135 formatter.field("attrs", Lite(&_val.attrs));
4136 }
4137 if !_val.elems.is_empty() {
4138 formatter.field("elems", Lite(&_val.elems));
4139 }
4140 formatter.finish()
4141 }
4142 }
4143 impl Debug for Lite<syn::PatTupleStruct> {
4144 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4145 let _val = &self.value;
4146 let mut formatter = formatter.debug_struct("PatTupleStruct");
4147 if !_val.attrs.is_empty() {
4148 formatter.field("attrs", Lite(&_val.attrs));
4149 }
4150 formatter.field("path", Lite(&_val.path));
4151 formatter.field("pat", Lite(&_val.pat));
4152 formatter.finish()
4153 }
4154 }
4155 impl Debug for Lite<syn::PatType> {
4156 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4157 let _val = &self.value;
4158 let mut formatter = formatter.debug_struct("PatType");
4159 if !_val.attrs.is_empty() {
4160 formatter.field("attrs", Lite(&_val.attrs));
4161 }
4162 formatter.field("pat", Lite(&_val.pat));
4163 formatter.field("ty", Lite(&_val.ty));
4164 formatter.finish()
4165 }
4166 }
4167 impl Debug for Lite<syn::PatWild> {
4168 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4169 let _val = &self.value;
4170 let mut formatter = formatter.debug_struct("PatWild");
4171 if !_val.attrs.is_empty() {
4172 formatter.field("attrs", Lite(&_val.attrs));
4173 }
4174 formatter.finish()
4175 }
4176 }
4177 impl Debug for Lite<syn::Path> {
4178 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4179 let _val = &self.value;
4180 let mut formatter = formatter.debug_struct("Path");
4181 if let Some(val) = &_val.leading_colon {
4182 #[derive(RefCast)]
4183 #[repr(transparent)]
4184 struct Print(syn::token::Colon2);
4185 impl Debug for Print {
4186 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4187 formatter.write_str("Some")?;
4188 Ok(())
4189 }
4190 }
4191 formatter.field("leading_colon", Print::ref_cast(val));
4192 }
4193 if !_val.segments.is_empty() {
4194 formatter.field("segments", Lite(&_val.segments));
4195 }
4196 formatter.finish()
4197 }
4198 }
4199 impl Debug for Lite<syn::PathArguments> {
4200 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4201 let _val = &self.value;
4202 match _val {
4203 syn::PathArguments::None => formatter.write_str("None"),
4204 syn::PathArguments::AngleBracketed(_val) => {
4205 let mut formatter = formatter.debug_struct("PathArguments::AngleBracketed");
4206 if let Some(val) = &_val.colon2_token {
4207 #[derive(RefCast)]
4208 #[repr(transparent)]
4209 struct Print(syn::token::Colon2);
4210 impl Debug for Print {
4211 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4212 formatter.write_str("Some")?;
4213 Ok(())
4214 }
4215 }
4216 formatter.field("colon2_token", Print::ref_cast(val));
4217 }
4218 if !_val.args.is_empty() {
4219 formatter.field("args", Lite(&_val.args));
4220 }
4221 formatter.finish()
4222 }
4223 syn::PathArguments::Parenthesized(_val) => {
4224 let mut formatter = formatter.debug_struct("PathArguments::Parenthesized");
4225 if !_val.inputs.is_empty() {
4226 formatter.field("inputs", Lite(&_val.inputs));
4227 }
4228 formatter.field("output", Lite(&_val.output));
4229 formatter.finish()
4230 }
4231 }
4232 }
4233 }
4234 impl Debug for Lite<syn::PathSegment> {
4235 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4236 let _val = &self.value;
4237 let mut formatter = formatter.debug_struct("PathSegment");
4238 formatter.field("ident", Lite(&_val.ident));
4239 formatter.field("arguments", Lite(&_val.arguments));
4240 formatter.finish()
4241 }
4242 }
4243 impl Debug for Lite<syn::PredicateEq> {
4244 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4245 let _val = &self.value;
4246 let mut formatter = formatter.debug_struct("PredicateEq");
4247 formatter.field("lhs_ty", Lite(&_val.lhs_ty));
4248 formatter.field("rhs_ty", Lite(&_val.rhs_ty));
4249 formatter.finish()
4250 }
4251 }
4252 impl Debug for Lite<syn::PredicateLifetime> {
4253 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4254 let _val = &self.value;
4255 let mut formatter = formatter.debug_struct("PredicateLifetime");
4256 formatter.field("lifetime", Lite(&_val.lifetime));
4257 if !_val.bounds.is_empty() {
4258 formatter.field("bounds", Lite(&_val.bounds));
4259 }
4260 formatter.finish()
4261 }
4262 }
4263 impl Debug for Lite<syn::PredicateType> {
4264 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4265 let _val = &self.value;
4266 let mut formatter = formatter.debug_struct("PredicateType");
4267 if let Some(val) = &_val.lifetimes {
4268 #[derive(RefCast)]
4269 #[repr(transparent)]
4270 struct Print(syn::BoundLifetimes);
4271 impl Debug for Print {
4272 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4273 formatter.write_str("Some")?;
4274 let _val = &self.0;
4275 formatter.write_str("(")?;
4276 Debug::fmt(Lite(_val), formatter)?;
4277 formatter.write_str(")")?;
4278 Ok(())
4279 }
4280 }
4281 formatter.field("lifetimes", Print::ref_cast(val));
4282 }
4283 formatter.field("bounded_ty", Lite(&_val.bounded_ty));
4284 if !_val.bounds.is_empty() {
4285 formatter.field("bounds", Lite(&_val.bounds));
4286 }
4287 formatter.finish()
4288 }
4289 }
4290 impl Debug for Lite<syn::QSelf> {
4291 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4292 let _val = &self.value;
4293 let mut formatter = formatter.debug_struct("QSelf");
4294 formatter.field("ty", Lite(&_val.ty));
4295 formatter.field("position", Lite(&_val.position));
4296 if let Some(val) = &_val.as_token {
4297 #[derive(RefCast)]
4298 #[repr(transparent)]
4299 struct Print(syn::token::As);
4300 impl Debug for Print {
4301 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4302 formatter.write_str("Some")?;
4303 Ok(())
4304 }
4305 }
4306 formatter.field("as_token", Print::ref_cast(val));
4307 }
4308 formatter.finish()
4309 }
4310 }
4311 impl Debug for Lite<syn::RangeLimits> {
4312 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4313 let _val = &self.value;
4314 match _val {
4315 syn::RangeLimits::HalfOpen(_val) => {
4316 formatter.write_str("HalfOpen")?;
4317 Ok(())
4318 }
4319 syn::RangeLimits::Closed(_val) => {
4320 formatter.write_str("Closed")?;
4321 Ok(())
4322 }
4323 }
4324 }
4325 }
4326 impl Debug for Lite<syn::Receiver> {
4327 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4328 let _val = &self.value;
4329 let mut formatter = formatter.debug_struct("Receiver");
4330 if !_val.attrs.is_empty() {
4331 formatter.field("attrs", Lite(&_val.attrs));
4332 }
4333 if let Some(val) = &_val.reference {
4334 #[derive(RefCast)]
4335 #[repr(transparent)]
4336 struct Print((syn::token::And, Option<syn::Lifetime>));
4337 impl Debug for Print {
4338 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4339 formatter.write_str("Some")?;
4340 let _val = &self.0;
4341 formatter.write_str("(")?;
4342 Debug::fmt(
4343 {
4344 #[derive(RefCast)]
4345 #[repr(transparent)]
4346 struct Print(Option<syn::Lifetime>);
4347 impl Debug for Print {
4348 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4349 match &self.0 {
4350 Some(_val) => {
4351 formatter.write_str("Some")?;
4352 formatter.write_str("(")?;
4353 Debug::fmt(Lite(_val), formatter)?;
4354 formatter.write_str(")")?;
4355 Ok(())
4356 }
4357 None => formatter.write_str("None"),
4358 }
4359 }
4360 }
4361 Print::ref_cast(&_val.1)
4362 },
4363 formatter,
4364 )?;
4365 formatter.write_str(")")?;
4366 Ok(())
4367 }
4368 }
4369 formatter.field("reference", Print::ref_cast(val));
4370 }
4371 if let Some(val) = &_val.mutability {
4372 #[derive(RefCast)]
4373 #[repr(transparent)]
4374 struct Print(syn::token::Mut);
4375 impl Debug for Print {
4376 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4377 formatter.write_str("Some")?;
4378 Ok(())
4379 }
4380 }
4381 formatter.field("mutability", Print::ref_cast(val));
4382 }
4383 formatter.finish()
4384 }
4385 }
4386 impl Debug for Lite<syn::ReturnType> {
4387 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4388 let _val = &self.value;
4389 match _val {
4390 syn::ReturnType::Default => formatter.write_str("Default"),
4391 syn::ReturnType::Type(_v0, _v1) => {
4392 let mut formatter = formatter.debug_tuple("Type");
4393 formatter.field(Lite(_v1));
4394 formatter.finish()
4395 }
4396 }
4397 }
4398 }
4399 impl Debug for Lite<syn::Signature> {
4400 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4401 let _val = &self.value;
4402 let mut formatter = formatter.debug_struct("Signature");
4403 if let Some(val) = &_val.constness {
4404 #[derive(RefCast)]
4405 #[repr(transparent)]
4406 struct Print(syn::token::Const);
4407 impl Debug for Print {
4408 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4409 formatter.write_str("Some")?;
4410 Ok(())
4411 }
4412 }
4413 formatter.field("constness", Print::ref_cast(val));
4414 }
4415 if let Some(val) = &_val.asyncness {
4416 #[derive(RefCast)]
4417 #[repr(transparent)]
4418 struct Print(syn::token::Async);
4419 impl Debug for Print {
4420 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4421 formatter.write_str("Some")?;
4422 Ok(())
4423 }
4424 }
4425 formatter.field("asyncness", Print::ref_cast(val));
4426 }
4427 if let Some(val) = &_val.unsafety {
4428 #[derive(RefCast)]
4429 #[repr(transparent)]
4430 struct Print(syn::token::Unsafe);
4431 impl Debug for Print {
4432 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4433 formatter.write_str("Some")?;
4434 Ok(())
4435 }
4436 }
4437 formatter.field("unsafety", Print::ref_cast(val));
4438 }
4439 if let Some(val) = &_val.abi {
4440 #[derive(RefCast)]
4441 #[repr(transparent)]
4442 struct Print(syn::Abi);
4443 impl Debug for Print {
4444 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4445 formatter.write_str("Some")?;
4446 let _val = &self.0;
4447 formatter.write_str("(")?;
4448 Debug::fmt(Lite(_val), formatter)?;
4449 formatter.write_str(")")?;
4450 Ok(())
4451 }
4452 }
4453 formatter.field("abi", Print::ref_cast(val));
4454 }
4455 formatter.field("ident", Lite(&_val.ident));
4456 formatter.field("generics", Lite(&_val.generics));
4457 if !_val.inputs.is_empty() {
4458 formatter.field("inputs", Lite(&_val.inputs));
4459 }
4460 if let Some(val) = &_val.variadic {
4461 #[derive(RefCast)]
4462 #[repr(transparent)]
4463 struct Print(syn::Variadic);
4464 impl Debug for Print {
4465 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4466 formatter.write_str("Some")?;
4467 let _val = &self.0;
4468 formatter.write_str("(")?;
4469 Debug::fmt(Lite(_val), formatter)?;
4470 formatter.write_str(")")?;
4471 Ok(())
4472 }
4473 }
4474 formatter.field("variadic", Print::ref_cast(val));
4475 }
4476 formatter.field("output", Lite(&_val.output));
4477 formatter.finish()
4478 }
4479 }
4480 impl Debug for Lite<syn::Stmt> {
4481 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4482 let _val = &self.value;
4483 match _val {
4484 syn::Stmt::Local(_val) => {
4485 formatter.write_str("Local")?;
4486 formatter.write_str("(")?;
4487 Debug::fmt(Lite(_val), formatter)?;
4488 formatter.write_str(")")?;
4489 Ok(())
4490 }
4491 syn::Stmt::Item(_val) => {
4492 formatter.write_str("Item")?;
4493 formatter.write_str("(")?;
4494 Debug::fmt(Lite(_val), formatter)?;
4495 formatter.write_str(")")?;
4496 Ok(())
4497 }
4498 syn::Stmt::Expr(_val) => {
4499 formatter.write_str("Expr")?;
4500 formatter.write_str("(")?;
4501 Debug::fmt(Lite(_val), formatter)?;
4502 formatter.write_str(")")?;
4503 Ok(())
4504 }
4505 syn::Stmt::Semi(_v0, _v1) => {
4506 let mut formatter = formatter.debug_tuple("Semi");
4507 formatter.field(Lite(_v0));
4508 formatter.finish()
4509 }
4510 }
4511 }
4512 }
4513 impl Debug for Lite<syn::TraitBound> {
4514 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4515 let _val = &self.value;
4516 let mut formatter = formatter.debug_struct("TraitBound");
4517 if let Some(val) = &_val.paren_token {
4518 #[derive(RefCast)]
4519 #[repr(transparent)]
4520 struct Print(syn::token::Paren);
4521 impl Debug for Print {
4522 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4523 formatter.write_str("Some")?;
4524 Ok(())
4525 }
4526 }
4527 formatter.field("paren_token", Print::ref_cast(val));
4528 }
4529 formatter.field("modifier", Lite(&_val.modifier));
4530 if let Some(val) = &_val.lifetimes {
4531 #[derive(RefCast)]
4532 #[repr(transparent)]
4533 struct Print(syn::BoundLifetimes);
4534 impl Debug for Print {
4535 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4536 formatter.write_str("Some")?;
4537 let _val = &self.0;
4538 formatter.write_str("(")?;
4539 Debug::fmt(Lite(_val), formatter)?;
4540 formatter.write_str(")")?;
4541 Ok(())
4542 }
4543 }
4544 formatter.field("lifetimes", Print::ref_cast(val));
4545 }
4546 formatter.field("path", Lite(&_val.path));
4547 formatter.finish()
4548 }
4549 }
4550 impl Debug for Lite<syn::TraitBoundModifier> {
4551 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4552 let _val = &self.value;
4553 match _val {
4554 syn::TraitBoundModifier::None => formatter.write_str("None"),
4555 syn::TraitBoundModifier::Maybe(_val) => {
4556 formatter.write_str("Maybe")?;
4557 Ok(())
4558 }
4559 }
4560 }
4561 }
4562 impl Debug for Lite<syn::TraitItem> {
4563 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4564 let _val = &self.value;
4565 match _val {
4566 syn::TraitItem::Const(_val) => {
4567 let mut formatter = formatter.debug_struct("TraitItem::Const");
4568 if !_val.attrs.is_empty() {
4569 formatter.field("attrs", Lite(&_val.attrs));
4570 }
4571 formatter.field("ident", Lite(&_val.ident));
4572 formatter.field("ty", Lite(&_val.ty));
4573 if let Some(val) = &_val.default {
4574 #[derive(RefCast)]
4575 #[repr(transparent)]
4576 struct Print((syn::token::Eq, syn::Expr));
4577 impl Debug for Print {
4578 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4579 formatter.write_str("Some")?;
4580 let _val = &self.0;
4581 formatter.write_str("(")?;
4582 Debug::fmt(Lite(&_val.1), formatter)?;
4583 formatter.write_str(")")?;
4584 Ok(())
4585 }
4586 }
4587 formatter.field("default", Print::ref_cast(val));
4588 }
4589 formatter.finish()
4590 }
4591 syn::TraitItem::Method(_val) => {
4592 let mut formatter = formatter.debug_struct("TraitItem::Method");
4593 if !_val.attrs.is_empty() {
4594 formatter.field("attrs", Lite(&_val.attrs));
4595 }
4596 formatter.field("sig", Lite(&_val.sig));
4597 if let Some(val) = &_val.default {
4598 #[derive(RefCast)]
4599 #[repr(transparent)]
4600 struct Print(syn::Block);
4601 impl Debug for Print {
4602 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4603 formatter.write_str("Some")?;
4604 let _val = &self.0;
4605 formatter.write_str("(")?;
4606 Debug::fmt(Lite(_val), formatter)?;
4607 formatter.write_str(")")?;
4608 Ok(())
4609 }
4610 }
4611 formatter.field("default", Print::ref_cast(val));
4612 }
4613 if let Some(val) = &_val.semi_token {
4614 #[derive(RefCast)]
4615 #[repr(transparent)]
4616 struct Print(syn::token::Semi);
4617 impl Debug for Print {
4618 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4619 formatter.write_str("Some")?;
4620 Ok(())
4621 }
4622 }
4623 formatter.field("semi_token", Print::ref_cast(val));
4624 }
4625 formatter.finish()
4626 }
4627 syn::TraitItem::Type(_val) => {
4628 let mut formatter = formatter.debug_struct("TraitItem::Type");
4629 if !_val.attrs.is_empty() {
4630 formatter.field("attrs", Lite(&_val.attrs));
4631 }
4632 formatter.field("ident", Lite(&_val.ident));
4633 formatter.field("generics", Lite(&_val.generics));
4634 if let Some(val) = &_val.colon_token {
4635 #[derive(RefCast)]
4636 #[repr(transparent)]
4637 struct Print(syn::token::Colon);
4638 impl Debug for Print {
4639 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4640 formatter.write_str("Some")?;
4641 Ok(())
4642 }
4643 }
4644 formatter.field("colon_token", Print::ref_cast(val));
4645 }
4646 if !_val.bounds.is_empty() {
4647 formatter.field("bounds", Lite(&_val.bounds));
4648 }
4649 if let Some(val) = &_val.default {
4650 #[derive(RefCast)]
4651 #[repr(transparent)]
4652 struct Print((syn::token::Eq, syn::Type));
4653 impl Debug for Print {
4654 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4655 formatter.write_str("Some")?;
4656 let _val = &self.0;
4657 formatter.write_str("(")?;
4658 Debug::fmt(Lite(&_val.1), formatter)?;
4659 formatter.write_str(")")?;
4660 Ok(())
4661 }
4662 }
4663 formatter.field("default", Print::ref_cast(val));
4664 }
4665 formatter.finish()
4666 }
4667 syn::TraitItem::Macro(_val) => {
4668 let mut formatter = formatter.debug_struct("TraitItem::Macro");
4669 if !_val.attrs.is_empty() {
4670 formatter.field("attrs", Lite(&_val.attrs));
4671 }
4672 formatter.field("mac", Lite(&_val.mac));
4673 if let Some(val) = &_val.semi_token {
4674 #[derive(RefCast)]
4675 #[repr(transparent)]
4676 struct Print(syn::token::Semi);
4677 impl Debug for Print {
4678 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4679 formatter.write_str("Some")?;
4680 Ok(())
4681 }
4682 }
4683 formatter.field("semi_token", Print::ref_cast(val));
4684 }
4685 formatter.finish()
4686 }
4687 syn::TraitItem::Verbatim(_val) => {
4688 formatter.write_str("Verbatim")?;
4689 formatter.write_str("(`")?;
4690 Display::fmt(_val, formatter)?;
4691 formatter.write_str("`)")?;
4692 Ok(())
4693 }
4694 _ => unreachable!(),
4695 }
4696 }
4697 }
4698 impl Debug for Lite<syn::TraitItemConst> {
4699 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4700 let _val = &self.value;
4701 let mut formatter = formatter.debug_struct("TraitItemConst");
4702 if !_val.attrs.is_empty() {
4703 formatter.field("attrs", Lite(&_val.attrs));
4704 }
4705 formatter.field("ident", Lite(&_val.ident));
4706 formatter.field("ty", Lite(&_val.ty));
4707 if let Some(val) = &_val.default {
4708 #[derive(RefCast)]
4709 #[repr(transparent)]
4710 struct Print((syn::token::Eq, syn::Expr));
4711 impl Debug for Print {
4712 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4713 formatter.write_str("Some")?;
4714 let _val = &self.0;
4715 formatter.write_str("(")?;
4716 Debug::fmt(Lite(&_val.1), formatter)?;
4717 formatter.write_str(")")?;
4718 Ok(())
4719 }
4720 }
4721 formatter.field("default", Print::ref_cast(val));
4722 }
4723 formatter.finish()
4724 }
4725 }
4726 impl Debug for Lite<syn::TraitItemMacro> {
4727 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4728 let _val = &self.value;
4729 let mut formatter = formatter.debug_struct("TraitItemMacro");
4730 if !_val.attrs.is_empty() {
4731 formatter.field("attrs", Lite(&_val.attrs));
4732 }
4733 formatter.field("mac", Lite(&_val.mac));
4734 if let Some(val) = &_val.semi_token {
4735 #[derive(RefCast)]
4736 #[repr(transparent)]
4737 struct Print(syn::token::Semi);
4738 impl Debug for Print {
4739 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4740 formatter.write_str("Some")?;
4741 Ok(())
4742 }
4743 }
4744 formatter.field("semi_token", Print::ref_cast(val));
4745 }
4746 formatter.finish()
4747 }
4748 }
4749 impl Debug for Lite<syn::TraitItemMethod> {
4750 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4751 let _val = &self.value;
4752 let mut formatter = formatter.debug_struct("TraitItemMethod");
4753 if !_val.attrs.is_empty() {
4754 formatter.field("attrs", Lite(&_val.attrs));
4755 }
4756 formatter.field("sig", Lite(&_val.sig));
4757 if let Some(val) = &_val.default {
4758 #[derive(RefCast)]
4759 #[repr(transparent)]
4760 struct Print(syn::Block);
4761 impl Debug for Print {
4762 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4763 formatter.write_str("Some")?;
4764 let _val = &self.0;
4765 formatter.write_str("(")?;
4766 Debug::fmt(Lite(_val), formatter)?;
4767 formatter.write_str(")")?;
4768 Ok(())
4769 }
4770 }
4771 formatter.field("default", Print::ref_cast(val));
4772 }
4773 if let Some(val) = &_val.semi_token {
4774 #[derive(RefCast)]
4775 #[repr(transparent)]
4776 struct Print(syn::token::Semi);
4777 impl Debug for Print {
4778 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4779 formatter.write_str("Some")?;
4780 Ok(())
4781 }
4782 }
4783 formatter.field("semi_token", Print::ref_cast(val));
4784 }
4785 formatter.finish()
4786 }
4787 }
4788 impl Debug for Lite<syn::TraitItemType> {
4789 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4790 let _val = &self.value;
4791 let mut formatter = formatter.debug_struct("TraitItemType");
4792 if !_val.attrs.is_empty() {
4793 formatter.field("attrs", Lite(&_val.attrs));
4794 }
4795 formatter.field("ident", Lite(&_val.ident));
4796 formatter.field("generics", Lite(&_val.generics));
4797 if let Some(val) = &_val.colon_token {
4798 #[derive(RefCast)]
4799 #[repr(transparent)]
4800 struct Print(syn::token::Colon);
4801 impl Debug for Print {
4802 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4803 formatter.write_str("Some")?;
4804 Ok(())
4805 }
4806 }
4807 formatter.field("colon_token", Print::ref_cast(val));
4808 }
4809 if !_val.bounds.is_empty() {
4810 formatter.field("bounds", Lite(&_val.bounds));
4811 }
4812 if let Some(val) = &_val.default {
4813 #[derive(RefCast)]
4814 #[repr(transparent)]
4815 struct Print((syn::token::Eq, syn::Type));
4816 impl Debug for Print {
4817 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4818 formatter.write_str("Some")?;
4819 let _val = &self.0;
4820 formatter.write_str("(")?;
4821 Debug::fmt(Lite(&_val.1), formatter)?;
4822 formatter.write_str(")")?;
4823 Ok(())
4824 }
4825 }
4826 formatter.field("default", Print::ref_cast(val));
4827 }
4828 formatter.finish()
4829 }
4830 }
4831 impl Debug for Lite<syn::Type> {
4832 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4833 let _val = &self.value;
4834 match _val {
4835 syn::Type::Array(_val) => {
4836 let mut formatter = formatter.debug_struct("Type::Array");
4837 formatter.field("elem", Lite(&_val.elem));
4838 formatter.field("len", Lite(&_val.len));
4839 formatter.finish()
4840 }
4841 syn::Type::BareFn(_val) => {
4842 let mut formatter = formatter.debug_struct("Type::BareFn");
4843 if let Some(val) = &_val.lifetimes {
4844 #[derive(RefCast)]
4845 #[repr(transparent)]
4846 struct Print(syn::BoundLifetimes);
4847 impl Debug for Print {
4848 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4849 formatter.write_str("Some")?;
4850 let _val = &self.0;
4851 formatter.write_str("(")?;
4852 Debug::fmt(Lite(_val), formatter)?;
4853 formatter.write_str(")")?;
4854 Ok(())
4855 }
4856 }
4857 formatter.field("lifetimes", Print::ref_cast(val));
4858 }
4859 if let Some(val) = &_val.unsafety {
4860 #[derive(RefCast)]
4861 #[repr(transparent)]
4862 struct Print(syn::token::Unsafe);
4863 impl Debug for Print {
4864 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4865 formatter.write_str("Some")?;
4866 Ok(())
4867 }
4868 }
4869 formatter.field("unsafety", Print::ref_cast(val));
4870 }
4871 if let Some(val) = &_val.abi {
4872 #[derive(RefCast)]
4873 #[repr(transparent)]
4874 struct Print(syn::Abi);
4875 impl Debug for Print {
4876 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4877 formatter.write_str("Some")?;
4878 let _val = &self.0;
4879 formatter.write_str("(")?;
4880 Debug::fmt(Lite(_val), formatter)?;
4881 formatter.write_str(")")?;
4882 Ok(())
4883 }
4884 }
4885 formatter.field("abi", Print::ref_cast(val));
4886 }
4887 if !_val.inputs.is_empty() {
4888 formatter.field("inputs", Lite(&_val.inputs));
4889 }
4890 if let Some(val) = &_val.variadic {
4891 #[derive(RefCast)]
4892 #[repr(transparent)]
4893 struct Print(syn::Variadic);
4894 impl Debug for Print {
4895 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4896 formatter.write_str("Some")?;
4897 let _val = &self.0;
4898 formatter.write_str("(")?;
4899 Debug::fmt(Lite(_val), formatter)?;
4900 formatter.write_str(")")?;
4901 Ok(())
4902 }
4903 }
4904 formatter.field("variadic", Print::ref_cast(val));
4905 }
4906 formatter.field("output", Lite(&_val.output));
4907 formatter.finish()
4908 }
4909 syn::Type::Group(_val) => {
4910 let mut formatter = formatter.debug_struct("Type::Group");
4911 formatter.field("elem", Lite(&_val.elem));
4912 formatter.finish()
4913 }
4914 syn::Type::ImplTrait(_val) => {
4915 let mut formatter = formatter.debug_struct("Type::ImplTrait");
4916 if !_val.bounds.is_empty() {
4917 formatter.field("bounds", Lite(&_val.bounds));
4918 }
4919 formatter.finish()
4920 }
4921 syn::Type::Infer(_val) => {
4922 let mut formatter = formatter.debug_struct("Type::Infer");
4923 formatter.finish()
4924 }
4925 syn::Type::Macro(_val) => {
4926 let mut formatter = formatter.debug_struct("Type::Macro");
4927 formatter.field("mac", Lite(&_val.mac));
4928 formatter.finish()
4929 }
4930 syn::Type::Never(_val) => {
4931 let mut formatter = formatter.debug_struct("Type::Never");
4932 formatter.finish()
4933 }
4934 syn::Type::Paren(_val) => {
4935 let mut formatter = formatter.debug_struct("Type::Paren");
4936 formatter.field("elem", Lite(&_val.elem));
4937 formatter.finish()
4938 }
4939 syn::Type::Path(_val) => {
4940 let mut formatter = formatter.debug_struct("Type::Path");
4941 if let Some(val) = &_val.qself {
4942 #[derive(RefCast)]
4943 #[repr(transparent)]
4944 struct Print(syn::QSelf);
4945 impl Debug for Print {
4946 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4947 formatter.write_str("Some")?;
4948 let _val = &self.0;
4949 formatter.write_str("(")?;
4950 Debug::fmt(Lite(_val), formatter)?;
4951 formatter.write_str(")")?;
4952 Ok(())
4953 }
4954 }
4955 formatter.field("qself", Print::ref_cast(val));
4956 }
4957 formatter.field("path", Lite(&_val.path));
4958 formatter.finish()
4959 }
4960 syn::Type::Ptr(_val) => {
4961 let mut formatter = formatter.debug_struct("Type::Ptr");
4962 if let Some(val) = &_val.const_token {
4963 #[derive(RefCast)]
4964 #[repr(transparent)]
4965 struct Print(syn::token::Const);
4966 impl Debug for Print {
4967 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4968 formatter.write_str("Some")?;
4969 Ok(())
4970 }
4971 }
4972 formatter.field("const_token", Print::ref_cast(val));
4973 }
4974 if let Some(val) = &_val.mutability {
4975 #[derive(RefCast)]
4976 #[repr(transparent)]
4977 struct Print(syn::token::Mut);
4978 impl Debug for Print {
4979 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4980 formatter.write_str("Some")?;
4981 Ok(())
4982 }
4983 }
4984 formatter.field("mutability", Print::ref_cast(val));
4985 }
4986 formatter.field("elem", Lite(&_val.elem));
4987 formatter.finish()
4988 }
4989 syn::Type::Reference(_val) => {
4990 let mut formatter = formatter.debug_struct("Type::Reference");
4991 if let Some(val) = &_val.lifetime {
4992 #[derive(RefCast)]
4993 #[repr(transparent)]
4994 struct Print(syn::Lifetime);
4995 impl Debug for Print {
4996 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4997 formatter.write_str("Some")?;
4998 let _val = &self.0;
4999 formatter.write_str("(")?;
5000 Debug::fmt(Lite(_val), formatter)?;
5001 formatter.write_str(")")?;
5002 Ok(())
5003 }
5004 }
5005 formatter.field("lifetime", Print::ref_cast(val));
5006 }
5007 if let Some(val) = &_val.mutability {
5008 #[derive(RefCast)]
5009 #[repr(transparent)]
5010 struct Print(syn::token::Mut);
5011 impl Debug for Print {
5012 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5013 formatter.write_str("Some")?;
5014 Ok(())
5015 }
5016 }
5017 formatter.field("mutability", Print::ref_cast(val));
5018 }
5019 formatter.field("elem", Lite(&_val.elem));
5020 formatter.finish()
5021 }
5022 syn::Type::Slice(_val) => {
5023 let mut formatter = formatter.debug_struct("Type::Slice");
5024 formatter.field("elem", Lite(&_val.elem));
5025 formatter.finish()
5026 }
5027 syn::Type::TraitObject(_val) => {
5028 let mut formatter = formatter.debug_struct("Type::TraitObject");
5029 if let Some(val) = &_val.dyn_token {
5030 #[derive(RefCast)]
5031 #[repr(transparent)]
5032 struct Print(syn::token::Dyn);
5033 impl Debug for Print {
5034 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5035 formatter.write_str("Some")?;
5036 Ok(())
5037 }
5038 }
5039 formatter.field("dyn_token", Print::ref_cast(val));
5040 }
5041 if !_val.bounds.is_empty() {
5042 formatter.field("bounds", Lite(&_val.bounds));
5043 }
5044 formatter.finish()
5045 }
5046 syn::Type::Tuple(_val) => {
5047 let mut formatter = formatter.debug_struct("Type::Tuple");
5048 if !_val.elems.is_empty() {
5049 formatter.field("elems", Lite(&_val.elems));
5050 }
5051 formatter.finish()
5052 }
5053 syn::Type::Verbatim(_val) => {
5054 formatter.write_str("Verbatim")?;
5055 formatter.write_str("(`")?;
5056 Display::fmt(_val, formatter)?;
5057 formatter.write_str("`)")?;
5058 Ok(())
5059 }
5060 _ => unreachable!(),
5061 }
5062 }
5063 }
5064 impl Debug for Lite<syn::TypeArray> {
5065 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5066 let _val = &self.value;
5067 let mut formatter = formatter.debug_struct("TypeArray");
5068 formatter.field("elem", Lite(&_val.elem));
5069 formatter.field("len", Lite(&_val.len));
5070 formatter.finish()
5071 }
5072 }
5073 impl Debug for Lite<syn::TypeBareFn> {
5074 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5075 let _val = &self.value;
5076 let mut formatter = formatter.debug_struct("TypeBareFn");
5077 if let Some(val) = &_val.lifetimes {
5078 #[derive(RefCast)]
5079 #[repr(transparent)]
5080 struct Print(syn::BoundLifetimes);
5081 impl Debug for Print {
5082 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5083 formatter.write_str("Some")?;
5084 let _val = &self.0;
5085 formatter.write_str("(")?;
5086 Debug::fmt(Lite(_val), formatter)?;
5087 formatter.write_str(")")?;
5088 Ok(())
5089 }
5090 }
5091 formatter.field("lifetimes", Print::ref_cast(val));
5092 }
5093 if let Some(val) = &_val.unsafety {
5094 #[derive(RefCast)]
5095 #[repr(transparent)]
5096 struct Print(syn::token::Unsafe);
5097 impl Debug for Print {
5098 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5099 formatter.write_str("Some")?;
5100 Ok(())
5101 }
5102 }
5103 formatter.field("unsafety", Print::ref_cast(val));
5104 }
5105 if let Some(val) = &_val.abi {
5106 #[derive(RefCast)]
5107 #[repr(transparent)]
5108 struct Print(syn::Abi);
5109 impl Debug for Print {
5110 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5111 formatter.write_str("Some")?;
5112 let _val = &self.0;
5113 formatter.write_str("(")?;
5114 Debug::fmt(Lite(_val), formatter)?;
5115 formatter.write_str(")")?;
5116 Ok(())
5117 }
5118 }
5119 formatter.field("abi", Print::ref_cast(val));
5120 }
5121 if !_val.inputs.is_empty() {
5122 formatter.field("inputs", Lite(&_val.inputs));
5123 }
5124 if let Some(val) = &_val.variadic {
5125 #[derive(RefCast)]
5126 #[repr(transparent)]
5127 struct Print(syn::Variadic);
5128 impl Debug for Print {
5129 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5130 formatter.write_str("Some")?;
5131 let _val = &self.0;
5132 formatter.write_str("(")?;
5133 Debug::fmt(Lite(_val), formatter)?;
5134 formatter.write_str(")")?;
5135 Ok(())
5136 }
5137 }
5138 formatter.field("variadic", Print::ref_cast(val));
5139 }
5140 formatter.field("output", Lite(&_val.output));
5141 formatter.finish()
5142 }
5143 }
5144 impl Debug for Lite<syn::TypeGroup> {
5145 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5146 let _val = &self.value;
5147 let mut formatter = formatter.debug_struct("TypeGroup");
5148 formatter.field("elem", Lite(&_val.elem));
5149 formatter.finish()
5150 }
5151 }
5152 impl Debug for Lite<syn::TypeImplTrait> {
5153 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5154 let _val = &self.value;
5155 let mut formatter = formatter.debug_struct("TypeImplTrait");
5156 if !_val.bounds.is_empty() {
5157 formatter.field("bounds", Lite(&_val.bounds));
5158 }
5159 formatter.finish()
5160 }
5161 }
5162 impl Debug for Lite<syn::TypeInfer> {
5163 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5164 let _val = &self.value;
5165 let mut formatter = formatter.debug_struct("TypeInfer");
5166 formatter.finish()
5167 }
5168 }
5169 impl Debug for Lite<syn::TypeMacro> {
5170 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5171 let _val = &self.value;
5172 let mut formatter = formatter.debug_struct("TypeMacro");
5173 formatter.field("mac", Lite(&_val.mac));
5174 formatter.finish()
5175 }
5176 }
5177 impl Debug for Lite<syn::TypeNever> {
5178 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5179 let _val = &self.value;
5180 let mut formatter = formatter.debug_struct("TypeNever");
5181 formatter.finish()
5182 }
5183 }
5184 impl Debug for Lite<syn::TypeParam> {
5185 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5186 let _val = &self.value;
5187 let mut formatter = formatter.debug_struct("TypeParam");
5188 if !_val.attrs.is_empty() {
5189 formatter.field("attrs", Lite(&_val.attrs));
5190 }
5191 formatter.field("ident", Lite(&_val.ident));
5192 if let Some(val) = &_val.colon_token {
5193 #[derive(RefCast)]
5194 #[repr(transparent)]
5195 struct Print(syn::token::Colon);
5196 impl Debug for Print {
5197 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5198 formatter.write_str("Some")?;
5199 Ok(())
5200 }
5201 }
5202 formatter.field("colon_token", Print::ref_cast(val));
5203 }
5204 if !_val.bounds.is_empty() {
5205 formatter.field("bounds", Lite(&_val.bounds));
5206 }
5207 if let Some(val) = &_val.eq_token {
5208 #[derive(RefCast)]
5209 #[repr(transparent)]
5210 struct Print(syn::token::Eq);
5211 impl Debug for Print {
5212 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5213 formatter.write_str("Some")?;
5214 Ok(())
5215 }
5216 }
5217 formatter.field("eq_token", Print::ref_cast(val));
5218 }
5219 if let Some(val) = &_val.default {
5220 #[derive(RefCast)]
5221 #[repr(transparent)]
5222 struct Print(syn::Type);
5223 impl Debug for Print {
5224 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5225 formatter.write_str("Some")?;
5226 let _val = &self.0;
5227 formatter.write_str("(")?;
5228 Debug::fmt(Lite(_val), formatter)?;
5229 formatter.write_str(")")?;
5230 Ok(())
5231 }
5232 }
5233 formatter.field("default", Print::ref_cast(val));
5234 }
5235 formatter.finish()
5236 }
5237 }
5238 impl Debug for Lite<syn::TypeParamBound> {
5239 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5240 let _val = &self.value;
5241 match _val {
5242 syn::TypeParamBound::Trait(_val) => {
5243 formatter.write_str("Trait")?;
5244 formatter.write_str("(")?;
5245 Debug::fmt(Lite(_val), formatter)?;
5246 formatter.write_str(")")?;
5247 Ok(())
5248 }
5249 syn::TypeParamBound::Lifetime(_val) => {
5250 formatter.write_str("Lifetime")?;
5251 formatter.write_str("(")?;
5252 Debug::fmt(Lite(_val), formatter)?;
5253 formatter.write_str(")")?;
5254 Ok(())
5255 }
5256 }
5257 }
5258 }
5259 impl Debug for Lite<syn::TypeParen> {
5260 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5261 let _val = &self.value;
5262 let mut formatter = formatter.debug_struct("TypeParen");
5263 formatter.field("elem", Lite(&_val.elem));
5264 formatter.finish()
5265 }
5266 }
5267 impl Debug for Lite<syn::TypePath> {
5268 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5269 let _val = &self.value;
5270 let mut formatter = formatter.debug_struct("TypePath");
5271 if let Some(val) = &_val.qself {
5272 #[derive(RefCast)]
5273 #[repr(transparent)]
5274 struct Print(syn::QSelf);
5275 impl Debug for Print {
5276 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5277 formatter.write_str("Some")?;
5278 let _val = &self.0;
5279 formatter.write_str("(")?;
5280 Debug::fmt(Lite(_val), formatter)?;
5281 formatter.write_str(")")?;
5282 Ok(())
5283 }
5284 }
5285 formatter.field("qself", Print::ref_cast(val));
5286 }
5287 formatter.field("path", Lite(&_val.path));
5288 formatter.finish()
5289 }
5290 }
5291 impl Debug for Lite<syn::TypePtr> {
5292 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5293 let _val = &self.value;
5294 let mut formatter = formatter.debug_struct("TypePtr");
5295 if let Some(val) = &_val.const_token {
5296 #[derive(RefCast)]
5297 #[repr(transparent)]
5298 struct Print(syn::token::Const);
5299 impl Debug for Print {
5300 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5301 formatter.write_str("Some")?;
5302 Ok(())
5303 }
5304 }
5305 formatter.field("const_token", Print::ref_cast(val));
5306 }
5307 if let Some(val) = &_val.mutability {
5308 #[derive(RefCast)]
5309 #[repr(transparent)]
5310 struct Print(syn::token::Mut);
5311 impl Debug for Print {
5312 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5313 formatter.write_str("Some")?;
5314 Ok(())
5315 }
5316 }
5317 formatter.field("mutability", Print::ref_cast(val));
5318 }
5319 formatter.field("elem", Lite(&_val.elem));
5320 formatter.finish()
5321 }
5322 }
5323 impl Debug for Lite<syn::TypeReference> {
5324 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5325 let _val = &self.value;
5326 let mut formatter = formatter.debug_struct("TypeReference");
5327 if let Some(val) = &_val.lifetime {
5328 #[derive(RefCast)]
5329 #[repr(transparent)]
5330 struct Print(syn::Lifetime);
5331 impl Debug for Print {
5332 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5333 formatter.write_str("Some")?;
5334 let _val = &self.0;
5335 formatter.write_str("(")?;
5336 Debug::fmt(Lite(_val), formatter)?;
5337 formatter.write_str(")")?;
5338 Ok(())
5339 }
5340 }
5341 formatter.field("lifetime", Print::ref_cast(val));
5342 }
5343 if let Some(val) = &_val.mutability {
5344 #[derive(RefCast)]
5345 #[repr(transparent)]
5346 struct Print(syn::token::Mut);
5347 impl Debug for Print {
5348 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5349 formatter.write_str("Some")?;
5350 Ok(())
5351 }
5352 }
5353 formatter.field("mutability", Print::ref_cast(val));
5354 }
5355 formatter.field("elem", Lite(&_val.elem));
5356 formatter.finish()
5357 }
5358 }
5359 impl Debug for Lite<syn::TypeSlice> {
5360 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5361 let _val = &self.value;
5362 let mut formatter = formatter.debug_struct("TypeSlice");
5363 formatter.field("elem", Lite(&_val.elem));
5364 formatter.finish()
5365 }
5366 }
5367 impl Debug for Lite<syn::TypeTraitObject> {
5368 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5369 let _val = &self.value;
5370 let mut formatter = formatter.debug_struct("TypeTraitObject");
5371 if let Some(val) = &_val.dyn_token {
5372 #[derive(RefCast)]
5373 #[repr(transparent)]
5374 struct Print(syn::token::Dyn);
5375 impl Debug for Print {
5376 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5377 formatter.write_str("Some")?;
5378 Ok(())
5379 }
5380 }
5381 formatter.field("dyn_token", Print::ref_cast(val));
5382 }
5383 if !_val.bounds.is_empty() {
5384 formatter.field("bounds", Lite(&_val.bounds));
5385 }
5386 formatter.finish()
5387 }
5388 }
5389 impl Debug for Lite<syn::TypeTuple> {
5390 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5391 let _val = &self.value;
5392 let mut formatter = formatter.debug_struct("TypeTuple");
5393 if !_val.elems.is_empty() {
5394 formatter.field("elems", Lite(&_val.elems));
5395 }
5396 formatter.finish()
5397 }
5398 }
5399 impl Debug for Lite<syn::UnOp> {
5400 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5401 let _val = &self.value;
5402 match _val {
5403 syn::UnOp::Deref(_val) => {
5404 formatter.write_str("Deref")?;
5405 Ok(())
5406 }
5407 syn::UnOp::Not(_val) => {
5408 formatter.write_str("Not")?;
5409 Ok(())
5410 }
5411 syn::UnOp::Neg(_val) => {
5412 formatter.write_str("Neg")?;
5413 Ok(())
5414 }
5415 }
5416 }
5417 }
5418 impl Debug for Lite<syn::UseGlob> {
5419 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5420 let _val = &self.value;
5421 let mut formatter = formatter.debug_struct("UseGlob");
5422 formatter.finish()
5423 }
5424 }
5425 impl Debug for Lite<syn::UseGroup> {
5426 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5427 let _val = &self.value;
5428 let mut formatter = formatter.debug_struct("UseGroup");
5429 if !_val.items.is_empty() {
5430 formatter.field("items", Lite(&_val.items));
5431 }
5432 formatter.finish()
5433 }
5434 }
5435 impl Debug for Lite<syn::UseName> {
5436 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5437 let _val = &self.value;
5438 let mut formatter = formatter.debug_struct("UseName");
5439 formatter.field("ident", Lite(&_val.ident));
5440 formatter.finish()
5441 }
5442 }
5443 impl Debug for Lite<syn::UsePath> {
5444 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5445 let _val = &self.value;
5446 let mut formatter = formatter.debug_struct("UsePath");
5447 formatter.field("ident", Lite(&_val.ident));
5448 formatter.field("tree", Lite(&_val.tree));
5449 formatter.finish()
5450 }
5451 }
5452 impl Debug for Lite<syn::UseRename> {
5453 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5454 let _val = &self.value;
5455 let mut formatter = formatter.debug_struct("UseRename");
5456 formatter.field("ident", Lite(&_val.ident));
5457 formatter.field("rename", Lite(&_val.rename));
5458 formatter.finish()
5459 }
5460 }
5461 impl Debug for Lite<syn::UseTree> {
5462 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5463 let _val = &self.value;
5464 match _val {
5465 syn::UseTree::Path(_val) => {
5466 formatter.write_str("Path")?;
5467 formatter.write_str("(")?;
5468 Debug::fmt(Lite(_val), formatter)?;
5469 formatter.write_str(")")?;
5470 Ok(())
5471 }
5472 syn::UseTree::Name(_val) => {
5473 formatter.write_str("Name")?;
5474 formatter.write_str("(")?;
5475 Debug::fmt(Lite(_val), formatter)?;
5476 formatter.write_str(")")?;
5477 Ok(())
5478 }
5479 syn::UseTree::Rename(_val) => {
5480 formatter.write_str("Rename")?;
5481 formatter.write_str("(")?;
5482 Debug::fmt(Lite(_val), formatter)?;
5483 formatter.write_str(")")?;
5484 Ok(())
5485 }
5486 syn::UseTree::Glob(_val) => {
5487 formatter.write_str("Glob")?;
5488 formatter.write_str("(")?;
5489 Debug::fmt(Lite(_val), formatter)?;
5490 formatter.write_str(")")?;
5491 Ok(())
5492 }
5493 syn::UseTree::Group(_val) => {
5494 formatter.write_str("Group")?;
5495 formatter.write_str("(")?;
5496 Debug::fmt(Lite(_val), formatter)?;
5497 formatter.write_str(")")?;
5498 Ok(())
5499 }
5500 }
5501 }
5502 }
5503 impl Debug for Lite<syn::Variadic> {
5504 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5505 let _val = &self.value;
5506 let mut formatter = formatter.debug_struct("Variadic");
5507 if !_val.attrs.is_empty() {
5508 formatter.field("attrs", Lite(&_val.attrs));
5509 }
5510 formatter.finish()
5511 }
5512 }
5513 impl Debug for Lite<syn::Variant> {
5514 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5515 let _val = &self.value;
5516 let mut formatter = formatter.debug_struct("Variant");
5517 if !_val.attrs.is_empty() {
5518 formatter.field("attrs", Lite(&_val.attrs));
5519 }
5520 formatter.field("ident", Lite(&_val.ident));
5521 formatter.field("fields", Lite(&_val.fields));
5522 if let Some(val) = &_val.discriminant {
5523 #[derive(RefCast)]
5524 #[repr(transparent)]
5525 struct Print((syn::token::Eq, syn::Expr));
5526 impl Debug for Print {
5527 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5528 formatter.write_str("Some")?;
5529 let _val = &self.0;
5530 formatter.write_str("(")?;
5531 Debug::fmt(Lite(&_val.1), formatter)?;
5532 formatter.write_str(")")?;
5533 Ok(())
5534 }
5535 }
5536 formatter.field("discriminant", Print::ref_cast(val));
5537 }
5538 formatter.finish()
5539 }
5540 }
5541 impl Debug for Lite<syn::VisCrate> {
5542 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5543 let _val = &self.value;
5544 let mut formatter = formatter.debug_struct("VisCrate");
5545 formatter.finish()
5546 }
5547 }
5548 impl Debug for Lite<syn::VisPublic> {
5549 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5550 let _val = &self.value;
5551 let mut formatter = formatter.debug_struct("VisPublic");
5552 formatter.finish()
5553 }
5554 }
5555 impl Debug for Lite<syn::VisRestricted> {
5556 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5557 let _val = &self.value;
5558 let mut formatter = formatter.debug_struct("VisRestricted");
5559 if let Some(val) = &_val.in_token {
5560 #[derive(RefCast)]
5561 #[repr(transparent)]
5562 struct Print(syn::token::In);
5563 impl Debug for Print {
5564 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5565 formatter.write_str("Some")?;
5566 Ok(())
5567 }
5568 }
5569 formatter.field("in_token", Print::ref_cast(val));
5570 }
5571 formatter.field("path", Lite(&_val.path));
5572 formatter.finish()
5573 }
5574 }
5575 impl Debug for Lite<syn::Visibility> {
5576 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5577 let _val = &self.value;
5578 match _val {
5579 syn::Visibility::Public(_val) => {
5580 let mut formatter = formatter.debug_struct("Visibility::Public");
5581 formatter.finish()
5582 }
5583 syn::Visibility::Crate(_val) => {
5584 let mut formatter = formatter.debug_struct("Visibility::Crate");
5585 formatter.finish()
5586 }
5587 syn::Visibility::Restricted(_val) => {
5588 let mut formatter = formatter.debug_struct("Visibility::Restricted");
5589 if let Some(val) = &_val.in_token {
5590 #[derive(RefCast)]
5591 #[repr(transparent)]
5592 struct Print(syn::token::In);
5593 impl Debug for Print {
5594 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5595 formatter.write_str("Some")?;
5596 Ok(())
5597 }
5598 }
5599 formatter.field("in_token", Print::ref_cast(val));
5600 }
5601 formatter.field("path", Lite(&_val.path));
5602 formatter.finish()
5603 }
5604 syn::Visibility::Inherited => formatter.write_str("Inherited"),
5605 }
5606 }
5607 }
5608 impl Debug for Lite<syn::WhereClause> {
5609 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5610 let _val = &self.value;
5611 let mut formatter = formatter.debug_struct("WhereClause");
5612 if !_val.predicates.is_empty() {
5613 formatter.field("predicates", Lite(&_val.predicates));
5614 }
5615 formatter.finish()
5616 }
5617 }
5618 impl Debug for Lite<syn::WherePredicate> {
5619 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5620 let _val = &self.value;
5621 match _val {
5622 syn::WherePredicate::Type(_val) => {
5623 formatter.write_str("Type")?;
5624 formatter.write_str("(")?;
5625 Debug::fmt(Lite(_val), formatter)?;
5626 formatter.write_str(")")?;
5627 Ok(())
5628 }
5629 syn::WherePredicate::Lifetime(_val) => {
5630 formatter.write_str("Lifetime")?;
5631 formatter.write_str("(")?;
5632 Debug::fmt(Lite(_val), formatter)?;
5633 formatter.write_str(")")?;
5634 Ok(())
5635 }
5636 syn::WherePredicate::Eq(_val) => {
5637 formatter.write_str("Eq")?;
5638 formatter.write_str("(")?;
5639 Debug::fmt(Lite(_val), formatter)?;
5640 formatter.write_str(")")?;
5641 Ok(())
5642 }
5643 }
5644 }
5645 }
backport for Debian buster