]> git.proxmox.com Git - rustc.git/blob - vendor/syn/src/gen/debug.rs
New upstream version 1.48.0~beta.8+dfsg1
[rustc.git] / vendor / syn / src / gen / debug.rs
1 // This file is @generated by syn-internal-codegen.
2 // It is not intended for manual editing.
3
4 use crate::*;
5 use std::fmt::{self, Debug};
6 #[cfg(any(feature = "derive", feature = "full"))]
7 impl Debug for Abi {
8 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
9 let mut formatter = formatter.debug_struct("Abi");
10 formatter.field("extern_token", &self.extern_token);
11 formatter.field("name", &self.name);
12 formatter.finish()
13 }
14 }
15 #[cfg(any(feature = "derive", feature = "full"))]
16 impl Debug for AngleBracketedGenericArguments {
17 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
18 let mut formatter = formatter.debug_struct("AngleBracketedGenericArguments");
19 formatter.field("colon2_token", &self.colon2_token);
20 formatter.field("lt_token", &self.lt_token);
21 formatter.field("args", &self.args);
22 formatter.field("gt_token", &self.gt_token);
23 formatter.finish()
24 }
25 }
26 #[cfg(feature = "full")]
27 impl Debug for Arm {
28 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
29 let mut formatter = formatter.debug_struct("Arm");
30 formatter.field("attrs", &self.attrs);
31 formatter.field("pat", &self.pat);
32 formatter.field("guard", &self.guard);
33 formatter.field("fat_arrow_token", &self.fat_arrow_token);
34 formatter.field("body", &self.body);
35 formatter.field("comma", &self.comma);
36 formatter.finish()
37 }
38 }
39 #[cfg(any(feature = "derive", feature = "full"))]
40 impl Debug for AttrStyle {
41 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
42 match self {
43 AttrStyle::Outer => formatter.write_str("Outer"),
44 AttrStyle::Inner(v0) => {
45 let mut formatter = formatter.debug_tuple("Inner");
46 formatter.field(v0);
47 formatter.finish()
48 }
49 }
50 }
51 }
52 #[cfg(any(feature = "derive", feature = "full"))]
53 impl Debug for Attribute {
54 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
55 let mut formatter = formatter.debug_struct("Attribute");
56 formatter.field("pound_token", &self.pound_token);
57 formatter.field("style", &self.style);
58 formatter.field("bracket_token", &self.bracket_token);
59 formatter.field("path", &self.path);
60 formatter.field("tokens", &self.tokens);
61 formatter.finish()
62 }
63 }
64 #[cfg(any(feature = "derive", feature = "full"))]
65 impl Debug for BareFnArg {
66 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
67 let mut formatter = formatter.debug_struct("BareFnArg");
68 formatter.field("attrs", &self.attrs);
69 formatter.field("name", &self.name);
70 formatter.field("ty", &self.ty);
71 formatter.finish()
72 }
73 }
74 #[cfg(any(feature = "derive", feature = "full"))]
75 impl Debug for BinOp {
76 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
77 match self {
78 BinOp::Add(v0) => {
79 let mut formatter = formatter.debug_tuple("Add");
80 formatter.field(v0);
81 formatter.finish()
82 }
83 BinOp::Sub(v0) => {
84 let mut formatter = formatter.debug_tuple("Sub");
85 formatter.field(v0);
86 formatter.finish()
87 }
88 BinOp::Mul(v0) => {
89 let mut formatter = formatter.debug_tuple("Mul");
90 formatter.field(v0);
91 formatter.finish()
92 }
93 BinOp::Div(v0) => {
94 let mut formatter = formatter.debug_tuple("Div");
95 formatter.field(v0);
96 formatter.finish()
97 }
98 BinOp::Rem(v0) => {
99 let mut formatter = formatter.debug_tuple("Rem");
100 formatter.field(v0);
101 formatter.finish()
102 }
103 BinOp::And(v0) => {
104 let mut formatter = formatter.debug_tuple("And");
105 formatter.field(v0);
106 formatter.finish()
107 }
108 BinOp::Or(v0) => {
109 let mut formatter = formatter.debug_tuple("Or");
110 formatter.field(v0);
111 formatter.finish()
112 }
113 BinOp::BitXor(v0) => {
114 let mut formatter = formatter.debug_tuple("BitXor");
115 formatter.field(v0);
116 formatter.finish()
117 }
118 BinOp::BitAnd(v0) => {
119 let mut formatter = formatter.debug_tuple("BitAnd");
120 formatter.field(v0);
121 formatter.finish()
122 }
123 BinOp::BitOr(v0) => {
124 let mut formatter = formatter.debug_tuple("BitOr");
125 formatter.field(v0);
126 formatter.finish()
127 }
128 BinOp::Shl(v0) => {
129 let mut formatter = formatter.debug_tuple("Shl");
130 formatter.field(v0);
131 formatter.finish()
132 }
133 BinOp::Shr(v0) => {
134 let mut formatter = formatter.debug_tuple("Shr");
135 formatter.field(v0);
136 formatter.finish()
137 }
138 BinOp::Eq(v0) => {
139 let mut formatter = formatter.debug_tuple("Eq");
140 formatter.field(v0);
141 formatter.finish()
142 }
143 BinOp::Lt(v0) => {
144 let mut formatter = formatter.debug_tuple("Lt");
145 formatter.field(v0);
146 formatter.finish()
147 }
148 BinOp::Le(v0) => {
149 let mut formatter = formatter.debug_tuple("Le");
150 formatter.field(v0);
151 formatter.finish()
152 }
153 BinOp::Ne(v0) => {
154 let mut formatter = formatter.debug_tuple("Ne");
155 formatter.field(v0);
156 formatter.finish()
157 }
158 BinOp::Ge(v0) => {
159 let mut formatter = formatter.debug_tuple("Ge");
160 formatter.field(v0);
161 formatter.finish()
162 }
163 BinOp::Gt(v0) => {
164 let mut formatter = formatter.debug_tuple("Gt");
165 formatter.field(v0);
166 formatter.finish()
167 }
168 BinOp::AddEq(v0) => {
169 let mut formatter = formatter.debug_tuple("AddEq");
170 formatter.field(v0);
171 formatter.finish()
172 }
173 BinOp::SubEq(v0) => {
174 let mut formatter = formatter.debug_tuple("SubEq");
175 formatter.field(v0);
176 formatter.finish()
177 }
178 BinOp::MulEq(v0) => {
179 let mut formatter = formatter.debug_tuple("MulEq");
180 formatter.field(v0);
181 formatter.finish()
182 }
183 BinOp::DivEq(v0) => {
184 let mut formatter = formatter.debug_tuple("DivEq");
185 formatter.field(v0);
186 formatter.finish()
187 }
188 BinOp::RemEq(v0) => {
189 let mut formatter = formatter.debug_tuple("RemEq");
190 formatter.field(v0);
191 formatter.finish()
192 }
193 BinOp::BitXorEq(v0) => {
194 let mut formatter = formatter.debug_tuple("BitXorEq");
195 formatter.field(v0);
196 formatter.finish()
197 }
198 BinOp::BitAndEq(v0) => {
199 let mut formatter = formatter.debug_tuple("BitAndEq");
200 formatter.field(v0);
201 formatter.finish()
202 }
203 BinOp::BitOrEq(v0) => {
204 let mut formatter = formatter.debug_tuple("BitOrEq");
205 formatter.field(v0);
206 formatter.finish()
207 }
208 BinOp::ShlEq(v0) => {
209 let mut formatter = formatter.debug_tuple("ShlEq");
210 formatter.field(v0);
211 formatter.finish()
212 }
213 BinOp::ShrEq(v0) => {
214 let mut formatter = formatter.debug_tuple("ShrEq");
215 formatter.field(v0);
216 formatter.finish()
217 }
218 }
219 }
220 }
221 #[cfg(any(feature = "derive", feature = "full"))]
222 impl Debug for Binding {
223 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
224 let mut formatter = formatter.debug_struct("Binding");
225 formatter.field("ident", &self.ident);
226 formatter.field("eq_token", &self.eq_token);
227 formatter.field("ty", &self.ty);
228 formatter.finish()
229 }
230 }
231 #[cfg(feature = "full")]
232 impl Debug for Block {
233 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
234 let mut formatter = formatter.debug_struct("Block");
235 formatter.field("brace_token", &self.brace_token);
236 formatter.field("stmts", &self.stmts);
237 formatter.finish()
238 }
239 }
240 #[cfg(any(feature = "derive", feature = "full"))]
241 impl Debug for BoundLifetimes {
242 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
243 let mut formatter = formatter.debug_struct("BoundLifetimes");
244 formatter.field("for_token", &self.for_token);
245 formatter.field("lt_token", &self.lt_token);
246 formatter.field("lifetimes", &self.lifetimes);
247 formatter.field("gt_token", &self.gt_token);
248 formatter.finish()
249 }
250 }
251 #[cfg(any(feature = "derive", feature = "full"))]
252 impl Debug for ConstParam {
253 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
254 let mut formatter = formatter.debug_struct("ConstParam");
255 formatter.field("attrs", &self.attrs);
256 formatter.field("const_token", &self.const_token);
257 formatter.field("ident", &self.ident);
258 formatter.field("colon_token", &self.colon_token);
259 formatter.field("ty", &self.ty);
260 formatter.field("eq_token", &self.eq_token);
261 formatter.field("default", &self.default);
262 formatter.finish()
263 }
264 }
265 #[cfg(any(feature = "derive", feature = "full"))]
266 impl Debug for Constraint {
267 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
268 let mut formatter = formatter.debug_struct("Constraint");
269 formatter.field("ident", &self.ident);
270 formatter.field("colon_token", &self.colon_token);
271 formatter.field("bounds", &self.bounds);
272 formatter.finish()
273 }
274 }
275 #[cfg(feature = "derive")]
276 impl Debug for Data {
277 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
278 match self {
279 Data::Struct(v0) => {
280 let mut formatter = formatter.debug_tuple("Struct");
281 formatter.field(v0);
282 formatter.finish()
283 }
284 Data::Enum(v0) => {
285 let mut formatter = formatter.debug_tuple("Enum");
286 formatter.field(v0);
287 formatter.finish()
288 }
289 Data::Union(v0) => {
290 let mut formatter = formatter.debug_tuple("Union");
291 formatter.field(v0);
292 formatter.finish()
293 }
294 }
295 }
296 }
297 #[cfg(feature = "derive")]
298 impl Debug for DataEnum {
299 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
300 let mut formatter = formatter.debug_struct("DataEnum");
301 formatter.field("enum_token", &self.enum_token);
302 formatter.field("brace_token", &self.brace_token);
303 formatter.field("variants", &self.variants);
304 formatter.finish()
305 }
306 }
307 #[cfg(feature = "derive")]
308 impl Debug for DataStruct {
309 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
310 let mut formatter = formatter.debug_struct("DataStruct");
311 formatter.field("struct_token", &self.struct_token);
312 formatter.field("fields", &self.fields);
313 formatter.field("semi_token", &self.semi_token);
314 formatter.finish()
315 }
316 }
317 #[cfg(feature = "derive")]
318 impl Debug for DataUnion {
319 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
320 let mut formatter = formatter.debug_struct("DataUnion");
321 formatter.field("union_token", &self.union_token);
322 formatter.field("fields", &self.fields);
323 formatter.finish()
324 }
325 }
326 #[cfg(feature = "derive")]
327 impl Debug for DeriveInput {
328 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
329 let mut formatter = formatter.debug_struct("DeriveInput");
330 formatter.field("attrs", &self.attrs);
331 formatter.field("vis", &self.vis);
332 formatter.field("ident", &self.ident);
333 formatter.field("generics", &self.generics);
334 formatter.field("data", &self.data);
335 formatter.finish()
336 }
337 }
338 #[cfg(any(feature = "derive", feature = "full"))]
339 impl Debug for Expr {
340 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
341 match self {
342 #[cfg(feature = "full")]
343 Expr::Array(v0) => {
344 let mut formatter = formatter.debug_tuple("Array");
345 formatter.field(v0);
346 formatter.finish()
347 }
348 #[cfg(feature = "full")]
349 Expr::Assign(v0) => {
350 let mut formatter = formatter.debug_tuple("Assign");
351 formatter.field(v0);
352 formatter.finish()
353 }
354 #[cfg(feature = "full")]
355 Expr::AssignOp(v0) => {
356 let mut formatter = formatter.debug_tuple("AssignOp");
357 formatter.field(v0);
358 formatter.finish()
359 }
360 #[cfg(feature = "full")]
361 Expr::Async(v0) => {
362 let mut formatter = formatter.debug_tuple("Async");
363 formatter.field(v0);
364 formatter.finish()
365 }
366 #[cfg(feature = "full")]
367 Expr::Await(v0) => {
368 let mut formatter = formatter.debug_tuple("Await");
369 formatter.field(v0);
370 formatter.finish()
371 }
372 Expr::Binary(v0) => {
373 let mut formatter = formatter.debug_tuple("Binary");
374 formatter.field(v0);
375 formatter.finish()
376 }
377 #[cfg(feature = "full")]
378 Expr::Block(v0) => {
379 let mut formatter = formatter.debug_tuple("Block");
380 formatter.field(v0);
381 formatter.finish()
382 }
383 #[cfg(feature = "full")]
384 Expr::Box(v0) => {
385 let mut formatter = formatter.debug_tuple("Box");
386 formatter.field(v0);
387 formatter.finish()
388 }
389 #[cfg(feature = "full")]
390 Expr::Break(v0) => {
391 let mut formatter = formatter.debug_tuple("Break");
392 formatter.field(v0);
393 formatter.finish()
394 }
395 Expr::Call(v0) => {
396 let mut formatter = formatter.debug_tuple("Call");
397 formatter.field(v0);
398 formatter.finish()
399 }
400 Expr::Cast(v0) => {
401 let mut formatter = formatter.debug_tuple("Cast");
402 formatter.field(v0);
403 formatter.finish()
404 }
405 #[cfg(feature = "full")]
406 Expr::Closure(v0) => {
407 let mut formatter = formatter.debug_tuple("Closure");
408 formatter.field(v0);
409 formatter.finish()
410 }
411 #[cfg(feature = "full")]
412 Expr::Continue(v0) => {
413 let mut formatter = formatter.debug_tuple("Continue");
414 formatter.field(v0);
415 formatter.finish()
416 }
417 Expr::Field(v0) => {
418 let mut formatter = formatter.debug_tuple("Field");
419 formatter.field(v0);
420 formatter.finish()
421 }
422 #[cfg(feature = "full")]
423 Expr::ForLoop(v0) => {
424 let mut formatter = formatter.debug_tuple("ForLoop");
425 formatter.field(v0);
426 formatter.finish()
427 }
428 #[cfg(feature = "full")]
429 Expr::Group(v0) => {
430 let mut formatter = formatter.debug_tuple("Group");
431 formatter.field(v0);
432 formatter.finish()
433 }
434 #[cfg(feature = "full")]
435 Expr::If(v0) => {
436 let mut formatter = formatter.debug_tuple("If");
437 formatter.field(v0);
438 formatter.finish()
439 }
440 Expr::Index(v0) => {
441 let mut formatter = formatter.debug_tuple("Index");
442 formatter.field(v0);
443 formatter.finish()
444 }
445 #[cfg(feature = "full")]
446 Expr::Let(v0) => {
447 let mut formatter = formatter.debug_tuple("Let");
448 formatter.field(v0);
449 formatter.finish()
450 }
451 Expr::Lit(v0) => {
452 let mut formatter = formatter.debug_tuple("Lit");
453 formatter.field(v0);
454 formatter.finish()
455 }
456 #[cfg(feature = "full")]
457 Expr::Loop(v0) => {
458 let mut formatter = formatter.debug_tuple("Loop");
459 formatter.field(v0);
460 formatter.finish()
461 }
462 #[cfg(feature = "full")]
463 Expr::Macro(v0) => {
464 let mut formatter = formatter.debug_tuple("Macro");
465 formatter.field(v0);
466 formatter.finish()
467 }
468 #[cfg(feature = "full")]
469 Expr::Match(v0) => {
470 let mut formatter = formatter.debug_tuple("Match");
471 formatter.field(v0);
472 formatter.finish()
473 }
474 #[cfg(feature = "full")]
475 Expr::MethodCall(v0) => {
476 let mut formatter = formatter.debug_tuple("MethodCall");
477 formatter.field(v0);
478 formatter.finish()
479 }
480 Expr::Paren(v0) => {
481 let mut formatter = formatter.debug_tuple("Paren");
482 formatter.field(v0);
483 formatter.finish()
484 }
485 Expr::Path(v0) => {
486 let mut formatter = formatter.debug_tuple("Path");
487 formatter.field(v0);
488 formatter.finish()
489 }
490 #[cfg(feature = "full")]
491 Expr::Range(v0) => {
492 let mut formatter = formatter.debug_tuple("Range");
493 formatter.field(v0);
494 formatter.finish()
495 }
496 #[cfg(feature = "full")]
497 Expr::Reference(v0) => {
498 let mut formatter = formatter.debug_tuple("Reference");
499 formatter.field(v0);
500 formatter.finish()
501 }
502 #[cfg(feature = "full")]
503 Expr::Repeat(v0) => {
504 let mut formatter = formatter.debug_tuple("Repeat");
505 formatter.field(v0);
506 formatter.finish()
507 }
508 #[cfg(feature = "full")]
509 Expr::Return(v0) => {
510 let mut formatter = formatter.debug_tuple("Return");
511 formatter.field(v0);
512 formatter.finish()
513 }
514 #[cfg(feature = "full")]
515 Expr::Struct(v0) => {
516 let mut formatter = formatter.debug_tuple("Struct");
517 formatter.field(v0);
518 formatter.finish()
519 }
520 #[cfg(feature = "full")]
521 Expr::Try(v0) => {
522 let mut formatter = formatter.debug_tuple("Try");
523 formatter.field(v0);
524 formatter.finish()
525 }
526 #[cfg(feature = "full")]
527 Expr::TryBlock(v0) => {
528 let mut formatter = formatter.debug_tuple("TryBlock");
529 formatter.field(v0);
530 formatter.finish()
531 }
532 #[cfg(feature = "full")]
533 Expr::Tuple(v0) => {
534 let mut formatter = formatter.debug_tuple("Tuple");
535 formatter.field(v0);
536 formatter.finish()
537 }
538 #[cfg(feature = "full")]
539 Expr::Type(v0) => {
540 let mut formatter = formatter.debug_tuple("Type");
541 formatter.field(v0);
542 formatter.finish()
543 }
544 Expr::Unary(v0) => {
545 let mut formatter = formatter.debug_tuple("Unary");
546 formatter.field(v0);
547 formatter.finish()
548 }
549 #[cfg(feature = "full")]
550 Expr::Unsafe(v0) => {
551 let mut formatter = formatter.debug_tuple("Unsafe");
552 formatter.field(v0);
553 formatter.finish()
554 }
555 Expr::Verbatim(v0) => {
556 let mut formatter = formatter.debug_tuple("Verbatim");
557 formatter.field(v0);
558 formatter.finish()
559 }
560 #[cfg(feature = "full")]
561 Expr::While(v0) => {
562 let mut formatter = formatter.debug_tuple("While");
563 formatter.field(v0);
564 formatter.finish()
565 }
566 #[cfg(feature = "full")]
567 Expr::Yield(v0) => {
568 let mut formatter = formatter.debug_tuple("Yield");
569 formatter.field(v0);
570 formatter.finish()
571 }
572 _ => unreachable!(),
573 }
574 }
575 }
576 #[cfg(feature = "full")]
577 impl Debug for ExprArray {
578 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
579 let mut formatter = formatter.debug_struct("ExprArray");
580 formatter.field("attrs", &self.attrs);
581 formatter.field("bracket_token", &self.bracket_token);
582 formatter.field("elems", &self.elems);
583 formatter.finish()
584 }
585 }
586 #[cfg(feature = "full")]
587 impl Debug for ExprAssign {
588 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
589 let mut formatter = formatter.debug_struct("ExprAssign");
590 formatter.field("attrs", &self.attrs);
591 formatter.field("left", &self.left);
592 formatter.field("eq_token", &self.eq_token);
593 formatter.field("right", &self.right);
594 formatter.finish()
595 }
596 }
597 #[cfg(feature = "full")]
598 impl Debug for ExprAssignOp {
599 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
600 let mut formatter = formatter.debug_struct("ExprAssignOp");
601 formatter.field("attrs", &self.attrs);
602 formatter.field("left", &self.left);
603 formatter.field("op", &self.op);
604 formatter.field("right", &self.right);
605 formatter.finish()
606 }
607 }
608 #[cfg(feature = "full")]
609 impl Debug for ExprAsync {
610 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
611 let mut formatter = formatter.debug_struct("ExprAsync");
612 formatter.field("attrs", &self.attrs);
613 formatter.field("async_token", &self.async_token);
614 formatter.field("capture", &self.capture);
615 formatter.field("block", &self.block);
616 formatter.finish()
617 }
618 }
619 #[cfg(feature = "full")]
620 impl Debug for ExprAwait {
621 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
622 let mut formatter = formatter.debug_struct("ExprAwait");
623 formatter.field("attrs", &self.attrs);
624 formatter.field("base", &self.base);
625 formatter.field("dot_token", &self.dot_token);
626 formatter.field("await_token", &self.await_token);
627 formatter.finish()
628 }
629 }
630 #[cfg(any(feature = "derive", feature = "full"))]
631 impl Debug for ExprBinary {
632 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
633 let mut formatter = formatter.debug_struct("ExprBinary");
634 formatter.field("attrs", &self.attrs);
635 formatter.field("left", &self.left);
636 formatter.field("op", &self.op);
637 formatter.field("right", &self.right);
638 formatter.finish()
639 }
640 }
641 #[cfg(feature = "full")]
642 impl Debug for ExprBlock {
643 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
644 let mut formatter = formatter.debug_struct("ExprBlock");
645 formatter.field("attrs", &self.attrs);
646 formatter.field("label", &self.label);
647 formatter.field("block", &self.block);
648 formatter.finish()
649 }
650 }
651 #[cfg(feature = "full")]
652 impl Debug for ExprBox {
653 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
654 let mut formatter = formatter.debug_struct("ExprBox");
655 formatter.field("attrs", &self.attrs);
656 formatter.field("box_token", &self.box_token);
657 formatter.field("expr", &self.expr);
658 formatter.finish()
659 }
660 }
661 #[cfg(feature = "full")]
662 impl Debug for ExprBreak {
663 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
664 let mut formatter = formatter.debug_struct("ExprBreak");
665 formatter.field("attrs", &self.attrs);
666 formatter.field("break_token", &self.break_token);
667 formatter.field("label", &self.label);
668 formatter.field("expr", &self.expr);
669 formatter.finish()
670 }
671 }
672 #[cfg(any(feature = "derive", feature = "full"))]
673 impl Debug for ExprCall {
674 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
675 let mut formatter = formatter.debug_struct("ExprCall");
676 formatter.field("attrs", &self.attrs);
677 formatter.field("func", &self.func);
678 formatter.field("paren_token", &self.paren_token);
679 formatter.field("args", &self.args);
680 formatter.finish()
681 }
682 }
683 #[cfg(any(feature = "derive", feature = "full"))]
684 impl Debug for ExprCast {
685 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
686 let mut formatter = formatter.debug_struct("ExprCast");
687 formatter.field("attrs", &self.attrs);
688 formatter.field("expr", &self.expr);
689 formatter.field("as_token", &self.as_token);
690 formatter.field("ty", &self.ty);
691 formatter.finish()
692 }
693 }
694 #[cfg(feature = "full")]
695 impl Debug for ExprClosure {
696 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
697 let mut formatter = formatter.debug_struct("ExprClosure");
698 formatter.field("attrs", &self.attrs);
699 formatter.field("asyncness", &self.asyncness);
700 formatter.field("movability", &self.movability);
701 formatter.field("capture", &self.capture);
702 formatter.field("or1_token", &self.or1_token);
703 formatter.field("inputs", &self.inputs);
704 formatter.field("or2_token", &self.or2_token);
705 formatter.field("output", &self.output);
706 formatter.field("body", &self.body);
707 formatter.finish()
708 }
709 }
710 #[cfg(feature = "full")]
711 impl Debug for ExprContinue {
712 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
713 let mut formatter = formatter.debug_struct("ExprContinue");
714 formatter.field("attrs", &self.attrs);
715 formatter.field("continue_token", &self.continue_token);
716 formatter.field("label", &self.label);
717 formatter.finish()
718 }
719 }
720 #[cfg(any(feature = "derive", feature = "full"))]
721 impl Debug for ExprField {
722 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
723 let mut formatter = formatter.debug_struct("ExprField");
724 formatter.field("attrs", &self.attrs);
725 formatter.field("base", &self.base);
726 formatter.field("dot_token", &self.dot_token);
727 formatter.field("member", &self.member);
728 formatter.finish()
729 }
730 }
731 #[cfg(feature = "full")]
732 impl Debug for ExprForLoop {
733 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
734 let mut formatter = formatter.debug_struct("ExprForLoop");
735 formatter.field("attrs", &self.attrs);
736 formatter.field("label", &self.label);
737 formatter.field("for_token", &self.for_token);
738 formatter.field("pat", &self.pat);
739 formatter.field("in_token", &self.in_token);
740 formatter.field("expr", &self.expr);
741 formatter.field("body", &self.body);
742 formatter.finish()
743 }
744 }
745 #[cfg(feature = "full")]
746 impl Debug for ExprGroup {
747 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
748 let mut formatter = formatter.debug_struct("ExprGroup");
749 formatter.field("attrs", &self.attrs);
750 formatter.field("group_token", &self.group_token);
751 formatter.field("expr", &self.expr);
752 formatter.finish()
753 }
754 }
755 #[cfg(feature = "full")]
756 impl Debug for ExprIf {
757 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
758 let mut formatter = formatter.debug_struct("ExprIf");
759 formatter.field("attrs", &self.attrs);
760 formatter.field("if_token", &self.if_token);
761 formatter.field("cond", &self.cond);
762 formatter.field("then_branch", &self.then_branch);
763 formatter.field("else_branch", &self.else_branch);
764 formatter.finish()
765 }
766 }
767 #[cfg(any(feature = "derive", feature = "full"))]
768 impl Debug for ExprIndex {
769 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
770 let mut formatter = formatter.debug_struct("ExprIndex");
771 formatter.field("attrs", &self.attrs);
772 formatter.field("expr", &self.expr);
773 formatter.field("bracket_token", &self.bracket_token);
774 formatter.field("index", &self.index);
775 formatter.finish()
776 }
777 }
778 #[cfg(feature = "full")]
779 impl Debug for ExprLet {
780 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
781 let mut formatter = formatter.debug_struct("ExprLet");
782 formatter.field("attrs", &self.attrs);
783 formatter.field("let_token", &self.let_token);
784 formatter.field("pat", &self.pat);
785 formatter.field("eq_token", &self.eq_token);
786 formatter.field("expr", &self.expr);
787 formatter.finish()
788 }
789 }
790 #[cfg(any(feature = "derive", feature = "full"))]
791 impl Debug for ExprLit {
792 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
793 let mut formatter = formatter.debug_struct("ExprLit");
794 formatter.field("attrs", &self.attrs);
795 formatter.field("lit", &self.lit);
796 formatter.finish()
797 }
798 }
799 #[cfg(feature = "full")]
800 impl Debug for ExprLoop {
801 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
802 let mut formatter = formatter.debug_struct("ExprLoop");
803 formatter.field("attrs", &self.attrs);
804 formatter.field("label", &self.label);
805 formatter.field("loop_token", &self.loop_token);
806 formatter.field("body", &self.body);
807 formatter.finish()
808 }
809 }
810 #[cfg(feature = "full")]
811 impl Debug for ExprMacro {
812 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
813 let mut formatter = formatter.debug_struct("ExprMacro");
814 formatter.field("attrs", &self.attrs);
815 formatter.field("mac", &self.mac);
816 formatter.finish()
817 }
818 }
819 #[cfg(feature = "full")]
820 impl Debug for ExprMatch {
821 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
822 let mut formatter = formatter.debug_struct("ExprMatch");
823 formatter.field("attrs", &self.attrs);
824 formatter.field("match_token", &self.match_token);
825 formatter.field("expr", &self.expr);
826 formatter.field("brace_token", &self.brace_token);
827 formatter.field("arms", &self.arms);
828 formatter.finish()
829 }
830 }
831 #[cfg(feature = "full")]
832 impl Debug for ExprMethodCall {
833 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
834 let mut formatter = formatter.debug_struct("ExprMethodCall");
835 formatter.field("attrs", &self.attrs);
836 formatter.field("receiver", &self.receiver);
837 formatter.field("dot_token", &self.dot_token);
838 formatter.field("method", &self.method);
839 formatter.field("turbofish", &self.turbofish);
840 formatter.field("paren_token", &self.paren_token);
841 formatter.field("args", &self.args);
842 formatter.finish()
843 }
844 }
845 #[cfg(any(feature = "derive", feature = "full"))]
846 impl Debug for ExprParen {
847 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
848 let mut formatter = formatter.debug_struct("ExprParen");
849 formatter.field("attrs", &self.attrs);
850 formatter.field("paren_token", &self.paren_token);
851 formatter.field("expr", &self.expr);
852 formatter.finish()
853 }
854 }
855 #[cfg(any(feature = "derive", feature = "full"))]
856 impl Debug for ExprPath {
857 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
858 let mut formatter = formatter.debug_struct("ExprPath");
859 formatter.field("attrs", &self.attrs);
860 formatter.field("qself", &self.qself);
861 formatter.field("path", &self.path);
862 formatter.finish()
863 }
864 }
865 #[cfg(feature = "full")]
866 impl Debug for ExprRange {
867 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
868 let mut formatter = formatter.debug_struct("ExprRange");
869 formatter.field("attrs", &self.attrs);
870 formatter.field("from", &self.from);
871 formatter.field("limits", &self.limits);
872 formatter.field("to", &self.to);
873 formatter.finish()
874 }
875 }
876 #[cfg(feature = "full")]
877 impl Debug for ExprReference {
878 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
879 let mut formatter = formatter.debug_struct("ExprReference");
880 formatter.field("attrs", &self.attrs);
881 formatter.field("and_token", &self.and_token);
882 formatter.field("raw", &self.raw);
883 formatter.field("mutability", &self.mutability);
884 formatter.field("expr", &self.expr);
885 formatter.finish()
886 }
887 }
888 #[cfg(feature = "full")]
889 impl Debug for ExprRepeat {
890 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
891 let mut formatter = formatter.debug_struct("ExprRepeat");
892 formatter.field("attrs", &self.attrs);
893 formatter.field("bracket_token", &self.bracket_token);
894 formatter.field("expr", &self.expr);
895 formatter.field("semi_token", &self.semi_token);
896 formatter.field("len", &self.len);
897 formatter.finish()
898 }
899 }
900 #[cfg(feature = "full")]
901 impl Debug for ExprReturn {
902 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
903 let mut formatter = formatter.debug_struct("ExprReturn");
904 formatter.field("attrs", &self.attrs);
905 formatter.field("return_token", &self.return_token);
906 formatter.field("expr", &self.expr);
907 formatter.finish()
908 }
909 }
910 #[cfg(feature = "full")]
911 impl Debug for ExprStruct {
912 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
913 let mut formatter = formatter.debug_struct("ExprStruct");
914 formatter.field("attrs", &self.attrs);
915 formatter.field("path", &self.path);
916 formatter.field("brace_token", &self.brace_token);
917 formatter.field("fields", &self.fields);
918 formatter.field("dot2_token", &self.dot2_token);
919 formatter.field("rest", &self.rest);
920 formatter.finish()
921 }
922 }
923 #[cfg(feature = "full")]
924 impl Debug for ExprTry {
925 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
926 let mut formatter = formatter.debug_struct("ExprTry");
927 formatter.field("attrs", &self.attrs);
928 formatter.field("expr", &self.expr);
929 formatter.field("question_token", &self.question_token);
930 formatter.finish()
931 }
932 }
933 #[cfg(feature = "full")]
934 impl Debug for ExprTryBlock {
935 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
936 let mut formatter = formatter.debug_struct("ExprTryBlock");
937 formatter.field("attrs", &self.attrs);
938 formatter.field("try_token", &self.try_token);
939 formatter.field("block", &self.block);
940 formatter.finish()
941 }
942 }
943 #[cfg(feature = "full")]
944 impl Debug for ExprTuple {
945 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
946 let mut formatter = formatter.debug_struct("ExprTuple");
947 formatter.field("attrs", &self.attrs);
948 formatter.field("paren_token", &self.paren_token);
949 formatter.field("elems", &self.elems);
950 formatter.finish()
951 }
952 }
953 #[cfg(feature = "full")]
954 impl Debug for ExprType {
955 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
956 let mut formatter = formatter.debug_struct("ExprType");
957 formatter.field("attrs", &self.attrs);
958 formatter.field("expr", &self.expr);
959 formatter.field("colon_token", &self.colon_token);
960 formatter.field("ty", &self.ty);
961 formatter.finish()
962 }
963 }
964 #[cfg(any(feature = "derive", feature = "full"))]
965 impl Debug for ExprUnary {
966 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
967 let mut formatter = formatter.debug_struct("ExprUnary");
968 formatter.field("attrs", &self.attrs);
969 formatter.field("op", &self.op);
970 formatter.field("expr", &self.expr);
971 formatter.finish()
972 }
973 }
974 #[cfg(feature = "full")]
975 impl Debug for ExprUnsafe {
976 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
977 let mut formatter = formatter.debug_struct("ExprUnsafe");
978 formatter.field("attrs", &self.attrs);
979 formatter.field("unsafe_token", &self.unsafe_token);
980 formatter.field("block", &self.block);
981 formatter.finish()
982 }
983 }
984 #[cfg(feature = "full")]
985 impl Debug for ExprWhile {
986 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
987 let mut formatter = formatter.debug_struct("ExprWhile");
988 formatter.field("attrs", &self.attrs);
989 formatter.field("label", &self.label);
990 formatter.field("while_token", &self.while_token);
991 formatter.field("cond", &self.cond);
992 formatter.field("body", &self.body);
993 formatter.finish()
994 }
995 }
996 #[cfg(feature = "full")]
997 impl Debug for ExprYield {
998 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
999 let mut formatter = formatter.debug_struct("ExprYield");
1000 formatter.field("attrs", &self.attrs);
1001 formatter.field("yield_token", &self.yield_token);
1002 formatter.field("expr", &self.expr);
1003 formatter.finish()
1004 }
1005 }
1006 #[cfg(any(feature = "derive", feature = "full"))]
1007 impl Debug for Field {
1008 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1009 let mut formatter = formatter.debug_struct("Field");
1010 formatter.field("attrs", &self.attrs);
1011 formatter.field("vis", &self.vis);
1012 formatter.field("ident", &self.ident);
1013 formatter.field("colon_token", &self.colon_token);
1014 formatter.field("ty", &self.ty);
1015 formatter.finish()
1016 }
1017 }
1018 #[cfg(feature = "full")]
1019 impl Debug for FieldPat {
1020 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1021 let mut formatter = formatter.debug_struct("FieldPat");
1022 formatter.field("attrs", &self.attrs);
1023 formatter.field("member", &self.member);
1024 formatter.field("colon_token", &self.colon_token);
1025 formatter.field("pat", &self.pat);
1026 formatter.finish()
1027 }
1028 }
1029 #[cfg(feature = "full")]
1030 impl Debug for FieldValue {
1031 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1032 let mut formatter = formatter.debug_struct("FieldValue");
1033 formatter.field("attrs", &self.attrs);
1034 formatter.field("member", &self.member);
1035 formatter.field("colon_token", &self.colon_token);
1036 formatter.field("expr", &self.expr);
1037 formatter.finish()
1038 }
1039 }
1040 #[cfg(any(feature = "derive", feature = "full"))]
1041 impl Debug for Fields {
1042 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1043 match self {
1044 Fields::Named(v0) => {
1045 let mut formatter = formatter.debug_tuple("Named");
1046 formatter.field(v0);
1047 formatter.finish()
1048 }
1049 Fields::Unnamed(v0) => {
1050 let mut formatter = formatter.debug_tuple("Unnamed");
1051 formatter.field(v0);
1052 formatter.finish()
1053 }
1054 Fields::Unit => formatter.write_str("Unit"),
1055 }
1056 }
1057 }
1058 #[cfg(any(feature = "derive", feature = "full"))]
1059 impl Debug for FieldsNamed {
1060 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1061 let mut formatter = formatter.debug_struct("FieldsNamed");
1062 formatter.field("brace_token", &self.brace_token);
1063 formatter.field("named", &self.named);
1064 formatter.finish()
1065 }
1066 }
1067 #[cfg(any(feature = "derive", feature = "full"))]
1068 impl Debug for FieldsUnnamed {
1069 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1070 let mut formatter = formatter.debug_struct("FieldsUnnamed");
1071 formatter.field("paren_token", &self.paren_token);
1072 formatter.field("unnamed", &self.unnamed);
1073 formatter.finish()
1074 }
1075 }
1076 #[cfg(feature = "full")]
1077 impl Debug for File {
1078 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1079 let mut formatter = formatter.debug_struct("File");
1080 formatter.field("shebang", &self.shebang);
1081 formatter.field("attrs", &self.attrs);
1082 formatter.field("items", &self.items);
1083 formatter.finish()
1084 }
1085 }
1086 #[cfg(feature = "full")]
1087 impl Debug for FnArg {
1088 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1089 match self {
1090 FnArg::Receiver(v0) => {
1091 let mut formatter = formatter.debug_tuple("Receiver");
1092 formatter.field(v0);
1093 formatter.finish()
1094 }
1095 FnArg::Typed(v0) => {
1096 let mut formatter = formatter.debug_tuple("Typed");
1097 formatter.field(v0);
1098 formatter.finish()
1099 }
1100 }
1101 }
1102 }
1103 #[cfg(feature = "full")]
1104 impl Debug for ForeignItem {
1105 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1106 match self {
1107 ForeignItem::Fn(v0) => {
1108 let mut formatter = formatter.debug_tuple("Fn");
1109 formatter.field(v0);
1110 formatter.finish()
1111 }
1112 ForeignItem::Static(v0) => {
1113 let mut formatter = formatter.debug_tuple("Static");
1114 formatter.field(v0);
1115 formatter.finish()
1116 }
1117 ForeignItem::Type(v0) => {
1118 let mut formatter = formatter.debug_tuple("Type");
1119 formatter.field(v0);
1120 formatter.finish()
1121 }
1122 ForeignItem::Macro(v0) => {
1123 let mut formatter = formatter.debug_tuple("Macro");
1124 formatter.field(v0);
1125 formatter.finish()
1126 }
1127 ForeignItem::Verbatim(v0) => {
1128 let mut formatter = formatter.debug_tuple("Verbatim");
1129 formatter.field(v0);
1130 formatter.finish()
1131 }
1132 _ => unreachable!(),
1133 }
1134 }
1135 }
1136 #[cfg(feature = "full")]
1137 impl Debug for ForeignItemFn {
1138 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1139 let mut formatter = formatter.debug_struct("ForeignItemFn");
1140 formatter.field("attrs", &self.attrs);
1141 formatter.field("vis", &self.vis);
1142 formatter.field("sig", &self.sig);
1143 formatter.field("semi_token", &self.semi_token);
1144 formatter.finish()
1145 }
1146 }
1147 #[cfg(feature = "full")]
1148 impl Debug for ForeignItemMacro {
1149 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1150 let mut formatter = formatter.debug_struct("ForeignItemMacro");
1151 formatter.field("attrs", &self.attrs);
1152 formatter.field("mac", &self.mac);
1153 formatter.field("semi_token", &self.semi_token);
1154 formatter.finish()
1155 }
1156 }
1157 #[cfg(feature = "full")]
1158 impl Debug for ForeignItemStatic {
1159 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1160 let mut formatter = formatter.debug_struct("ForeignItemStatic");
1161 formatter.field("attrs", &self.attrs);
1162 formatter.field("vis", &self.vis);
1163 formatter.field("static_token", &self.static_token);
1164 formatter.field("mutability", &self.mutability);
1165 formatter.field("ident", &self.ident);
1166 formatter.field("colon_token", &self.colon_token);
1167 formatter.field("ty", &self.ty);
1168 formatter.field("semi_token", &self.semi_token);
1169 formatter.finish()
1170 }
1171 }
1172 #[cfg(feature = "full")]
1173 impl Debug for ForeignItemType {
1174 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1175 let mut formatter = formatter.debug_struct("ForeignItemType");
1176 formatter.field("attrs", &self.attrs);
1177 formatter.field("vis", &self.vis);
1178 formatter.field("type_token", &self.type_token);
1179 formatter.field("ident", &self.ident);
1180 formatter.field("semi_token", &self.semi_token);
1181 formatter.finish()
1182 }
1183 }
1184 #[cfg(any(feature = "derive", feature = "full"))]
1185 impl Debug for GenericArgument {
1186 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1187 match self {
1188 GenericArgument::Lifetime(v0) => {
1189 let mut formatter = formatter.debug_tuple("Lifetime");
1190 formatter.field(v0);
1191 formatter.finish()
1192 }
1193 GenericArgument::Type(v0) => {
1194 let mut formatter = formatter.debug_tuple("Type");
1195 formatter.field(v0);
1196 formatter.finish()
1197 }
1198 GenericArgument::Binding(v0) => {
1199 let mut formatter = formatter.debug_tuple("Binding");
1200 formatter.field(v0);
1201 formatter.finish()
1202 }
1203 GenericArgument::Constraint(v0) => {
1204 let mut formatter = formatter.debug_tuple("Constraint");
1205 formatter.field(v0);
1206 formatter.finish()
1207 }
1208 GenericArgument::Const(v0) => {
1209 let mut formatter = formatter.debug_tuple("Const");
1210 formatter.field(v0);
1211 formatter.finish()
1212 }
1213 }
1214 }
1215 }
1216 #[cfg(feature = "full")]
1217 impl Debug for GenericMethodArgument {
1218 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1219 match self {
1220 GenericMethodArgument::Type(v0) => {
1221 let mut formatter = formatter.debug_tuple("Type");
1222 formatter.field(v0);
1223 formatter.finish()
1224 }
1225 GenericMethodArgument::Const(v0) => {
1226 let mut formatter = formatter.debug_tuple("Const");
1227 formatter.field(v0);
1228 formatter.finish()
1229 }
1230 }
1231 }
1232 }
1233 #[cfg(any(feature = "derive", feature = "full"))]
1234 impl Debug for GenericParam {
1235 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1236 match self {
1237 GenericParam::Type(v0) => {
1238 let mut formatter = formatter.debug_tuple("Type");
1239 formatter.field(v0);
1240 formatter.finish()
1241 }
1242 GenericParam::Lifetime(v0) => {
1243 let mut formatter = formatter.debug_tuple("Lifetime");
1244 formatter.field(v0);
1245 formatter.finish()
1246 }
1247 GenericParam::Const(v0) => {
1248 let mut formatter = formatter.debug_tuple("Const");
1249 formatter.field(v0);
1250 formatter.finish()
1251 }
1252 }
1253 }
1254 }
1255 #[cfg(any(feature = "derive", feature = "full"))]
1256 impl Debug for Generics {
1257 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1258 let mut formatter = formatter.debug_struct("Generics");
1259 formatter.field("lt_token", &self.lt_token);
1260 formatter.field("params", &self.params);
1261 formatter.field("gt_token", &self.gt_token);
1262 formatter.field("where_clause", &self.where_clause);
1263 formatter.finish()
1264 }
1265 }
1266 #[cfg(feature = "full")]
1267 impl Debug for ImplItem {
1268 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1269 match self {
1270 ImplItem::Const(v0) => {
1271 let mut formatter = formatter.debug_tuple("Const");
1272 formatter.field(v0);
1273 formatter.finish()
1274 }
1275 ImplItem::Method(v0) => {
1276 let mut formatter = formatter.debug_tuple("Method");
1277 formatter.field(v0);
1278 formatter.finish()
1279 }
1280 ImplItem::Type(v0) => {
1281 let mut formatter = formatter.debug_tuple("Type");
1282 formatter.field(v0);
1283 formatter.finish()
1284 }
1285 ImplItem::Macro(v0) => {
1286 let mut formatter = formatter.debug_tuple("Macro");
1287 formatter.field(v0);
1288 formatter.finish()
1289 }
1290 ImplItem::Verbatim(v0) => {
1291 let mut formatter = formatter.debug_tuple("Verbatim");
1292 formatter.field(v0);
1293 formatter.finish()
1294 }
1295 _ => unreachable!(),
1296 }
1297 }
1298 }
1299 #[cfg(feature = "full")]
1300 impl Debug for ImplItemConst {
1301 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1302 let mut formatter = formatter.debug_struct("ImplItemConst");
1303 formatter.field("attrs", &self.attrs);
1304 formatter.field("vis", &self.vis);
1305 formatter.field("defaultness", &self.defaultness);
1306 formatter.field("const_token", &self.const_token);
1307 formatter.field("ident", &self.ident);
1308 formatter.field("colon_token", &self.colon_token);
1309 formatter.field("ty", &self.ty);
1310 formatter.field("eq_token", &self.eq_token);
1311 formatter.field("expr", &self.expr);
1312 formatter.field("semi_token", &self.semi_token);
1313 formatter.finish()
1314 }
1315 }
1316 #[cfg(feature = "full")]
1317 impl Debug for ImplItemMacro {
1318 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1319 let mut formatter = formatter.debug_struct("ImplItemMacro");
1320 formatter.field("attrs", &self.attrs);
1321 formatter.field("mac", &self.mac);
1322 formatter.field("semi_token", &self.semi_token);
1323 formatter.finish()
1324 }
1325 }
1326 #[cfg(feature = "full")]
1327 impl Debug for ImplItemMethod {
1328 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1329 let mut formatter = formatter.debug_struct("ImplItemMethod");
1330 formatter.field("attrs", &self.attrs);
1331 formatter.field("vis", &self.vis);
1332 formatter.field("defaultness", &self.defaultness);
1333 formatter.field("sig", &self.sig);
1334 formatter.field("block", &self.block);
1335 formatter.finish()
1336 }
1337 }
1338 #[cfg(feature = "full")]
1339 impl Debug for ImplItemType {
1340 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1341 let mut formatter = formatter.debug_struct("ImplItemType");
1342 formatter.field("attrs", &self.attrs);
1343 formatter.field("vis", &self.vis);
1344 formatter.field("defaultness", &self.defaultness);
1345 formatter.field("type_token", &self.type_token);
1346 formatter.field("ident", &self.ident);
1347 formatter.field("generics", &self.generics);
1348 formatter.field("eq_token", &self.eq_token);
1349 formatter.field("ty", &self.ty);
1350 formatter.field("semi_token", &self.semi_token);
1351 formatter.finish()
1352 }
1353 }
1354 #[cfg(any(feature = "derive", feature = "full"))]
1355 impl Debug for Index {
1356 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1357 let mut formatter = formatter.debug_struct("Index");
1358 formatter.field("index", &self.index);
1359 formatter.field("span", &self.span);
1360 formatter.finish()
1361 }
1362 }
1363 #[cfg(feature = "full")]
1364 impl Debug for Item {
1365 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1366 match self {
1367 Item::Const(v0) => {
1368 let mut formatter = formatter.debug_tuple("Const");
1369 formatter.field(v0);
1370 formatter.finish()
1371 }
1372 Item::Enum(v0) => {
1373 let mut formatter = formatter.debug_tuple("Enum");
1374 formatter.field(v0);
1375 formatter.finish()
1376 }
1377 Item::ExternCrate(v0) => {
1378 let mut formatter = formatter.debug_tuple("ExternCrate");
1379 formatter.field(v0);
1380 formatter.finish()
1381 }
1382 Item::Fn(v0) => {
1383 let mut formatter = formatter.debug_tuple("Fn");
1384 formatter.field(v0);
1385 formatter.finish()
1386 }
1387 Item::ForeignMod(v0) => {
1388 let mut formatter = formatter.debug_tuple("ForeignMod");
1389 formatter.field(v0);
1390 formatter.finish()
1391 }
1392 Item::Impl(v0) => {
1393 let mut formatter = formatter.debug_tuple("Impl");
1394 formatter.field(v0);
1395 formatter.finish()
1396 }
1397 Item::Macro(v0) => {
1398 let mut formatter = formatter.debug_tuple("Macro");
1399 formatter.field(v0);
1400 formatter.finish()
1401 }
1402 Item::Macro2(v0) => {
1403 let mut formatter = formatter.debug_tuple("Macro2");
1404 formatter.field(v0);
1405 formatter.finish()
1406 }
1407 Item::Mod(v0) => {
1408 let mut formatter = formatter.debug_tuple("Mod");
1409 formatter.field(v0);
1410 formatter.finish()
1411 }
1412 Item::Static(v0) => {
1413 let mut formatter = formatter.debug_tuple("Static");
1414 formatter.field(v0);
1415 formatter.finish()
1416 }
1417 Item::Struct(v0) => {
1418 let mut formatter = formatter.debug_tuple("Struct");
1419 formatter.field(v0);
1420 formatter.finish()
1421 }
1422 Item::Trait(v0) => {
1423 let mut formatter = formatter.debug_tuple("Trait");
1424 formatter.field(v0);
1425 formatter.finish()
1426 }
1427 Item::TraitAlias(v0) => {
1428 let mut formatter = formatter.debug_tuple("TraitAlias");
1429 formatter.field(v0);
1430 formatter.finish()
1431 }
1432 Item::Type(v0) => {
1433 let mut formatter = formatter.debug_tuple("Type");
1434 formatter.field(v0);
1435 formatter.finish()
1436 }
1437 Item::Union(v0) => {
1438 let mut formatter = formatter.debug_tuple("Union");
1439 formatter.field(v0);
1440 formatter.finish()
1441 }
1442 Item::Use(v0) => {
1443 let mut formatter = formatter.debug_tuple("Use");
1444 formatter.field(v0);
1445 formatter.finish()
1446 }
1447 Item::Verbatim(v0) => {
1448 let mut formatter = formatter.debug_tuple("Verbatim");
1449 formatter.field(v0);
1450 formatter.finish()
1451 }
1452 _ => unreachable!(),
1453 }
1454 }
1455 }
1456 #[cfg(feature = "full")]
1457 impl Debug for ItemConst {
1458 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1459 let mut formatter = formatter.debug_struct("ItemConst");
1460 formatter.field("attrs", &self.attrs);
1461 formatter.field("vis", &self.vis);
1462 formatter.field("const_token", &self.const_token);
1463 formatter.field("ident", &self.ident);
1464 formatter.field("colon_token", &self.colon_token);
1465 formatter.field("ty", &self.ty);
1466 formatter.field("eq_token", &self.eq_token);
1467 formatter.field("expr", &self.expr);
1468 formatter.field("semi_token", &self.semi_token);
1469 formatter.finish()
1470 }
1471 }
1472 #[cfg(feature = "full")]
1473 impl Debug for ItemEnum {
1474 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1475 let mut formatter = formatter.debug_struct("ItemEnum");
1476 formatter.field("attrs", &self.attrs);
1477 formatter.field("vis", &self.vis);
1478 formatter.field("enum_token", &self.enum_token);
1479 formatter.field("ident", &self.ident);
1480 formatter.field("generics", &self.generics);
1481 formatter.field("brace_token", &self.brace_token);
1482 formatter.field("variants", &self.variants);
1483 formatter.finish()
1484 }
1485 }
1486 #[cfg(feature = "full")]
1487 impl Debug for ItemExternCrate {
1488 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1489 let mut formatter = formatter.debug_struct("ItemExternCrate");
1490 formatter.field("attrs", &self.attrs);
1491 formatter.field("vis", &self.vis);
1492 formatter.field("extern_token", &self.extern_token);
1493 formatter.field("crate_token", &self.crate_token);
1494 formatter.field("ident", &self.ident);
1495 formatter.field("rename", &self.rename);
1496 formatter.field("semi_token", &self.semi_token);
1497 formatter.finish()
1498 }
1499 }
1500 #[cfg(feature = "full")]
1501 impl Debug for ItemFn {
1502 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1503 let mut formatter = formatter.debug_struct("ItemFn");
1504 formatter.field("attrs", &self.attrs);
1505 formatter.field("vis", &self.vis);
1506 formatter.field("sig", &self.sig);
1507 formatter.field("block", &self.block);
1508 formatter.finish()
1509 }
1510 }
1511 #[cfg(feature = "full")]
1512 impl Debug for ItemForeignMod {
1513 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1514 let mut formatter = formatter.debug_struct("ItemForeignMod");
1515 formatter.field("attrs", &self.attrs);
1516 formatter.field("abi", &self.abi);
1517 formatter.field("brace_token", &self.brace_token);
1518 formatter.field("items", &self.items);
1519 formatter.finish()
1520 }
1521 }
1522 #[cfg(feature = "full")]
1523 impl Debug for ItemImpl {
1524 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1525 let mut formatter = formatter.debug_struct("ItemImpl");
1526 formatter.field("attrs", &self.attrs);
1527 formatter.field("defaultness", &self.defaultness);
1528 formatter.field("unsafety", &self.unsafety);
1529 formatter.field("impl_token", &self.impl_token);
1530 formatter.field("generics", &self.generics);
1531 formatter.field("trait_", &self.trait_);
1532 formatter.field("self_ty", &self.self_ty);
1533 formatter.field("brace_token", &self.brace_token);
1534 formatter.field("items", &self.items);
1535 formatter.finish()
1536 }
1537 }
1538 #[cfg(feature = "full")]
1539 impl Debug for ItemMacro {
1540 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1541 let mut formatter = formatter.debug_struct("ItemMacro");
1542 formatter.field("attrs", &self.attrs);
1543 formatter.field("ident", &self.ident);
1544 formatter.field("mac", &self.mac);
1545 formatter.field("semi_token", &self.semi_token);
1546 formatter.finish()
1547 }
1548 }
1549 #[cfg(feature = "full")]
1550 impl Debug for ItemMacro2 {
1551 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1552 let mut formatter = formatter.debug_struct("ItemMacro2");
1553 formatter.field("attrs", &self.attrs);
1554 formatter.field("vis", &self.vis);
1555 formatter.field("macro_token", &self.macro_token);
1556 formatter.field("ident", &self.ident);
1557 formatter.field("rules", &self.rules);
1558 formatter.finish()
1559 }
1560 }
1561 #[cfg(feature = "full")]
1562 impl Debug for ItemMod {
1563 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1564 let mut formatter = formatter.debug_struct("ItemMod");
1565 formatter.field("attrs", &self.attrs);
1566 formatter.field("vis", &self.vis);
1567 formatter.field("mod_token", &self.mod_token);
1568 formatter.field("ident", &self.ident);
1569 formatter.field("content", &self.content);
1570 formatter.field("semi", &self.semi);
1571 formatter.finish()
1572 }
1573 }
1574 #[cfg(feature = "full")]
1575 impl Debug for ItemStatic {
1576 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1577 let mut formatter = formatter.debug_struct("ItemStatic");
1578 formatter.field("attrs", &self.attrs);
1579 formatter.field("vis", &self.vis);
1580 formatter.field("static_token", &self.static_token);
1581 formatter.field("mutability", &self.mutability);
1582 formatter.field("ident", &self.ident);
1583 formatter.field("colon_token", &self.colon_token);
1584 formatter.field("ty", &self.ty);
1585 formatter.field("eq_token", &self.eq_token);
1586 formatter.field("expr", &self.expr);
1587 formatter.field("semi_token", &self.semi_token);
1588 formatter.finish()
1589 }
1590 }
1591 #[cfg(feature = "full")]
1592 impl Debug for ItemStruct {
1593 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1594 let mut formatter = formatter.debug_struct("ItemStruct");
1595 formatter.field("attrs", &self.attrs);
1596 formatter.field("vis", &self.vis);
1597 formatter.field("struct_token", &self.struct_token);
1598 formatter.field("ident", &self.ident);
1599 formatter.field("generics", &self.generics);
1600 formatter.field("fields", &self.fields);
1601 formatter.field("semi_token", &self.semi_token);
1602 formatter.finish()
1603 }
1604 }
1605 #[cfg(feature = "full")]
1606 impl Debug for ItemTrait {
1607 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1608 let mut formatter = formatter.debug_struct("ItemTrait");
1609 formatter.field("attrs", &self.attrs);
1610 formatter.field("vis", &self.vis);
1611 formatter.field("unsafety", &self.unsafety);
1612 formatter.field("auto_token", &self.auto_token);
1613 formatter.field("trait_token", &self.trait_token);
1614 formatter.field("ident", &self.ident);
1615 formatter.field("generics", &self.generics);
1616 formatter.field("colon_token", &self.colon_token);
1617 formatter.field("supertraits", &self.supertraits);
1618 formatter.field("brace_token", &self.brace_token);
1619 formatter.field("items", &self.items);
1620 formatter.finish()
1621 }
1622 }
1623 #[cfg(feature = "full")]
1624 impl Debug for ItemTraitAlias {
1625 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1626 let mut formatter = formatter.debug_struct("ItemTraitAlias");
1627 formatter.field("attrs", &self.attrs);
1628 formatter.field("vis", &self.vis);
1629 formatter.field("trait_token", &self.trait_token);
1630 formatter.field("ident", &self.ident);
1631 formatter.field("generics", &self.generics);
1632 formatter.field("eq_token", &self.eq_token);
1633 formatter.field("bounds", &self.bounds);
1634 formatter.field("semi_token", &self.semi_token);
1635 formatter.finish()
1636 }
1637 }
1638 #[cfg(feature = "full")]
1639 impl Debug for ItemType {
1640 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1641 let mut formatter = formatter.debug_struct("ItemType");
1642 formatter.field("attrs", &self.attrs);
1643 formatter.field("vis", &self.vis);
1644 formatter.field("type_token", &self.type_token);
1645 formatter.field("ident", &self.ident);
1646 formatter.field("generics", &self.generics);
1647 formatter.field("eq_token", &self.eq_token);
1648 formatter.field("ty", &self.ty);
1649 formatter.field("semi_token", &self.semi_token);
1650 formatter.finish()
1651 }
1652 }
1653 #[cfg(feature = "full")]
1654 impl Debug for ItemUnion {
1655 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1656 let mut formatter = formatter.debug_struct("ItemUnion");
1657 formatter.field("attrs", &self.attrs);
1658 formatter.field("vis", &self.vis);
1659 formatter.field("union_token", &self.union_token);
1660 formatter.field("ident", &self.ident);
1661 formatter.field("generics", &self.generics);
1662 formatter.field("fields", &self.fields);
1663 formatter.finish()
1664 }
1665 }
1666 #[cfg(feature = "full")]
1667 impl Debug for ItemUse {
1668 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1669 let mut formatter = formatter.debug_struct("ItemUse");
1670 formatter.field("attrs", &self.attrs);
1671 formatter.field("vis", &self.vis);
1672 formatter.field("use_token", &self.use_token);
1673 formatter.field("leading_colon", &self.leading_colon);
1674 formatter.field("tree", &self.tree);
1675 formatter.field("semi_token", &self.semi_token);
1676 formatter.finish()
1677 }
1678 }
1679 #[cfg(feature = "full")]
1680 impl Debug for Label {
1681 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1682 let mut formatter = formatter.debug_struct("Label");
1683 formatter.field("name", &self.name);
1684 formatter.field("colon_token", &self.colon_token);
1685 formatter.finish()
1686 }
1687 }
1688 impl Debug for Lifetime {
1689 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1690 let mut formatter = formatter.debug_struct("Lifetime");
1691 formatter.field("apostrophe", &self.apostrophe);
1692 formatter.field("ident", &self.ident);
1693 formatter.finish()
1694 }
1695 }
1696 #[cfg(any(feature = "derive", feature = "full"))]
1697 impl Debug for LifetimeDef {
1698 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1699 let mut formatter = formatter.debug_struct("LifetimeDef");
1700 formatter.field("attrs", &self.attrs);
1701 formatter.field("lifetime", &self.lifetime);
1702 formatter.field("colon_token", &self.colon_token);
1703 formatter.field("bounds", &self.bounds);
1704 formatter.finish()
1705 }
1706 }
1707 impl Debug for Lit {
1708 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1709 match self {
1710 Lit::Str(v0) => {
1711 let mut formatter = formatter.debug_tuple("Str");
1712 formatter.field(v0);
1713 formatter.finish()
1714 }
1715 Lit::ByteStr(v0) => {
1716 let mut formatter = formatter.debug_tuple("ByteStr");
1717 formatter.field(v0);
1718 formatter.finish()
1719 }
1720 Lit::Byte(v0) => {
1721 let mut formatter = formatter.debug_tuple("Byte");
1722 formatter.field(v0);
1723 formatter.finish()
1724 }
1725 Lit::Char(v0) => {
1726 let mut formatter = formatter.debug_tuple("Char");
1727 formatter.field(v0);
1728 formatter.finish()
1729 }
1730 Lit::Int(v0) => {
1731 let mut formatter = formatter.debug_tuple("Int");
1732 formatter.field(v0);
1733 formatter.finish()
1734 }
1735 Lit::Float(v0) => {
1736 let mut formatter = formatter.debug_tuple("Float");
1737 formatter.field(v0);
1738 formatter.finish()
1739 }
1740 Lit::Bool(v0) => {
1741 let mut formatter = formatter.debug_tuple("Bool");
1742 formatter.field(v0);
1743 formatter.finish()
1744 }
1745 Lit::Verbatim(v0) => {
1746 let mut formatter = formatter.debug_tuple("Verbatim");
1747 formatter.field(v0);
1748 formatter.finish()
1749 }
1750 }
1751 }
1752 }
1753 #[cfg(feature = "full")]
1754 impl Debug for Local {
1755 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1756 let mut formatter = formatter.debug_struct("Local");
1757 formatter.field("attrs", &self.attrs);
1758 formatter.field("let_token", &self.let_token);
1759 formatter.field("pat", &self.pat);
1760 formatter.field("init", &self.init);
1761 formatter.field("semi_token", &self.semi_token);
1762 formatter.finish()
1763 }
1764 }
1765 #[cfg(any(feature = "derive", feature = "full"))]
1766 impl Debug for Macro {
1767 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1768 let mut formatter = formatter.debug_struct("Macro");
1769 formatter.field("path", &self.path);
1770 formatter.field("bang_token", &self.bang_token);
1771 formatter.field("delimiter", &self.delimiter);
1772 formatter.field("tokens", &self.tokens);
1773 formatter.finish()
1774 }
1775 }
1776 #[cfg(any(feature = "derive", feature = "full"))]
1777 impl Debug for MacroDelimiter {
1778 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1779 match self {
1780 MacroDelimiter::Paren(v0) => {
1781 let mut formatter = formatter.debug_tuple("Paren");
1782 formatter.field(v0);
1783 formatter.finish()
1784 }
1785 MacroDelimiter::Brace(v0) => {
1786 let mut formatter = formatter.debug_tuple("Brace");
1787 formatter.field(v0);
1788 formatter.finish()
1789 }
1790 MacroDelimiter::Bracket(v0) => {
1791 let mut formatter = formatter.debug_tuple("Bracket");
1792 formatter.field(v0);
1793 formatter.finish()
1794 }
1795 }
1796 }
1797 }
1798 #[cfg(any(feature = "derive", feature = "full"))]
1799 impl Debug for Member {
1800 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1801 match self {
1802 Member::Named(v0) => {
1803 let mut formatter = formatter.debug_tuple("Named");
1804 formatter.field(v0);
1805 formatter.finish()
1806 }
1807 Member::Unnamed(v0) => {
1808 let mut formatter = formatter.debug_tuple("Unnamed");
1809 formatter.field(v0);
1810 formatter.finish()
1811 }
1812 }
1813 }
1814 }
1815 #[cfg(any(feature = "derive", feature = "full"))]
1816 impl Debug for Meta {
1817 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1818 match self {
1819 Meta::Path(v0) => {
1820 let mut formatter = formatter.debug_tuple("Path");
1821 formatter.field(v0);
1822 formatter.finish()
1823 }
1824 Meta::List(v0) => {
1825 let mut formatter = formatter.debug_tuple("List");
1826 formatter.field(v0);
1827 formatter.finish()
1828 }
1829 Meta::NameValue(v0) => {
1830 let mut formatter = formatter.debug_tuple("NameValue");
1831 formatter.field(v0);
1832 formatter.finish()
1833 }
1834 }
1835 }
1836 }
1837 #[cfg(any(feature = "derive", feature = "full"))]
1838 impl Debug for MetaList {
1839 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1840 let mut formatter = formatter.debug_struct("MetaList");
1841 formatter.field("path", &self.path);
1842 formatter.field("paren_token", &self.paren_token);
1843 formatter.field("nested", &self.nested);
1844 formatter.finish()
1845 }
1846 }
1847 #[cfg(any(feature = "derive", feature = "full"))]
1848 impl Debug for MetaNameValue {
1849 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1850 let mut formatter = formatter.debug_struct("MetaNameValue");
1851 formatter.field("path", &self.path);
1852 formatter.field("eq_token", &self.eq_token);
1853 formatter.field("lit", &self.lit);
1854 formatter.finish()
1855 }
1856 }
1857 #[cfg(feature = "full")]
1858 impl Debug for MethodTurbofish {
1859 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1860 let mut formatter = formatter.debug_struct("MethodTurbofish");
1861 formatter.field("colon2_token", &self.colon2_token);
1862 formatter.field("lt_token", &self.lt_token);
1863 formatter.field("args", &self.args);
1864 formatter.field("gt_token", &self.gt_token);
1865 formatter.finish()
1866 }
1867 }
1868 #[cfg(any(feature = "derive", feature = "full"))]
1869 impl Debug for NestedMeta {
1870 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1871 match self {
1872 NestedMeta::Meta(v0) => {
1873 let mut formatter = formatter.debug_tuple("Meta");
1874 formatter.field(v0);
1875 formatter.finish()
1876 }
1877 NestedMeta::Lit(v0) => {
1878 let mut formatter = formatter.debug_tuple("Lit");
1879 formatter.field(v0);
1880 formatter.finish()
1881 }
1882 }
1883 }
1884 }
1885 #[cfg(any(feature = "derive", feature = "full"))]
1886 impl Debug for ParenthesizedGenericArguments {
1887 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1888 let mut formatter = formatter.debug_struct("ParenthesizedGenericArguments");
1889 formatter.field("paren_token", &self.paren_token);
1890 formatter.field("inputs", &self.inputs);
1891 formatter.field("output", &self.output);
1892 formatter.finish()
1893 }
1894 }
1895 #[cfg(feature = "full")]
1896 impl Debug for Pat {
1897 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1898 match self {
1899 Pat::Box(v0) => {
1900 let mut formatter = formatter.debug_tuple("Box");
1901 formatter.field(v0);
1902 formatter.finish()
1903 }
1904 Pat::Ident(v0) => {
1905 let mut formatter = formatter.debug_tuple("Ident");
1906 formatter.field(v0);
1907 formatter.finish()
1908 }
1909 Pat::Lit(v0) => {
1910 let mut formatter = formatter.debug_tuple("Lit");
1911 formatter.field(v0);
1912 formatter.finish()
1913 }
1914 Pat::Macro(v0) => {
1915 let mut formatter = formatter.debug_tuple("Macro");
1916 formatter.field(v0);
1917 formatter.finish()
1918 }
1919 Pat::Or(v0) => {
1920 let mut formatter = formatter.debug_tuple("Or");
1921 formatter.field(v0);
1922 formatter.finish()
1923 }
1924 Pat::Path(v0) => {
1925 let mut formatter = formatter.debug_tuple("Path");
1926 formatter.field(v0);
1927 formatter.finish()
1928 }
1929 Pat::Range(v0) => {
1930 let mut formatter = formatter.debug_tuple("Range");
1931 formatter.field(v0);
1932 formatter.finish()
1933 }
1934 Pat::Reference(v0) => {
1935 let mut formatter = formatter.debug_tuple("Reference");
1936 formatter.field(v0);
1937 formatter.finish()
1938 }
1939 Pat::Rest(v0) => {
1940 let mut formatter = formatter.debug_tuple("Rest");
1941 formatter.field(v0);
1942 formatter.finish()
1943 }
1944 Pat::Slice(v0) => {
1945 let mut formatter = formatter.debug_tuple("Slice");
1946 formatter.field(v0);
1947 formatter.finish()
1948 }
1949 Pat::Struct(v0) => {
1950 let mut formatter = formatter.debug_tuple("Struct");
1951 formatter.field(v0);
1952 formatter.finish()
1953 }
1954 Pat::Tuple(v0) => {
1955 let mut formatter = formatter.debug_tuple("Tuple");
1956 formatter.field(v0);
1957 formatter.finish()
1958 }
1959 Pat::TupleStruct(v0) => {
1960 let mut formatter = formatter.debug_tuple("TupleStruct");
1961 formatter.field(v0);
1962 formatter.finish()
1963 }
1964 Pat::Type(v0) => {
1965 let mut formatter = formatter.debug_tuple("Type");
1966 formatter.field(v0);
1967 formatter.finish()
1968 }
1969 Pat::Verbatim(v0) => {
1970 let mut formatter = formatter.debug_tuple("Verbatim");
1971 formatter.field(v0);
1972 formatter.finish()
1973 }
1974 Pat::Wild(v0) => {
1975 let mut formatter = formatter.debug_tuple("Wild");
1976 formatter.field(v0);
1977 formatter.finish()
1978 }
1979 _ => unreachable!(),
1980 }
1981 }
1982 }
1983 #[cfg(feature = "full")]
1984 impl Debug for PatBox {
1985 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1986 let mut formatter = formatter.debug_struct("PatBox");
1987 formatter.field("attrs", &self.attrs);
1988 formatter.field("box_token", &self.box_token);
1989 formatter.field("pat", &self.pat);
1990 formatter.finish()
1991 }
1992 }
1993 #[cfg(feature = "full")]
1994 impl Debug for PatIdent {
1995 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1996 let mut formatter = formatter.debug_struct("PatIdent");
1997 formatter.field("attrs", &self.attrs);
1998 formatter.field("by_ref", &self.by_ref);
1999 formatter.field("mutability", &self.mutability);
2000 formatter.field("ident", &self.ident);
2001 formatter.field("subpat", &self.subpat);
2002 formatter.finish()
2003 }
2004 }
2005 #[cfg(feature = "full")]
2006 impl Debug for PatLit {
2007 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2008 let mut formatter = formatter.debug_struct("PatLit");
2009 formatter.field("attrs", &self.attrs);
2010 formatter.field("expr", &self.expr);
2011 formatter.finish()
2012 }
2013 }
2014 #[cfg(feature = "full")]
2015 impl Debug for PatMacro {
2016 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2017 let mut formatter = formatter.debug_struct("PatMacro");
2018 formatter.field("attrs", &self.attrs);
2019 formatter.field("mac", &self.mac);
2020 formatter.finish()
2021 }
2022 }
2023 #[cfg(feature = "full")]
2024 impl Debug for PatOr {
2025 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2026 let mut formatter = formatter.debug_struct("PatOr");
2027 formatter.field("attrs", &self.attrs);
2028 formatter.field("leading_vert", &self.leading_vert);
2029 formatter.field("cases", &self.cases);
2030 formatter.finish()
2031 }
2032 }
2033 #[cfg(feature = "full")]
2034 impl Debug for PatPath {
2035 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2036 let mut formatter = formatter.debug_struct("PatPath");
2037 formatter.field("attrs", &self.attrs);
2038 formatter.field("qself", &self.qself);
2039 formatter.field("path", &self.path);
2040 formatter.finish()
2041 }
2042 }
2043 #[cfg(feature = "full")]
2044 impl Debug for PatRange {
2045 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2046 let mut formatter = formatter.debug_struct("PatRange");
2047 formatter.field("attrs", &self.attrs);
2048 formatter.field("lo", &self.lo);
2049 formatter.field("limits", &self.limits);
2050 formatter.field("hi", &self.hi);
2051 formatter.finish()
2052 }
2053 }
2054 #[cfg(feature = "full")]
2055 impl Debug for PatReference {
2056 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2057 let mut formatter = formatter.debug_struct("PatReference");
2058 formatter.field("attrs", &self.attrs);
2059 formatter.field("and_token", &self.and_token);
2060 formatter.field("mutability", &self.mutability);
2061 formatter.field("pat", &self.pat);
2062 formatter.finish()
2063 }
2064 }
2065 #[cfg(feature = "full")]
2066 impl Debug for PatRest {
2067 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2068 let mut formatter = formatter.debug_struct("PatRest");
2069 formatter.field("attrs", &self.attrs);
2070 formatter.field("dot2_token", &self.dot2_token);
2071 formatter.finish()
2072 }
2073 }
2074 #[cfg(feature = "full")]
2075 impl Debug for PatSlice {
2076 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2077 let mut formatter = formatter.debug_struct("PatSlice");
2078 formatter.field("attrs", &self.attrs);
2079 formatter.field("bracket_token", &self.bracket_token);
2080 formatter.field("elems", &self.elems);
2081 formatter.finish()
2082 }
2083 }
2084 #[cfg(feature = "full")]
2085 impl Debug for PatStruct {
2086 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2087 let mut formatter = formatter.debug_struct("PatStruct");
2088 formatter.field("attrs", &self.attrs);
2089 formatter.field("path", &self.path);
2090 formatter.field("brace_token", &self.brace_token);
2091 formatter.field("fields", &self.fields);
2092 formatter.field("dot2_token", &self.dot2_token);
2093 formatter.finish()
2094 }
2095 }
2096 #[cfg(feature = "full")]
2097 impl Debug for PatTuple {
2098 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2099 let mut formatter = formatter.debug_struct("PatTuple");
2100 formatter.field("attrs", &self.attrs);
2101 formatter.field("paren_token", &self.paren_token);
2102 formatter.field("elems", &self.elems);
2103 formatter.finish()
2104 }
2105 }
2106 #[cfg(feature = "full")]
2107 impl Debug for PatTupleStruct {
2108 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2109 let mut formatter = formatter.debug_struct("PatTupleStruct");
2110 formatter.field("attrs", &self.attrs);
2111 formatter.field("path", &self.path);
2112 formatter.field("pat", &self.pat);
2113 formatter.finish()
2114 }
2115 }
2116 #[cfg(feature = "full")]
2117 impl Debug for PatType {
2118 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2119 let mut formatter = formatter.debug_struct("PatType");
2120 formatter.field("attrs", &self.attrs);
2121 formatter.field("pat", &self.pat);
2122 formatter.field("colon_token", &self.colon_token);
2123 formatter.field("ty", &self.ty);
2124 formatter.finish()
2125 }
2126 }
2127 #[cfg(feature = "full")]
2128 impl Debug for PatWild {
2129 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2130 let mut formatter = formatter.debug_struct("PatWild");
2131 formatter.field("attrs", &self.attrs);
2132 formatter.field("underscore_token", &self.underscore_token);
2133 formatter.finish()
2134 }
2135 }
2136 #[cfg(any(feature = "derive", feature = "full"))]
2137 impl Debug for Path {
2138 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2139 let mut formatter = formatter.debug_struct("Path");
2140 formatter.field("leading_colon", &self.leading_colon);
2141 formatter.field("segments", &self.segments);
2142 formatter.finish()
2143 }
2144 }
2145 #[cfg(any(feature = "derive", feature = "full"))]
2146 impl Debug for PathArguments {
2147 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2148 match self {
2149 PathArguments::None => formatter.write_str("None"),
2150 PathArguments::AngleBracketed(v0) => {
2151 let mut formatter = formatter.debug_tuple("AngleBracketed");
2152 formatter.field(v0);
2153 formatter.finish()
2154 }
2155 PathArguments::Parenthesized(v0) => {
2156 let mut formatter = formatter.debug_tuple("Parenthesized");
2157 formatter.field(v0);
2158 formatter.finish()
2159 }
2160 }
2161 }
2162 }
2163 #[cfg(any(feature = "derive", feature = "full"))]
2164 impl Debug for PathSegment {
2165 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2166 let mut formatter = formatter.debug_struct("PathSegment");
2167 formatter.field("ident", &self.ident);
2168 formatter.field("arguments", &self.arguments);
2169 formatter.finish()
2170 }
2171 }
2172 #[cfg(any(feature = "derive", feature = "full"))]
2173 impl Debug for PredicateEq {
2174 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2175 let mut formatter = formatter.debug_struct("PredicateEq");
2176 formatter.field("lhs_ty", &self.lhs_ty);
2177 formatter.field("eq_token", &self.eq_token);
2178 formatter.field("rhs_ty", &self.rhs_ty);
2179 formatter.finish()
2180 }
2181 }
2182 #[cfg(any(feature = "derive", feature = "full"))]
2183 impl Debug for PredicateLifetime {
2184 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2185 let mut formatter = formatter.debug_struct("PredicateLifetime");
2186 formatter.field("lifetime", &self.lifetime);
2187 formatter.field("colon_token", &self.colon_token);
2188 formatter.field("bounds", &self.bounds);
2189 formatter.finish()
2190 }
2191 }
2192 #[cfg(any(feature = "derive", feature = "full"))]
2193 impl Debug for PredicateType {
2194 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2195 let mut formatter = formatter.debug_struct("PredicateType");
2196 formatter.field("lifetimes", &self.lifetimes);
2197 formatter.field("bounded_ty", &self.bounded_ty);
2198 formatter.field("colon_token", &self.colon_token);
2199 formatter.field("bounds", &self.bounds);
2200 formatter.finish()
2201 }
2202 }
2203 #[cfg(any(feature = "derive", feature = "full"))]
2204 impl Debug for QSelf {
2205 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2206 let mut formatter = formatter.debug_struct("QSelf");
2207 formatter.field("lt_token", &self.lt_token);
2208 formatter.field("ty", &self.ty);
2209 formatter.field("position", &self.position);
2210 formatter.field("as_token", &self.as_token);
2211 formatter.field("gt_token", &self.gt_token);
2212 formatter.finish()
2213 }
2214 }
2215 #[cfg(feature = "full")]
2216 impl Debug for RangeLimits {
2217 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2218 match self {
2219 RangeLimits::HalfOpen(v0) => {
2220 let mut formatter = formatter.debug_tuple("HalfOpen");
2221 formatter.field(v0);
2222 formatter.finish()
2223 }
2224 RangeLimits::Closed(v0) => {
2225 let mut formatter = formatter.debug_tuple("Closed");
2226 formatter.field(v0);
2227 formatter.finish()
2228 }
2229 }
2230 }
2231 }
2232 #[cfg(feature = "full")]
2233 impl Debug for Receiver {
2234 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2235 let mut formatter = formatter.debug_struct("Receiver");
2236 formatter.field("attrs", &self.attrs);
2237 formatter.field("reference", &self.reference);
2238 formatter.field("mutability", &self.mutability);
2239 formatter.field("self_token", &self.self_token);
2240 formatter.finish()
2241 }
2242 }
2243 #[cfg(any(feature = "derive", feature = "full"))]
2244 impl Debug for ReturnType {
2245 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2246 match self {
2247 ReturnType::Default => formatter.write_str("Default"),
2248 ReturnType::Type(v0, v1) => {
2249 let mut formatter = formatter.debug_tuple("Type");
2250 formatter.field(v0);
2251 formatter.field(v1);
2252 formatter.finish()
2253 }
2254 }
2255 }
2256 }
2257 #[cfg(feature = "full")]
2258 impl Debug for Signature {
2259 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2260 let mut formatter = formatter.debug_struct("Signature");
2261 formatter.field("constness", &self.constness);
2262 formatter.field("asyncness", &self.asyncness);
2263 formatter.field("unsafety", &self.unsafety);
2264 formatter.field("abi", &self.abi);
2265 formatter.field("fn_token", &self.fn_token);
2266 formatter.field("ident", &self.ident);
2267 formatter.field("generics", &self.generics);
2268 formatter.field("paren_token", &self.paren_token);
2269 formatter.field("inputs", &self.inputs);
2270 formatter.field("variadic", &self.variadic);
2271 formatter.field("output", &self.output);
2272 formatter.finish()
2273 }
2274 }
2275 #[cfg(feature = "full")]
2276 impl Debug for Stmt {
2277 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2278 match self {
2279 Stmt::Local(v0) => {
2280 let mut formatter = formatter.debug_tuple("Local");
2281 formatter.field(v0);
2282 formatter.finish()
2283 }
2284 Stmt::Item(v0) => {
2285 let mut formatter = formatter.debug_tuple("Item");
2286 formatter.field(v0);
2287 formatter.finish()
2288 }
2289 Stmt::Expr(v0) => {
2290 let mut formatter = formatter.debug_tuple("Expr");
2291 formatter.field(v0);
2292 formatter.finish()
2293 }
2294 Stmt::Semi(v0, v1) => {
2295 let mut formatter = formatter.debug_tuple("Semi");
2296 formatter.field(v0);
2297 formatter.field(v1);
2298 formatter.finish()
2299 }
2300 }
2301 }
2302 }
2303 #[cfg(any(feature = "derive", feature = "full"))]
2304 impl Debug for TraitBound {
2305 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2306 let mut formatter = formatter.debug_struct("TraitBound");
2307 formatter.field("paren_token", &self.paren_token);
2308 formatter.field("modifier", &self.modifier);
2309 formatter.field("lifetimes", &self.lifetimes);
2310 formatter.field("path", &self.path);
2311 formatter.finish()
2312 }
2313 }
2314 #[cfg(any(feature = "derive", feature = "full"))]
2315 impl Debug for TraitBoundModifier {
2316 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2317 match self {
2318 TraitBoundModifier::None => formatter.write_str("None"),
2319 TraitBoundModifier::Maybe(v0) => {
2320 let mut formatter = formatter.debug_tuple("Maybe");
2321 formatter.field(v0);
2322 formatter.finish()
2323 }
2324 }
2325 }
2326 }
2327 #[cfg(feature = "full")]
2328 impl Debug for TraitItem {
2329 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2330 match self {
2331 TraitItem::Const(v0) => {
2332 let mut formatter = formatter.debug_tuple("Const");
2333 formatter.field(v0);
2334 formatter.finish()
2335 }
2336 TraitItem::Method(v0) => {
2337 let mut formatter = formatter.debug_tuple("Method");
2338 formatter.field(v0);
2339 formatter.finish()
2340 }
2341 TraitItem::Type(v0) => {
2342 let mut formatter = formatter.debug_tuple("Type");
2343 formatter.field(v0);
2344 formatter.finish()
2345 }
2346 TraitItem::Macro(v0) => {
2347 let mut formatter = formatter.debug_tuple("Macro");
2348 formatter.field(v0);
2349 formatter.finish()
2350 }
2351 TraitItem::Verbatim(v0) => {
2352 let mut formatter = formatter.debug_tuple("Verbatim");
2353 formatter.field(v0);
2354 formatter.finish()
2355 }
2356 _ => unreachable!(),
2357 }
2358 }
2359 }
2360 #[cfg(feature = "full")]
2361 impl Debug for TraitItemConst {
2362 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2363 let mut formatter = formatter.debug_struct("TraitItemConst");
2364 formatter.field("attrs", &self.attrs);
2365 formatter.field("const_token", &self.const_token);
2366 formatter.field("ident", &self.ident);
2367 formatter.field("colon_token", &self.colon_token);
2368 formatter.field("ty", &self.ty);
2369 formatter.field("default", &self.default);
2370 formatter.field("semi_token", &self.semi_token);
2371 formatter.finish()
2372 }
2373 }
2374 #[cfg(feature = "full")]
2375 impl Debug for TraitItemMacro {
2376 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2377 let mut formatter = formatter.debug_struct("TraitItemMacro");
2378 formatter.field("attrs", &self.attrs);
2379 formatter.field("mac", &self.mac);
2380 formatter.field("semi_token", &self.semi_token);
2381 formatter.finish()
2382 }
2383 }
2384 #[cfg(feature = "full")]
2385 impl Debug for TraitItemMethod {
2386 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2387 let mut formatter = formatter.debug_struct("TraitItemMethod");
2388 formatter.field("attrs", &self.attrs);
2389 formatter.field("sig", &self.sig);
2390 formatter.field("default", &self.default);
2391 formatter.field("semi_token", &self.semi_token);
2392 formatter.finish()
2393 }
2394 }
2395 #[cfg(feature = "full")]
2396 impl Debug for TraitItemType {
2397 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2398 let mut formatter = formatter.debug_struct("TraitItemType");
2399 formatter.field("attrs", &self.attrs);
2400 formatter.field("type_token", &self.type_token);
2401 formatter.field("ident", &self.ident);
2402 formatter.field("generics", &self.generics);
2403 formatter.field("colon_token", &self.colon_token);
2404 formatter.field("bounds", &self.bounds);
2405 formatter.field("default", &self.default);
2406 formatter.field("semi_token", &self.semi_token);
2407 formatter.finish()
2408 }
2409 }
2410 #[cfg(any(feature = "derive", feature = "full"))]
2411 impl Debug for Type {
2412 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2413 match self {
2414 Type::Array(v0) => {
2415 let mut formatter = formatter.debug_tuple("Array");
2416 formatter.field(v0);
2417 formatter.finish()
2418 }
2419 Type::BareFn(v0) => {
2420 let mut formatter = formatter.debug_tuple("BareFn");
2421 formatter.field(v0);
2422 formatter.finish()
2423 }
2424 Type::Group(v0) => {
2425 let mut formatter = formatter.debug_tuple("Group");
2426 formatter.field(v0);
2427 formatter.finish()
2428 }
2429 Type::ImplTrait(v0) => {
2430 let mut formatter = formatter.debug_tuple("ImplTrait");
2431 formatter.field(v0);
2432 formatter.finish()
2433 }
2434 Type::Infer(v0) => {
2435 let mut formatter = formatter.debug_tuple("Infer");
2436 formatter.field(v0);
2437 formatter.finish()
2438 }
2439 Type::Macro(v0) => {
2440 let mut formatter = formatter.debug_tuple("Macro");
2441 formatter.field(v0);
2442 formatter.finish()
2443 }
2444 Type::Never(v0) => {
2445 let mut formatter = formatter.debug_tuple("Never");
2446 formatter.field(v0);
2447 formatter.finish()
2448 }
2449 Type::Paren(v0) => {
2450 let mut formatter = formatter.debug_tuple("Paren");
2451 formatter.field(v0);
2452 formatter.finish()
2453 }
2454 Type::Path(v0) => {
2455 let mut formatter = formatter.debug_tuple("Path");
2456 formatter.field(v0);
2457 formatter.finish()
2458 }
2459 Type::Ptr(v0) => {
2460 let mut formatter = formatter.debug_tuple("Ptr");
2461 formatter.field(v0);
2462 formatter.finish()
2463 }
2464 Type::Reference(v0) => {
2465 let mut formatter = formatter.debug_tuple("Reference");
2466 formatter.field(v0);
2467 formatter.finish()
2468 }
2469 Type::Slice(v0) => {
2470 let mut formatter = formatter.debug_tuple("Slice");
2471 formatter.field(v0);
2472 formatter.finish()
2473 }
2474 Type::TraitObject(v0) => {
2475 let mut formatter = formatter.debug_tuple("TraitObject");
2476 formatter.field(v0);
2477 formatter.finish()
2478 }
2479 Type::Tuple(v0) => {
2480 let mut formatter = formatter.debug_tuple("Tuple");
2481 formatter.field(v0);
2482 formatter.finish()
2483 }
2484 Type::Verbatim(v0) => {
2485 let mut formatter = formatter.debug_tuple("Verbatim");
2486 formatter.field(v0);
2487 formatter.finish()
2488 }
2489 _ => unreachable!(),
2490 }
2491 }
2492 }
2493 #[cfg(any(feature = "derive", feature = "full"))]
2494 impl Debug for TypeArray {
2495 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2496 let mut formatter = formatter.debug_struct("TypeArray");
2497 formatter.field("bracket_token", &self.bracket_token);
2498 formatter.field("elem", &self.elem);
2499 formatter.field("semi_token", &self.semi_token);
2500 formatter.field("len", &self.len);
2501 formatter.finish()
2502 }
2503 }
2504 #[cfg(any(feature = "derive", feature = "full"))]
2505 impl Debug for TypeBareFn {
2506 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2507 let mut formatter = formatter.debug_struct("TypeBareFn");
2508 formatter.field("lifetimes", &self.lifetimes);
2509 formatter.field("unsafety", &self.unsafety);
2510 formatter.field("abi", &self.abi);
2511 formatter.field("fn_token", &self.fn_token);
2512 formatter.field("paren_token", &self.paren_token);
2513 formatter.field("inputs", &self.inputs);
2514 formatter.field("variadic", &self.variadic);
2515 formatter.field("output", &self.output);
2516 formatter.finish()
2517 }
2518 }
2519 #[cfg(any(feature = "derive", feature = "full"))]
2520 impl Debug for TypeGroup {
2521 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2522 let mut formatter = formatter.debug_struct("TypeGroup");
2523 formatter.field("group_token", &self.group_token);
2524 formatter.field("elem", &self.elem);
2525 formatter.finish()
2526 }
2527 }
2528 #[cfg(any(feature = "derive", feature = "full"))]
2529 impl Debug for TypeImplTrait {
2530 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2531 let mut formatter = formatter.debug_struct("TypeImplTrait");
2532 formatter.field("impl_token", &self.impl_token);
2533 formatter.field("bounds", &self.bounds);
2534 formatter.finish()
2535 }
2536 }
2537 #[cfg(any(feature = "derive", feature = "full"))]
2538 impl Debug for TypeInfer {
2539 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2540 let mut formatter = formatter.debug_struct("TypeInfer");
2541 formatter.field("underscore_token", &self.underscore_token);
2542 formatter.finish()
2543 }
2544 }
2545 #[cfg(any(feature = "derive", feature = "full"))]
2546 impl Debug for TypeMacro {
2547 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2548 let mut formatter = formatter.debug_struct("TypeMacro");
2549 formatter.field("mac", &self.mac);
2550 formatter.finish()
2551 }
2552 }
2553 #[cfg(any(feature = "derive", feature = "full"))]
2554 impl Debug for TypeNever {
2555 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2556 let mut formatter = formatter.debug_struct("TypeNever");
2557 formatter.field("bang_token", &self.bang_token);
2558 formatter.finish()
2559 }
2560 }
2561 #[cfg(any(feature = "derive", feature = "full"))]
2562 impl Debug for TypeParam {
2563 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2564 let mut formatter = formatter.debug_struct("TypeParam");
2565 formatter.field("attrs", &self.attrs);
2566 formatter.field("ident", &self.ident);
2567 formatter.field("colon_token", &self.colon_token);
2568 formatter.field("bounds", &self.bounds);
2569 formatter.field("eq_token", &self.eq_token);
2570 formatter.field("default", &self.default);
2571 formatter.finish()
2572 }
2573 }
2574 #[cfg(any(feature = "derive", feature = "full"))]
2575 impl Debug for TypeParamBound {
2576 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2577 match self {
2578 TypeParamBound::Trait(v0) => {
2579 let mut formatter = formatter.debug_tuple("Trait");
2580 formatter.field(v0);
2581 formatter.finish()
2582 }
2583 TypeParamBound::Lifetime(v0) => {
2584 let mut formatter = formatter.debug_tuple("Lifetime");
2585 formatter.field(v0);
2586 formatter.finish()
2587 }
2588 }
2589 }
2590 }
2591 #[cfg(any(feature = "derive", feature = "full"))]
2592 impl Debug for TypeParen {
2593 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2594 let mut formatter = formatter.debug_struct("TypeParen");
2595 formatter.field("paren_token", &self.paren_token);
2596 formatter.field("elem", &self.elem);
2597 formatter.finish()
2598 }
2599 }
2600 #[cfg(any(feature = "derive", feature = "full"))]
2601 impl Debug for TypePath {
2602 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2603 let mut formatter = formatter.debug_struct("TypePath");
2604 formatter.field("qself", &self.qself);
2605 formatter.field("path", &self.path);
2606 formatter.finish()
2607 }
2608 }
2609 #[cfg(any(feature = "derive", feature = "full"))]
2610 impl Debug for TypePtr {
2611 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2612 let mut formatter = formatter.debug_struct("TypePtr");
2613 formatter.field("star_token", &self.star_token);
2614 formatter.field("const_token", &self.const_token);
2615 formatter.field("mutability", &self.mutability);
2616 formatter.field("elem", &self.elem);
2617 formatter.finish()
2618 }
2619 }
2620 #[cfg(any(feature = "derive", feature = "full"))]
2621 impl Debug for TypeReference {
2622 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2623 let mut formatter = formatter.debug_struct("TypeReference");
2624 formatter.field("and_token", &self.and_token);
2625 formatter.field("lifetime", &self.lifetime);
2626 formatter.field("mutability", &self.mutability);
2627 formatter.field("elem", &self.elem);
2628 formatter.finish()
2629 }
2630 }
2631 #[cfg(any(feature = "derive", feature = "full"))]
2632 impl Debug for TypeSlice {
2633 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2634 let mut formatter = formatter.debug_struct("TypeSlice");
2635 formatter.field("bracket_token", &self.bracket_token);
2636 formatter.field("elem", &self.elem);
2637 formatter.finish()
2638 }
2639 }
2640 #[cfg(any(feature = "derive", feature = "full"))]
2641 impl Debug for TypeTraitObject {
2642 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2643 let mut formatter = formatter.debug_struct("TypeTraitObject");
2644 formatter.field("dyn_token", &self.dyn_token);
2645 formatter.field("bounds", &self.bounds);
2646 formatter.finish()
2647 }
2648 }
2649 #[cfg(any(feature = "derive", feature = "full"))]
2650 impl Debug for TypeTuple {
2651 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2652 let mut formatter = formatter.debug_struct("TypeTuple");
2653 formatter.field("paren_token", &self.paren_token);
2654 formatter.field("elems", &self.elems);
2655 formatter.finish()
2656 }
2657 }
2658 #[cfg(any(feature = "derive", feature = "full"))]
2659 impl Debug for UnOp {
2660 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2661 match self {
2662 UnOp::Deref(v0) => {
2663 let mut formatter = formatter.debug_tuple("Deref");
2664 formatter.field(v0);
2665 formatter.finish()
2666 }
2667 UnOp::Not(v0) => {
2668 let mut formatter = formatter.debug_tuple("Not");
2669 formatter.field(v0);
2670 formatter.finish()
2671 }
2672 UnOp::Neg(v0) => {
2673 let mut formatter = formatter.debug_tuple("Neg");
2674 formatter.field(v0);
2675 formatter.finish()
2676 }
2677 }
2678 }
2679 }
2680 #[cfg(feature = "full")]
2681 impl Debug for UseGlob {
2682 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2683 let mut formatter = formatter.debug_struct("UseGlob");
2684 formatter.field("star_token", &self.star_token);
2685 formatter.finish()
2686 }
2687 }
2688 #[cfg(feature = "full")]
2689 impl Debug for UseGroup {
2690 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2691 let mut formatter = formatter.debug_struct("UseGroup");
2692 formatter.field("brace_token", &self.brace_token);
2693 formatter.field("items", &self.items);
2694 formatter.finish()
2695 }
2696 }
2697 #[cfg(feature = "full")]
2698 impl Debug for UseName {
2699 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2700 let mut formatter = formatter.debug_struct("UseName");
2701 formatter.field("ident", &self.ident);
2702 formatter.finish()
2703 }
2704 }
2705 #[cfg(feature = "full")]
2706 impl Debug for UsePath {
2707 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2708 let mut formatter = formatter.debug_struct("UsePath");
2709 formatter.field("ident", &self.ident);
2710 formatter.field("colon2_token", &self.colon2_token);
2711 formatter.field("tree", &self.tree);
2712 formatter.finish()
2713 }
2714 }
2715 #[cfg(feature = "full")]
2716 impl Debug for UseRename {
2717 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2718 let mut formatter = formatter.debug_struct("UseRename");
2719 formatter.field("ident", &self.ident);
2720 formatter.field("as_token", &self.as_token);
2721 formatter.field("rename", &self.rename);
2722 formatter.finish()
2723 }
2724 }
2725 #[cfg(feature = "full")]
2726 impl Debug for UseTree {
2727 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2728 match self {
2729 UseTree::Path(v0) => {
2730 let mut formatter = formatter.debug_tuple("Path");
2731 formatter.field(v0);
2732 formatter.finish()
2733 }
2734 UseTree::Name(v0) => {
2735 let mut formatter = formatter.debug_tuple("Name");
2736 formatter.field(v0);
2737 formatter.finish()
2738 }
2739 UseTree::Rename(v0) => {
2740 let mut formatter = formatter.debug_tuple("Rename");
2741 formatter.field(v0);
2742 formatter.finish()
2743 }
2744 UseTree::Glob(v0) => {
2745 let mut formatter = formatter.debug_tuple("Glob");
2746 formatter.field(v0);
2747 formatter.finish()
2748 }
2749 UseTree::Group(v0) => {
2750 let mut formatter = formatter.debug_tuple("Group");
2751 formatter.field(v0);
2752 formatter.finish()
2753 }
2754 }
2755 }
2756 }
2757 #[cfg(any(feature = "derive", feature = "full"))]
2758 impl Debug for Variadic {
2759 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2760 let mut formatter = formatter.debug_struct("Variadic");
2761 formatter.field("attrs", &self.attrs);
2762 formatter.field("dots", &self.dots);
2763 formatter.finish()
2764 }
2765 }
2766 #[cfg(any(feature = "derive", feature = "full"))]
2767 impl Debug for Variant {
2768 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2769 let mut formatter = formatter.debug_struct("Variant");
2770 formatter.field("attrs", &self.attrs);
2771 formatter.field("ident", &self.ident);
2772 formatter.field("fields", &self.fields);
2773 formatter.field("discriminant", &self.discriminant);
2774 formatter.finish()
2775 }
2776 }
2777 #[cfg(any(feature = "derive", feature = "full"))]
2778 impl Debug for VisCrate {
2779 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2780 let mut formatter = formatter.debug_struct("VisCrate");
2781 formatter.field("crate_token", &self.crate_token);
2782 formatter.finish()
2783 }
2784 }
2785 #[cfg(any(feature = "derive", feature = "full"))]
2786 impl Debug for VisPublic {
2787 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2788 let mut formatter = formatter.debug_struct("VisPublic");
2789 formatter.field("pub_token", &self.pub_token);
2790 formatter.finish()
2791 }
2792 }
2793 #[cfg(any(feature = "derive", feature = "full"))]
2794 impl Debug for VisRestricted {
2795 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2796 let mut formatter = formatter.debug_struct("VisRestricted");
2797 formatter.field("pub_token", &self.pub_token);
2798 formatter.field("paren_token", &self.paren_token);
2799 formatter.field("in_token", &self.in_token);
2800 formatter.field("path", &self.path);
2801 formatter.finish()
2802 }
2803 }
2804 #[cfg(any(feature = "derive", feature = "full"))]
2805 impl Debug for Visibility {
2806 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2807 match self {
2808 Visibility::Public(v0) => {
2809 let mut formatter = formatter.debug_tuple("Public");
2810 formatter.field(v0);
2811 formatter.finish()
2812 }
2813 Visibility::Crate(v0) => {
2814 let mut formatter = formatter.debug_tuple("Crate");
2815 formatter.field(v0);
2816 formatter.finish()
2817 }
2818 Visibility::Restricted(v0) => {
2819 let mut formatter = formatter.debug_tuple("Restricted");
2820 formatter.field(v0);
2821 formatter.finish()
2822 }
2823 Visibility::Inherited => formatter.write_str("Inherited"),
2824 }
2825 }
2826 }
2827 #[cfg(any(feature = "derive", feature = "full"))]
2828 impl Debug for WhereClause {
2829 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2830 let mut formatter = formatter.debug_struct("WhereClause");
2831 formatter.field("where_token", &self.where_token);
2832 formatter.field("predicates", &self.predicates);
2833 formatter.finish()
2834 }
2835 }
2836 #[cfg(any(feature = "derive", feature = "full"))]
2837 impl Debug for WherePredicate {
2838 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2839 match self {
2840 WherePredicate::Type(v0) => {
2841 let mut formatter = formatter.debug_tuple("Type");
2842 formatter.field(v0);
2843 formatter.finish()
2844 }
2845 WherePredicate::Lifetime(v0) => {
2846 let mut formatter = formatter.debug_tuple("Lifetime");
2847 formatter.field(v0);
2848 formatter.finish()
2849 }
2850 WherePredicate::Eq(v0) => {
2851 let mut formatter = formatter.debug_tuple("Eq");
2852 formatter.field(v0);
2853 formatter.finish()
2854 }
2855 }
2856 }
2857 }