syn/gen/
debug.rs

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

syn/gen/
debug.rs
