1use crate::*;
5use std::fmt::{self, Debug};
6#[cfg(any(feature = "derive", feature = "full"))]
7#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
8impl 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")))]
18impl 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")))]
30impl 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")))]
44impl 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")))]
58impl 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")))]
71impl 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")))]
82impl 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")))]
230impl 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")))]
241impl 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")))]
251impl 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")))]
263impl 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")))]
278impl 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")))]
289impl 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")))]
312impl 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")))]
323impl 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")))]
334impl 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")))]
344impl 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")))]
357impl 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")))]
597impl 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")))]
608impl 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")))]
620impl 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")))]
632impl 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")))]
644impl 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")))]
656impl 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")))]
668impl 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")))]
679impl 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")))]
690impl 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")))]
702impl 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")))]
714impl 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")))]
726impl 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")))]
743impl 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")))]
754impl 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")))]
766impl 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")))]
781impl 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")))]
792impl 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")))]
805impl 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")))]
817impl 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")))]
830impl 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")))]
840impl 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")))]
852impl 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")))]
862impl 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")))]
875impl 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")))]
890impl 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")))]
901impl 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")))]
912impl 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")))]
924impl 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")))]
937impl 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")))]
950impl 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")))]
961impl 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")))]
975impl 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")))]
986impl 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")))]
997impl 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")))]
1008impl 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")))]
1020impl 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")))]
1031impl 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")))]
1042impl 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")))]
1055impl 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")))]
1066impl 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")))]
1079impl 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")))]
1091impl 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")))]
1103impl 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")))]
1122impl 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")))]
1132impl 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")))]
1142impl 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")))]
1153impl 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")))]
1171impl 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")))]
1206impl 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")))]
1218impl 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")))]
1229impl 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")))]
1245impl 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")))]
1258impl 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")))]
1291impl 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")))]
1309impl 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")))]
1332impl 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")))]
1344impl 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")))]
1379impl 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")))]
1397impl 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")))]
1408impl 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")))]
1421impl 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")))]
1438impl 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")))]
1448impl 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")))]
1543impl 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")))]
1560impl 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")))]
1575impl 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")))]
1590impl 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")))]
1602impl 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")))]
1614impl 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")))]
1631impl 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")))]
1643impl 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")))]
1656impl 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")))]
1670impl 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")))]
1688impl 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")))]
1703impl 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")))]
1722impl 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")))]
1738impl 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")))]
1754impl 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")))]
1768impl 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")))]
1782impl 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")))]
1791impl 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")))]
1801impl 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")))]
1812impl 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")))]
1860impl 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")))]
1873impl 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")))]
1885impl 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")))]
1908impl 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")))]
1926impl 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")))]
1949impl 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")))]
1960impl 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")))]
1971impl 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")))]
1983impl 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")))]
2001impl 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")))]
2012impl 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")))]
2102impl 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")))]
2113impl 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")))]
2126impl 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")))]
2136impl 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")))]
2146impl 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")))]
2157impl 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")))]
2168impl 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")))]
2180impl 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")))]
2192impl 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")))]
2202impl 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")))]
2213impl 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")))]
2226impl 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")))]
2237impl 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")))]
2248impl 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")))]
2260impl 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")))]
2270impl 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")))]
2280impl 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")))]
2299impl 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")))]
2309impl 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")))]
2320impl 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")))]
2331impl 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")))]
2343impl 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")))]
2356impl 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")))]
2374impl 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")))]
2386impl 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")))]
2401impl 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")))]
2420impl 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")))]
2449impl 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")))]
2461impl 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")))]
2475impl 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")))]
2510impl 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")))]
2525impl 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")))]
2536impl 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")))]
2548impl 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")))]
2564impl 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")))]
2649impl 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")))]
2661impl 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")))]
2677impl 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")))]
2687impl 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")))]
2697impl 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")))]
2706impl 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")))]
2715impl 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")))]
2724impl 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")))]
2738impl 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")))]
2756impl 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")))]
2766impl 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")))]
2776impl 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")))]
2788impl 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")))]
2800impl 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")))]
2810impl 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")))]
2820impl 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")))]
2830impl 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")))]
2853impl 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")))]
2862impl 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")))]
2872impl 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")))]
2881impl 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")))]
2892impl 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")))]
2903impl 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")))]
2936impl 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")))]
2946impl 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")))]
2958impl 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")))]
2967impl 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")))]
2976impl 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")))]
2988impl 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")))]
3012impl 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")))]
3022impl 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}