Debian Codegraph @

rust/syn/gen/debug.rs

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