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