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