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