Debian Codegraph @

.cargo/vendor/syn-1.0.109/src/gen/debug.rs

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