CoCalc -- debug.rs

GitHub Repository: torvalds/linux
Path: blob/master/rust/syn/gen/debug.rs
³⁸³¹⁶ views
1
// SPDX-License-Identifier: Apache-2.0 OR MIT
2

3
// This file is @generated by syn-internal-codegen.
4
// It is not intended for manual editing.
5

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

3242
Product

Resources

Company
