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