projects/linux·blob master · refs

3240 lines · 124.4 KiB

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)]
7use std::fmt::{self, Debug};
8#[cfg(any(feature = "derive", feature = "full"))]
9#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
10impl 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")))]
20impl 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"))]
26impl 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")))]
38impl 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")))]
52impl 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")))]
64impl 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")))]
76impl 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")))]
91impl 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")))]
103impl 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")))]
114impl 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")))]
126impl 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")))]
275impl 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")))]
285impl 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")))]
297impl 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")))]
316impl 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")))]
331impl 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")))]
343impl 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")))]
355impl 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")]
361impl 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")))]
372impl 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")]
378impl 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")))]
389impl 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")]
395impl 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")))]
405impl 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")))]
418impl 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")))]
497impl 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")]
503impl 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")))]
514impl 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")]
520impl 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")))]
532impl 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")]
538impl 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")))]
550impl 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")]
556impl 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")))]
568impl 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"))]
574impl 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")))]
586impl 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")]
592impl 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")))]
603impl 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")]
609impl 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")))]
621impl 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"))]
627impl 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")))]
639impl 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"))]
645impl 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")))]
657impl 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")]
663impl 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")))]
682impl 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")]
688impl 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")))]
699impl Debug for crate::ExprContinue {
700 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
701 self.debug(formatter, "ExprContinue")
702 }
703}
704#[cfg(feature = "full")]
705impl crate::ExprContinue {
706 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
707 let mut formatter = formatter.debug_struct(name);
708 formatter.field("attrs", &self.attrs);
709 formatter.field("continue_token", &self.continue_token);
710 formatter.field("label", &self.label);
711 formatter.finish()
712 }
713}
714#[cfg(any(feature = "derive", feature = "full"))]
715#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
716impl Debug for crate::ExprField {
717 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
718 self.debug(formatter, "ExprField")
719 }
720}
721#[cfg(any(feature = "derive", feature = "full"))]
722impl crate::ExprField {
723 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
724 let mut formatter = formatter.debug_struct(name);
725 formatter.field("attrs", &self.attrs);
726 formatter.field("base", &self.base);
727 formatter.field("dot_token", &self.dot_token);
728 formatter.field("member", &self.member);
729 formatter.finish()
730 }
731}
732#[cfg(feature = "full")]
733#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
734impl Debug for crate::ExprForLoop {
735 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
736 self.debug(formatter, "ExprForLoop")
737 }
738}
739#[cfg(feature = "full")]
740impl crate::ExprForLoop {
741 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
742 let mut formatter = formatter.debug_struct(name);
743 formatter.field("attrs", &self.attrs);
744 formatter.field("label", &self.label);
745 formatter.field("for_token", &self.for_token);
746 formatter.field("pat", &self.pat);
747 formatter.field("in_token", &self.in_token);
748 formatter.field("expr", &self.expr);
749 formatter.field("body", &self.body);
750 formatter.finish()
751 }
752}
753#[cfg(any(feature = "derive", feature = "full"))]
754#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
755impl Debug for crate::ExprGroup {
756 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
757 self.debug(formatter, "ExprGroup")
758 }
759}
760#[cfg(any(feature = "derive", feature = "full"))]
761impl crate::ExprGroup {
762 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
763 let mut formatter = formatter.debug_struct(name);
764 formatter.field("attrs", &self.attrs);
765 formatter.field("group_token", &self.group_token);
766 formatter.field("expr", &self.expr);
767 formatter.finish()
768 }
769}
770#[cfg(feature = "full")]
771#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
772impl Debug for crate::ExprIf {
773 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
774 self.debug(formatter, "ExprIf")
775 }
776}
777#[cfg(feature = "full")]
778impl crate::ExprIf {
779 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
780 let mut formatter = formatter.debug_struct(name);
781 formatter.field("attrs", &self.attrs);
782 formatter.field("if_token", &self.if_token);
783 formatter.field("cond", &self.cond);
784 formatter.field("then_branch", &self.then_branch);
785 formatter.field("else_branch", &self.else_branch);
786 formatter.finish()
787 }
788}
789#[cfg(any(feature = "derive", feature = "full"))]
790#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
791impl Debug for crate::ExprIndex {
792 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
793 self.debug(formatter, "ExprIndex")
794 }
795}
796#[cfg(any(feature = "derive", feature = "full"))]
797impl crate::ExprIndex {
798 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
799 let mut formatter = formatter.debug_struct(name);
800 formatter.field("attrs", &self.attrs);
801 formatter.field("expr", &self.expr);
802 formatter.field("bracket_token", &self.bracket_token);
803 formatter.field("index", &self.index);
804 formatter.finish()
805 }
806}
807#[cfg(feature = "full")]
808#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
809impl Debug for crate::ExprInfer {
810 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
811 self.debug(formatter, "ExprInfer")
812 }
813}
814#[cfg(feature = "full")]
815impl crate::ExprInfer {
816 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
817 let mut formatter = formatter.debug_struct(name);
818 formatter.field("attrs", &self.attrs);
819 formatter.field("underscore_token", &self.underscore_token);
820 formatter.finish()
821 }
822}
823#[cfg(feature = "full")]
824#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
825impl Debug for crate::ExprLet {
826 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
827 self.debug(formatter, "ExprLet")
828 }
829}
830#[cfg(feature = "full")]
831impl crate::ExprLet {
832 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
833 let mut formatter = formatter.debug_struct(name);
834 formatter.field("attrs", &self.attrs);
835 formatter.field("let_token", &self.let_token);
836 formatter.field("pat", &self.pat);
837 formatter.field("eq_token", &self.eq_token);
838 formatter.field("expr", &self.expr);
839 formatter.finish()
840 }
841}
842#[cfg(any(feature = "derive", feature = "full"))]
843#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
844impl Debug for crate::ExprLit {
845 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
846 self.debug(formatter, "ExprLit")
847 }
848}
849#[cfg(any(feature = "derive", feature = "full"))]
850impl crate::ExprLit {
851 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
852 let mut formatter = formatter.debug_struct(name);
853 formatter.field("attrs", &self.attrs);
854 formatter.field("lit", &self.lit);
855 formatter.finish()
856 }
857}
858#[cfg(feature = "full")]
859#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
860impl Debug for crate::ExprLoop {
861 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
862 self.debug(formatter, "ExprLoop")
863 }
864}
865#[cfg(feature = "full")]
866impl crate::ExprLoop {
867 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
868 let mut formatter = formatter.debug_struct(name);
869 formatter.field("attrs", &self.attrs);
870 formatter.field("label", &self.label);
871 formatter.field("loop_token", &self.loop_token);
872 formatter.field("body", &self.body);
873 formatter.finish()
874 }
875}
876#[cfg(any(feature = "derive", feature = "full"))]
877#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
878impl Debug for crate::ExprMacro {
879 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
880 self.debug(formatter, "ExprMacro")
881 }
882}
883#[cfg(any(feature = "derive", feature = "full"))]
884impl crate::ExprMacro {
885 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
886 let mut formatter = formatter.debug_struct(name);
887 formatter.field("attrs", &self.attrs);
888 formatter.field("mac", &self.mac);
889 formatter.finish()
890 }
891}
892#[cfg(feature = "full")]
893#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
894impl Debug for crate::ExprMatch {
895 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
896 self.debug(formatter, "ExprMatch")
897 }
898}
899#[cfg(feature = "full")]
900impl crate::ExprMatch {
901 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
902 let mut formatter = formatter.debug_struct(name);
903 formatter.field("attrs", &self.attrs);
904 formatter.field("match_token", &self.match_token);
905 formatter.field("expr", &self.expr);
906 formatter.field("brace_token", &self.brace_token);
907 formatter.field("arms", &self.arms);
908 formatter.finish()
909 }
910}
911#[cfg(any(feature = "derive", feature = "full"))]
912#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
913impl Debug for crate::ExprMethodCall {
914 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
915 self.debug(formatter, "ExprMethodCall")
916 }
917}
918#[cfg(any(feature = "derive", feature = "full"))]
919impl crate::ExprMethodCall {
920 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
921 let mut formatter = formatter.debug_struct(name);
922 formatter.field("attrs", &self.attrs);
923 formatter.field("receiver", &self.receiver);
924 formatter.field("dot_token", &self.dot_token);
925 formatter.field("method", &self.method);
926 formatter.field("turbofish", &self.turbofish);
927 formatter.field("paren_token", &self.paren_token);
928 formatter.field("args", &self.args);
929 formatter.finish()
930 }
931}
932#[cfg(any(feature = "derive", feature = "full"))]
933#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
934impl Debug for crate::ExprParen {
935 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
936 self.debug(formatter, "ExprParen")
937 }
938}
939#[cfg(any(feature = "derive", feature = "full"))]
940impl crate::ExprParen {
941 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
942 let mut formatter = formatter.debug_struct(name);
943 formatter.field("attrs", &self.attrs);
944 formatter.field("paren_token", &self.paren_token);
945 formatter.field("expr", &self.expr);
946 formatter.finish()
947 }
948}
949#[cfg(any(feature = "derive", feature = "full"))]
950#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
951impl Debug for crate::ExprPath {
952 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
953 self.debug(formatter, "ExprPath")
954 }
955}
956#[cfg(any(feature = "derive", feature = "full"))]
957impl crate::ExprPath {
958 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
959 let mut formatter = formatter.debug_struct(name);
960 formatter.field("attrs", &self.attrs);
961 formatter.field("qself", &self.qself);
962 formatter.field("path", &self.path);
963 formatter.finish()
964 }
965}
966#[cfg(feature = "full")]
967#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
968impl Debug for crate::ExprRange {
969 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
970 self.debug(formatter, "ExprRange")
971 }
972}
973#[cfg(feature = "full")]
974impl crate::ExprRange {
975 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
976 let mut formatter = formatter.debug_struct(name);
977 formatter.field("attrs", &self.attrs);
978 formatter.field("start", &self.start);
979 formatter.field("limits", &self.limits);
980 formatter.field("end", &self.end);
981 formatter.finish()
982 }
983}
984#[cfg(feature = "full")]
985#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
986impl Debug for crate::ExprRawAddr {
987 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
988 self.debug(formatter, "ExprRawAddr")
989 }
990}
991#[cfg(feature = "full")]
992impl crate::ExprRawAddr {
993 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
994 let mut formatter = formatter.debug_struct(name);
995 formatter.field("attrs", &self.attrs);
996 formatter.field("and_token", &self.and_token);
997 formatter.field("raw", &self.raw);
998 formatter.field("mutability", &self.mutability);
999 formatter.field("expr", &self.expr);
1000 formatter.finish()
1001 }
1002}
1003#[cfg(any(feature = "derive", feature = "full"))]
1004#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1005impl Debug for crate::ExprReference {
1006 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1007 self.debug(formatter, "ExprReference")
1008 }
1009}
1010#[cfg(any(feature = "derive", feature = "full"))]
1011impl crate::ExprReference {
1012 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
1013 let mut formatter = formatter.debug_struct(name);
1014 formatter.field("attrs", &self.attrs);
1015 formatter.field("and_token", &self.and_token);
1016 formatter.field("mutability", &self.mutability);
1017 formatter.field("expr", &self.expr);
1018 formatter.finish()
1019 }
1020}
1021#[cfg(feature = "full")]
1022#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1023impl Debug for crate::ExprRepeat {
1024 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1025 self.debug(formatter, "ExprRepeat")
1026 }
1027}
1028#[cfg(feature = "full")]
1029impl crate::ExprRepeat {
1030 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
1031 let mut formatter = formatter.debug_struct(name);
1032 formatter.field("attrs", &self.attrs);
1033 formatter.field("bracket_token", &self.bracket_token);
1034 formatter.field("expr", &self.expr);
1035 formatter.field("semi_token", &self.semi_token);
1036 formatter.field("len", &self.len);
1037 formatter.finish()
1038 }
1039}
1040#[cfg(feature = "full")]
1041#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1042impl Debug for crate::ExprReturn {
1043 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1044 self.debug(formatter, "ExprReturn")
1045 }
1046}
1047#[cfg(feature = "full")]
1048impl crate::ExprReturn {
1049 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
1050 let mut formatter = formatter.debug_struct(name);
1051 formatter.field("attrs", &self.attrs);
1052 formatter.field("return_token", &self.return_token);
1053 formatter.field("expr", &self.expr);
1054 formatter.finish()
1055 }
1056}
1057#[cfg(any(feature = "derive", feature = "full"))]
1058#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1059impl Debug for crate::ExprStruct {
1060 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1061 self.debug(formatter, "ExprStruct")
1062 }
1063}
1064#[cfg(any(feature = "derive", feature = "full"))]
1065impl crate::ExprStruct {
1066 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
1067 let mut formatter = formatter.debug_struct(name);
1068 formatter.field("attrs", &self.attrs);
1069 formatter.field("qself", &self.qself);
1070 formatter.field("path", &self.path);
1071 formatter.field("brace_token", &self.brace_token);
1072 formatter.field("fields", &self.fields);
1073 formatter.field("dot2_token", &self.dot2_token);
1074 formatter.field("rest", &self.rest);
1075 formatter.finish()
1076 }
1077}
1078#[cfg(feature = "full")]
1079#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1080impl Debug for crate::ExprTry {
1081 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1082 self.debug(formatter, "ExprTry")
1083 }
1084}
1085#[cfg(feature = "full")]
1086impl crate::ExprTry {
1087 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
1088 let mut formatter = formatter.debug_struct(name);
1089 formatter.field("attrs", &self.attrs);
1090 formatter.field("expr", &self.expr);
1091 formatter.field("question_token", &self.question_token);
1092 formatter.finish()
1093 }
1094}
1095#[cfg(feature = "full")]
1096#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1097impl Debug for crate::ExprTryBlock {
1098 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1099 self.debug(formatter, "ExprTryBlock")
1100 }
1101}
1102#[cfg(feature = "full")]
1103impl crate::ExprTryBlock {
1104 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
1105 let mut formatter = formatter.debug_struct(name);
1106 formatter.field("attrs", &self.attrs);
1107 formatter.field("try_token", &self.try_token);
1108 formatter.field("block", &self.block);
1109 formatter.finish()
1110 }
1111}
1112#[cfg(any(feature = "derive", feature = "full"))]
1113#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1114impl 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"))]
1120impl 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")))]
1131impl 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"))]
1137impl 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")))]
1148impl 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")]
1154impl 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")))]
1165impl 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")]
1171impl 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")))]
1184impl 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")]
1190impl 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")))]
1201impl 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")))]
1215impl 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")))]
1225impl Debug for crate::FieldPat {
1226 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1227 let mut formatter = formatter.debug_struct("FieldPat");
1228 formatter.field("attrs", &self.attrs);
1229 formatter.field("member", &self.member);
1230 formatter.field("colon_token", &self.colon_token);
1231 formatter.field("pat", &self.pat);
1232 formatter.finish()
1233 }
1234}
1235#[cfg(any(feature = "derive", feature = "full"))]
1236#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1237impl Debug for crate::FieldValue {
1238 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1239 let mut formatter = formatter.debug_struct("FieldValue");
1240 formatter.field("attrs", &self.attrs);
1241 formatter.field("member", &self.member);
1242 formatter.field("colon_token", &self.colon_token);
1243 formatter.field("expr", &self.expr);
1244 formatter.finish()
1245 }
1246}
1247#[cfg(any(feature = "derive", feature = "full"))]
1248#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1249impl Debug for crate::Fields {
1250 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1251 formatter.write_str("Fields::")?;
1252 match self {
1253 crate::Fields::Named(v0) => v0.debug(formatter, "Named"),
1254 crate::Fields::Unnamed(v0) => v0.debug(formatter, "Unnamed"),
1255 crate::Fields::Unit => formatter.write_str("Unit"),
1256 }
1257 }
1258}
1259#[cfg(any(feature = "derive", feature = "full"))]
1260#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1261impl Debug for crate::FieldsNamed {
1262 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1263 self.debug(formatter, "FieldsNamed")
1264 }
1265}
1266#[cfg(any(feature = "derive", feature = "full"))]
1267impl crate::FieldsNamed {
1268 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
1269 let mut formatter = formatter.debug_struct(name);
1270 formatter.field("brace_token", &self.brace_token);
1271 formatter.field("named", &self.named);
1272 formatter.finish()
1273 }
1274}
1275#[cfg(any(feature = "derive", feature = "full"))]
1276#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1277impl Debug for crate::FieldsUnnamed {
1278 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1279 self.debug(formatter, "FieldsUnnamed")
1280 }
1281}
1282#[cfg(any(feature = "derive", feature = "full"))]
1283impl crate::FieldsUnnamed {
1284 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
1285 let mut formatter = formatter.debug_struct(name);
1286 formatter.field("paren_token", &self.paren_token);
1287 formatter.field("unnamed", &self.unnamed);
1288 formatter.finish()
1289 }
1290}
1291#[cfg(feature = "full")]
1292#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1293impl Debug for crate::File {
1294 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1295 let mut formatter = formatter.debug_struct("File");
1296 formatter.field("shebang", &self.shebang);
1297 formatter.field("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")))]
1304impl 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")))]
1323impl 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")))]
1341impl 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")]
1347impl 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")))]
1359impl 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")]
1365impl 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")))]
1376impl 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")]
1382impl 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")))]
1398impl 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")]
1404impl 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")))]
1418impl 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")))]
1457impl 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")))]
1481impl 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")))]
1493impl 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")))]
1511impl 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")]
1517impl 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")))]
1536impl 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")]
1542impl 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")))]
1555impl 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")]
1561impl 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")))]
1572impl 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")]
1578impl 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")))]
1595impl 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")))]
1602impl 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")))]
1612impl 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")))]
1641impl 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")]
1647impl 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")))]
1665impl 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")]
1671impl 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")))]
1686impl 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")]
1692impl 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")))]
1707impl 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")]
1713impl 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")))]
1725impl 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")]
1731impl 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")))]
1744impl 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")]
1750impl 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")))]
1767impl 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")]
1773impl 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")))]
1785impl 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")]
1791impl 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")))]
1806impl 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")]
1812impl 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")))]
1830impl 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")]
1836impl 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")))]
1851impl 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")]
1857impl 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")))]
1877impl 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")]
1883impl 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")))]
1899impl 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")]
1905impl 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")))]
1921impl 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")]
1927impl 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")))]
1941impl 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")]
1947impl 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")))]
1961impl 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")))]
1970impl Debug for crate::Lifetime {
1971 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1972 self.debug(formatter, "Lifetime")
1973 }
1974}
1975impl 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")))]
1985impl 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")))]
1996impl 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")))]
2018impl 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")]
2024impl 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")))]
2037impl 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")))]
2048impl 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")))]
2060impl 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")))]
2084impl 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")))]
2103impl 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")))]
2115impl 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"))]
2121impl 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")))]
2132impl 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"))]
2138impl 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")))]
2149impl 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"))]
2155impl 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")))]
2166impl 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")))]
2196impl 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")]
2202impl 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")))]
2215impl 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")]
2221impl 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")))]
2232impl 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")]
2238impl 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")))]
2249impl 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")]
2255impl 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")))]
2267impl 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")]
2273impl 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")))]
2283impl 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")]
2289impl 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")))]
2300impl 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")]
2306impl 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")))]
2320impl 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")]
2326impl 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")))]
2337impl 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")]
2343impl 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")))]
2356impl 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")]
2362impl 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")))]
2374impl 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")]
2380impl 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")))]
2390impl 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"))]
2396impl 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")))]
2406impl 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")))]
2422impl 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")))]
2432impl 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")))]
2451impl 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")))]
2463impl 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")))]
2474impl 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")))]
2486impl 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")))]
2499impl 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")))]
2518impl 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")))]
2532impl 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")))]
2548impl 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")))]
2567impl 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")))]
2582impl 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")))]
2604impl 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")]
2610impl 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")))]
2621impl 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")))]
2633impl 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")))]
2648impl 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")))]
2666impl 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")]
2672impl 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")))]
2688impl 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")]
2694impl 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")))]
2706impl 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")]
2712impl 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")))]
2723impl 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")]
2729impl 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")))]
2745impl 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")))]
2773impl 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"))]
2779impl 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")))]
2791impl 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"))]
2797impl 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")))]
2813impl 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"))]
2819impl 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")))]
2829impl 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"))]
2835impl 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")))]
2845impl 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"))]
2851impl 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")))]
2860impl 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"))]
2866impl 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")))]
2875impl 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"))]
2881impl 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")))]
2890impl 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")))]
2904impl 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")))]
2932impl 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"))]
2938impl 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")))]
2948impl 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"))]
2954impl 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")))]
2964impl 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"))]
2970impl 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")))]
2982impl 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"))]
2988impl 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")))]
3000impl 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"))]
3006impl 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")))]
3016impl 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"))]
3022impl 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")))]
3032impl 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"))]
3038impl 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")))]
3048impl 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")))]
3072impl 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")))]
3081impl 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")))]
3091impl 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")))]
3100impl 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")))]
3111impl 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")))]
3122impl 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")))]
3156impl 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")))]
3168impl 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")))]
3180impl 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"))]
3186impl 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")))]
3198impl 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")))]
3214impl 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")))]
3224impl 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}