Debian Codegraph @

third_party/rust/syn/src/gen/debug.rs

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