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