Lines Matching refs:formatter
9 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
10 let mut formatter = formatter.debug_struct("Abi");
11 formatter.field("extern_token", &self.extern_token);
12 formatter.field("name", &self.name);
13 formatter.finish()
19 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
21 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
22 let mut formatter = formatter.debug_struct(name);
23 formatter.field("colon2_token", &self.colon2_token);
24 formatter.field("lt_token", &self.lt_token);
25 formatter.field("args", &self.args);
26 formatter.field("gt_token", &self.gt_token);
27 formatter.finish()
30 self.debug(formatter, "AngleBracketedGenericArguments")
36 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
37 let mut formatter = formatter.debug_struct("Arm");
38 formatter.field("attrs", &self.attrs);
39 formatter.field("pat", &self.pat);
40 formatter.field("guard", &self.guard);
41 formatter.field("fat_arrow_token", &self.fat_arrow_token);
42 formatter.field("body", &self.body);
43 formatter.field("comma", &self.comma);
44 formatter.finish()
50 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
51 let mut formatter = formatter.debug_struct("AssocConst");
52 formatter.field("ident", &self.ident);
53 formatter.field("generics", &self.generics);
54 formatter.field("eq_token", &self.eq_token);
55 formatter.field("value", &self.value);
56 formatter.finish()
62 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
63 let mut formatter = formatter.debug_struct("AssocType");
64 formatter.field("ident", &self.ident);
65 formatter.field("generics", &self.generics);
66 formatter.field("eq_token", &self.eq_token);
67 formatter.field("ty", &self.ty);
68 formatter.finish()
74 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
75 formatter.write_str("AttrStyle::")?;
77 AttrStyle::Outer => formatter.write_str("Outer"),
79 let mut formatter = formatter.debug_tuple("Inner");
80 formatter.field(v0);
81 formatter.finish()
89 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
90 let mut formatter = formatter.debug_struct("Attribute");
91 formatter.field("pound_token", &self.pound_token);
92 formatter.field("style", &self.style);
93 formatter.field("bracket_token", &self.bracket_token);
94 formatter.field("meta", &self.meta);
95 formatter.finish()
101 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
102 let mut formatter = formatter.debug_struct("BareFnArg");
103 formatter.field("attrs", &self.attrs);
104 formatter.field("name", &self.name);
105 formatter.field("ty", &self.ty);
106 formatter.finish()
112 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
113 let mut formatter = formatter.debug_struct("BareVariadic");
114 formatter.field("attrs", &self.attrs);
115 formatter.field("name", &self.name);
116 formatter.field("dots", &self.dots);
117 formatter.field("comma", &self.comma);
118 formatter.finish()
124 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
125 formatter.write_str("BinOp::")?;
128 let mut formatter = formatter.debug_tuple("Add");
129 formatter.field(v0);
130 formatter.finish()
133 let mut formatter = formatter.debug_tuple("Sub");
134 formatter.field(v0);
135 formatter.finish()
138 let mut formatter = formatter.debug_tuple("Mul");
139 formatter.field(v0);
140 formatter.finish()
143 let mut formatter = formatter.debug_tuple("Div");
144 formatter.field(v0);
145 formatter.finish()
148 let mut formatter = formatter.debug_tuple("Rem");
149 formatter.field(v0);
150 formatter.finish()
153 let mut formatter = formatter.debug_tuple("And");
154 formatter.field(v0);
155 formatter.finish()
158 let mut formatter = formatter.debug_tuple("Or");
159 formatter.field(v0);
160 formatter.finish()
163 let mut formatter = formatter.debug_tuple("BitXor");
164 formatter.field(v0);
165 formatter.finish()
168 let mut formatter = formatter.debug_tuple("BitAnd");
169 formatter.field(v0);
170 formatter.finish()
173 let mut formatter = formatter.debug_tuple("BitOr");
174 formatter.field(v0);
175 formatter.finish()
178 let mut formatter = formatter.debug_tuple("Shl");
179 formatter.field(v0);
180 formatter.finish()
183 let mut formatter = formatter.debug_tuple("Shr");
184 formatter.field(v0);
185 formatter.finish()
188 let mut formatter = formatter.debug_tuple("Eq");
189 formatter.field(v0);
190 formatter.finish()
193 let mut formatter = formatter.debug_tuple("Lt");
194 formatter.field(v0);
195 formatter.finish()
198 let mut formatter = formatter.debug_tuple("Le");
199 formatter.field(v0);
200 formatter.finish()
203 let mut formatter = formatter.debug_tuple("Ne");
204 formatter.field(v0);
205 formatter.finish()
208 let mut formatter = formatter.debug_tuple("Ge");
209 formatter.field(v0);
210 formatter.finish()
213 let mut formatter = formatter.debug_tuple("Gt");
214 formatter.field(v0);
215 formatter.finish()
218 let mut formatter = formatter.debug_tuple("AddAssign");
219 formatter.field(v0);
220 formatter.finish()
223 let mut formatter = formatter.debug_tuple("SubAssign");
224 formatter.field(v0);
225 formatter.finish()
228 let mut formatter = formatter.debug_tuple("MulAssign");
229 formatter.field(v0);
230 formatter.finish()
233 let mut formatter = formatter.debug_tuple("DivAssign");
234 formatter.field(v0);
235 formatter.finish()
238 let mut formatter = formatter.debug_tuple("RemAssign");
239 formatter.field(v0);
240 formatter.finish()
243 let mut formatter = formatter.debug_tuple("BitXorAssign");
244 formatter.field(v0);
245 formatter.finish()
248 let mut formatter = formatter.debug_tuple("BitAndAssign");
249 formatter.field(v0);
250 formatter.finish()
253 let mut formatter = formatter.debug_tuple("BitOrAssign");
254 formatter.field(v0);
255 formatter.finish()
258 let mut formatter = formatter.debug_tuple("ShlAssign");
259 formatter.field(v0);
260 formatter.finish()
263 let mut formatter = formatter.debug_tuple("ShrAssign");
264 formatter.field(v0);
265 formatter.finish()
273 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
274 let mut formatter = formatter.debug_struct("Block");
275 formatter.field("brace_token", &self.brace_token);
276 formatter.field("stmts", &self.stmts);
277 formatter.finish()
283 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
284 let mut formatter = formatter.debug_struct("BoundLifetimes");
285 formatter.field("for_token", &self.for_token);
286 formatter.field("lt_token", &self.lt_token);
287 formatter.field("lifetimes", &self.lifetimes);
288 formatter.field("gt_token", &self.gt_token);
289 formatter.finish()
295 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
296 let mut formatter = formatter.debug_struct("ConstParam");
297 formatter.field("attrs", &self.attrs);
298 formatter.field("const_token", &self.const_token);
299 formatter.field("ident", &self.ident);
300 formatter.field("colon_token", &self.colon_token);
301 formatter.field("ty", &self.ty);
302 formatter.field("eq_token", &self.eq_token);
303 formatter.field("default", &self.default);
304 formatter.finish()
310 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
311 let mut formatter = formatter.debug_struct("Constraint");
312 formatter.field("ident", &self.ident);
313 formatter.field("generics", &self.generics);
314 formatter.field("colon_token", &self.colon_token);
315 formatter.field("bounds", &self.bounds);
316 formatter.finish()
322 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
323 formatter.write_str("Data::")?;
325 Data::Struct(v0) => v0.debug(formatter, "Struct"),
326 Data::Enum(v0) => v0.debug(formatter, "Enum"),
327 Data::Union(v0) => v0.debug(formatter, "Union"),
334 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
336 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
337 let mut formatter = formatter.debug_struct(name);
338 formatter.field("enum_token", &self.enum_token);
339 formatter.field("brace_token", &self.brace_token);
340 formatter.field("variants", &self.variants);
341 formatter.finish()
344 self.debug(formatter, "DataEnum")
350 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
352 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
353 let mut formatter = formatter.debug_struct(name);
354 formatter.field("struct_token", &self.struct_token);
355 formatter.field("fields", &self.fields);
356 formatter.field("semi_token", &self.semi_token);
357 formatter.finish()
360 self.debug(formatter, "DataStruct")
366 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
368 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
369 let mut formatter = formatter.debug_struct(name);
370 formatter.field("union_token", &self.union_token);
371 formatter.field("fields", &self.fields);
372 formatter.finish()
375 self.debug(formatter, "DataUnion")
381 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
382 let mut formatter = formatter.debug_struct("DeriveInput");
383 formatter.field("attrs", &self.attrs);
384 formatter.field("vis", &self.vis);
385 formatter.field("ident", &self.ident);
386 formatter.field("generics", &self.generics);
387 formatter.field("data", &self.data);
388 formatter.finish()
394 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
395 formatter.write_str("Expr::")?;
398 Expr::Array(v0) => v0.debug(formatter, "Array"),
400 Expr::Assign(v0) => v0.debug(formatter, "Assign"),
402 Expr::Async(v0) => v0.debug(formatter, "Async"),
404 Expr::Await(v0) => v0.debug(formatter, "Await"),
405 Expr::Binary(v0) => v0.debug(formatter, "Binary"),
407 Expr::Block(v0) => v0.debug(formatter, "Block"),
409 Expr::Break(v0) => v0.debug(formatter, "Break"),
410 Expr::Call(v0) => v0.debug(formatter, "Call"),
411 Expr::Cast(v0) => v0.debug(formatter, "Cast"),
413 Expr::Closure(v0) => v0.debug(formatter, "Closure"),
415 Expr::Const(v0) => v0.debug(formatter, "Const"),
417 Expr::Continue(v0) => v0.debug(formatter, "Continue"),
418 Expr::Field(v0) => v0.debug(formatter, "Field"),
420 Expr::ForLoop(v0) => v0.debug(formatter, "ForLoop"),
421 Expr::Group(v0) => v0.debug(formatter, "Group"),
423 Expr::If(v0) => v0.debug(formatter, "If"),
424 Expr::Index(v0) => v0.debug(formatter, "Index"),
426 Expr::Infer(v0) => v0.debug(formatter, "Infer"),
428 Expr::Let(v0) => v0.debug(formatter, "Let"),
429 Expr::Lit(v0) => v0.debug(formatter, "Lit"),
431 Expr::Loop(v0) => v0.debug(formatter, "Loop"),
432 Expr::Macro(v0) => v0.debug(formatter, "Macro"),
434 Expr::Match(v0) => v0.debug(formatter, "Match"),
435 Expr::MethodCall(v0) => v0.debug(formatter, "MethodCall"),
436 Expr::Paren(v0) => v0.debug(formatter, "Paren"),
437 Expr::Path(v0) => v0.debug(formatter, "Path"),
439 Expr::Range(v0) => v0.debug(formatter, "Range"),
440 Expr::Reference(v0) => v0.debug(formatter, "Reference"),
442 Expr::Repeat(v0) => v0.debug(formatter, "Repeat"),
444 Expr::Return(v0) => v0.debug(formatter, "Return"),
445 Expr::Struct(v0) => v0.debug(formatter, "Struct"),
447 Expr::Try(v0) => v0.debug(formatter, "Try"),
449 Expr::TryBlock(v0) => v0.debug(formatter, "TryBlock"),
451 Expr::Tuple(v0) => v0.debug(formatter, "Tuple"),
452 Expr::Unary(v0) => v0.debug(formatter, "Unary"),
454 Expr::Unsafe(v0) => v0.debug(formatter, "Unsafe"),
456 let mut formatter = formatter.debug_tuple("Verbatim");
457 formatter.field(v0);
458 formatter.finish()
461 Expr::While(v0) => v0.debug(formatter, "While"),
463 Expr::Yield(v0) => v0.debug(formatter, "Yield"),
472 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
474 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
475 let mut formatter = formatter.debug_struct(name);
476 formatter.field("attrs", &self.attrs);
477 formatter.field("bracket_token", &self.bracket_token);
478 formatter.field("elems", &self.elems);
479 formatter.finish()
482 self.debug(formatter, "ExprArray")
488 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
490 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
491 let mut formatter = formatter.debug_struct(name);
492 formatter.field("attrs", &self.attrs);
493 formatter.field("left", &self.left);
494 formatter.field("eq_token", &self.eq_token);
495 formatter.field("right", &self.right);
496 formatter.finish()
499 self.debug(formatter, "ExprAssign")
505 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
507 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
508 let mut formatter = formatter.debug_struct(name);
509 formatter.field("attrs", &self.attrs);
510 formatter.field("async_token", &self.async_token);
511 formatter.field("capture", &self.capture);
512 formatter.field("block", &self.block);
513 formatter.finish()
516 self.debug(formatter, "ExprAsync")
522 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
524 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
525 let mut formatter = formatter.debug_struct(name);
526 formatter.field("attrs", &self.attrs);
527 formatter.field("base", &self.base);
528 formatter.field("dot_token", &self.dot_token);
529 formatter.field("await_token", &self.await_token);
530 formatter.finish()
533 self.debug(formatter, "ExprAwait")
539 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
541 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
542 let mut formatter = formatter.debug_struct(name);
543 formatter.field("attrs", &self.attrs);
544 formatter.field("left", &self.left);
545 formatter.field("op", &self.op);
546 formatter.field("right", &self.right);
547 formatter.finish()
550 self.debug(formatter, "ExprBinary")
556 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
558 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
559 let mut formatter = formatter.debug_struct(name);
560 formatter.field("attrs", &self.attrs);
561 formatter.field("label", &self.label);
562 formatter.field("block", &self.block);
563 formatter.finish()
566 self.debug(formatter, "ExprBlock")
572 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
574 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
575 let mut formatter = formatter.debug_struct(name);
576 formatter.field("attrs", &self.attrs);
577 formatter.field("break_token", &self.break_token);
578 formatter.field("label", &self.label);
579 formatter.field("expr", &self.expr);
580 formatter.finish()
583 self.debug(formatter, "ExprBreak")
589 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
591 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
592 let mut formatter = formatter.debug_struct(name);
593 formatter.field("attrs", &self.attrs);
594 formatter.field("func", &self.func);
595 formatter.field("paren_token", &self.paren_token);
596 formatter.field("args", &self.args);
597 formatter.finish()
600 self.debug(formatter, "ExprCall")
606 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
608 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
609 let mut formatter = formatter.debug_struct(name);
610 formatter.field("attrs", &self.attrs);
611 formatter.field("expr", &self.expr);
612 formatter.field("as_token", &self.as_token);
613 formatter.field("ty", &self.ty);
614 formatter.finish()
617 self.debug(formatter, "ExprCast")
623 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
625 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
626 let mut formatter = formatter.debug_struct(name);
627 formatter.field("attrs", &self.attrs);
628 formatter.field("lifetimes", &self.lifetimes);
629 formatter.field("constness", &self.constness);
630 formatter.field("movability", &self.movability);
631 formatter.field("asyncness", &self.asyncness);
632 formatter.field("capture", &self.capture);
633 formatter.field("or1_token", &self.or1_token);
634 formatter.field("inputs", &self.inputs);
635 formatter.field("or2_token", &self.or2_token);
636 formatter.field("output", &self.output);
637 formatter.field("body", &self.body);
638 formatter.finish()
641 self.debug(formatter, "ExprClosure")
647 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
649 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
650 let mut formatter = formatter.debug_struct(name);
651 formatter.field("attrs", &self.attrs);
652 formatter.field("const_token", &self.const_token);
653 formatter.field("block", &self.block);
654 formatter.finish()
657 self.debug(formatter, "ExprConst")
663 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
665 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
666 let mut formatter = formatter.debug_struct(name);
667 formatter.field("attrs", &self.attrs);
668 formatter.field("continue_token", &self.continue_token);
669 formatter.field("label", &self.label);
670 formatter.finish()
673 self.debug(formatter, "ExprContinue")
679 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
681 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
682 let mut formatter = formatter.debug_struct(name);
683 formatter.field("attrs", &self.attrs);
684 formatter.field("base", &self.base);
685 formatter.field("dot_token", &self.dot_token);
686 formatter.field("member", &self.member);
687 formatter.finish()
690 self.debug(formatter, "ExprField")
696 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
698 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
699 let mut formatter = formatter.debug_struct(name);
700 formatter.field("attrs", &self.attrs);
701 formatter.field("label", &self.label);
702 formatter.field("for_token", &self.for_token);
703 formatter.field("pat", &self.pat);
704 formatter.field("in_token", &self.in_token);
705 formatter.field("expr", &self.expr);
706 formatter.field("body", &self.body);
707 formatter.finish()
710 self.debug(formatter, "ExprForLoop")
716 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
718 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
719 let mut formatter = formatter.debug_struct(name);
720 formatter.field("attrs", &self.attrs);
721 formatter.field("group_token", &self.group_token);
722 formatter.field("expr", &self.expr);
723 formatter.finish()
726 self.debug(formatter, "ExprGroup")
732 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
734 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
735 let mut formatter = formatter.debug_struct(name);
736 formatter.field("attrs", &self.attrs);
737 formatter.field("if_token", &self.if_token);
738 formatter.field("cond", &self.cond);
739 formatter.field("then_branch", &self.then_branch);
740 formatter.field("else_branch", &self.else_branch);
741 formatter.finish()
744 self.debug(formatter, "ExprIf")
750 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
752 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
753 let mut formatter = formatter.debug_struct(name);
754 formatter.field("attrs", &self.attrs);
755 formatter.field("expr", &self.expr);
756 formatter.field("bracket_token", &self.bracket_token);
757 formatter.field("index", &self.index);
758 formatter.finish()
761 self.debug(formatter, "ExprIndex")
767 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
769 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
770 let mut formatter = formatter.debug_struct(name);
771 formatter.field("attrs", &self.attrs);
772 formatter.field("underscore_token", &self.underscore_token);
773 formatter.finish()
776 self.debug(formatter, "ExprInfer")
782 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
784 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
785 let mut formatter = formatter.debug_struct(name);
786 formatter.field("attrs", &self.attrs);
787 formatter.field("let_token", &self.let_token);
788 formatter.field("pat", &self.pat);
789 formatter.field("eq_token", &self.eq_token);
790 formatter.field("expr", &self.expr);
791 formatter.finish()
794 self.debug(formatter, "ExprLet")
800 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
802 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
803 let mut formatter = formatter.debug_struct(name);
804 formatter.field("attrs", &self.attrs);
805 formatter.field("lit", &self.lit);
806 formatter.finish()
809 self.debug(formatter, "ExprLit")
815 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
817 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
818 let mut formatter = formatter.debug_struct(name);
819 formatter.field("attrs", &self.attrs);
820 formatter.field("label", &self.label);
821 formatter.field("loop_token", &self.loop_token);
822 formatter.field("body", &self.body);
823 formatter.finish()
826 self.debug(formatter, "ExprLoop")
832 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
834 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
835 let mut formatter = formatter.debug_struct(name);
836 formatter.field("attrs", &self.attrs);
837 formatter.field("mac", &self.mac);
838 formatter.finish()
841 self.debug(formatter, "ExprMacro")
847 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
849 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
850 let mut formatter = formatter.debug_struct(name);
851 formatter.field("attrs", &self.attrs);
852 formatter.field("match_token", &self.match_token);
853 formatter.field("expr", &self.expr);
854 formatter.field("brace_token", &self.brace_token);
855 formatter.field("arms", &self.arms);
856 formatter.finish()
859 self.debug(formatter, "ExprMatch")
865 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
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("receiver", &self.receiver);
871 formatter.field("dot_token", &self.dot_token);
872 formatter.field("method", &self.method);
873 formatter.field("turbofish", &self.turbofish);
874 formatter.field("paren_token", &self.paren_token);
875 formatter.field("args", &self.args);
876 formatter.finish()
879 self.debug(formatter, "ExprMethodCall")
885 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
887 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
888 let mut formatter = formatter.debug_struct(name);
889 formatter.field("attrs", &self.attrs);
890 formatter.field("paren_token", &self.paren_token);
891 formatter.field("expr", &self.expr);
892 formatter.finish()
895 self.debug(formatter, "ExprParen")
901 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
903 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
904 let mut formatter = formatter.debug_struct(name);
905 formatter.field("attrs", &self.attrs);
906 formatter.field("qself", &self.qself);
907 formatter.field("path", &self.path);
908 formatter.finish()
911 self.debug(formatter, "ExprPath")
917 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
919 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
920 let mut formatter = formatter.debug_struct(name);
921 formatter.field("attrs", &self.attrs);
922 formatter.field("start", &self.start);
923 formatter.field("limits", &self.limits);
924 formatter.field("end", &self.end);
925 formatter.finish()
928 self.debug(formatter, "ExprRange")
934 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
936 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
937 let mut formatter = formatter.debug_struct(name);
938 formatter.field("attrs", &self.attrs);
939 formatter.field("and_token", &self.and_token);
940 formatter.field("mutability", &self.mutability);
941 formatter.field("expr", &self.expr);
942 formatter.finish()
945 self.debug(formatter, "ExprReference")
951 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
953 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
954 let mut formatter = formatter.debug_struct(name);
955 formatter.field("attrs", &self.attrs);
956 formatter.field("bracket_token", &self.bracket_token);
957 formatter.field("expr", &self.expr);
958 formatter.field("semi_token", &self.semi_token);
959 formatter.field("len", &self.len);
960 formatter.finish()
963 self.debug(formatter, "ExprRepeat")
969 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
971 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
972 let mut formatter = formatter.debug_struct(name);
973 formatter.field("attrs", &self.attrs);
974 formatter.field("return_token", &self.return_token);
975 formatter.field("expr", &self.expr);
976 formatter.finish()
979 self.debug(formatter, "ExprReturn")
985 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
987 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
988 let mut formatter = formatter.debug_struct(name);
989 formatter.field("attrs", &self.attrs);
990 formatter.field("qself", &self.qself);
991 formatter.field("path", &self.path);
992 formatter.field("brace_token", &self.brace_token);
993 formatter.field("fields", &self.fields);
994 formatter.field("dot2_token", &self.dot2_token);
995 formatter.field("rest", &self.rest);
996 formatter.finish()
999 self.debug(formatter, "ExprStruct")
1005 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1007 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
1008 let mut formatter = formatter.debug_struct(name);
1009 formatter.field("attrs", &self.attrs);
1010 formatter.field("expr", &self.expr);
1011 formatter.field("question_token", &self.question_token);
1012 formatter.finish()
1015 self.debug(formatter, "ExprTry")
1021 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1023 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
1024 let mut formatter = formatter.debug_struct(name);
1025 formatter.field("attrs", &self.attrs);
1026 formatter.field("try_token", &self.try_token);
1027 formatter.field("block", &self.block);
1028 formatter.finish()
1031 self.debug(formatter, "ExprTryBlock")
1037 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1039 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
1040 let mut formatter = formatter.debug_struct(name);
1041 formatter.field("attrs", &self.attrs);
1042 formatter.field("paren_token", &self.paren_token);
1043 formatter.field("elems", &self.elems);
1044 formatter.finish()
1047 self.debug(formatter, "ExprTuple")
1053 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1055 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
1056 let mut formatter = formatter.debug_struct(name);
1057 formatter.field("attrs", &self.attrs);
1058 formatter.field("op", &self.op);
1059 formatter.field("expr", &self.expr);
1060 formatter.finish()
1063 self.debug(formatter, "ExprUnary")
1069 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1071 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
1072 let mut formatter = formatter.debug_struct(name);
1073 formatter.field("attrs", &self.attrs);
1074 formatter.field("unsafe_token", &self.unsafe_token);
1075 formatter.field("block", &self.block);
1076 formatter.finish()
1079 self.debug(formatter, "ExprUnsafe")
1085 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
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("label", &self.label);
1091 formatter.field("while_token", &self.while_token);
1092 formatter.field("cond", &self.cond);
1093 formatter.field("body", &self.body);
1094 formatter.finish()
1097 self.debug(formatter, "ExprWhile")
1103 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1105 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
1106 let mut formatter = formatter.debug_struct(name);
1107 formatter.field("attrs", &self.attrs);
1108 formatter.field("yield_token", &self.yield_token);
1109 formatter.field("expr", &self.expr);
1110 formatter.finish()
1113 self.debug(formatter, "ExprYield")
1119 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1120 let mut formatter = formatter.debug_struct("Field");
1121 formatter.field("attrs", &self.attrs);
1122 formatter.field("vis", &self.vis);
1123 formatter.field("mutability", &self.mutability);
1124 formatter.field("ident", &self.ident);
1125 formatter.field("colon_token", &self.colon_token);
1126 formatter.field("ty", &self.ty);
1127 formatter.finish()
1133 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1134 formatter.write_str("FieldMutability::")?;
1136 FieldMutability::None => formatter.write_str("None"),
1143 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1144 let mut formatter = formatter.debug_struct("FieldPat");
1145 formatter.field("attrs", &self.attrs);
1146 formatter.field("member", &self.member);
1147 formatter.field("colon_token", &self.colon_token);
1148 formatter.field("pat", &self.pat);
1149 formatter.finish()
1155 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1156 let mut formatter = formatter.debug_struct("FieldValue");
1157 formatter.field("attrs", &self.attrs);
1158 formatter.field("member", &self.member);
1159 formatter.field("colon_token", &self.colon_token);
1160 formatter.field("expr", &self.expr);
1161 formatter.finish()
1167 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1168 formatter.write_str("Fields::")?;
1170 Fields::Named(v0) => v0.debug(formatter, "Named"),
1171 Fields::Unnamed(v0) => v0.debug(formatter, "Unnamed"),
1172 Fields::Unit => formatter.write_str("Unit"),
1179 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1181 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
1182 let mut formatter = formatter.debug_struct(name);
1183 formatter.field("brace_token", &self.brace_token);
1184 formatter.field("named", &self.named);
1185 formatter.finish()
1188 self.debug(formatter, "FieldsNamed")
1194 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1196 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
1197 let mut formatter = formatter.debug_struct(name);
1198 formatter.field("paren_token", &self.paren_token);
1199 formatter.field("unnamed", &self.unnamed);
1200 formatter.finish()
1203 self.debug(formatter, "FieldsUnnamed")
1209 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1210 let mut formatter = formatter.debug_struct("File");
1211 formatter.field("shebang", &self.shebang);
1212 formatter.field("attrs", &self.attrs);
1213 formatter.field("items", &self.items);
1214 formatter.finish()
1220 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1221 formatter.write_str("FnArg::")?;
1224 let mut formatter = formatter.debug_tuple("Receiver");
1225 formatter.field(v0);
1226 formatter.finish()
1229 let mut formatter = formatter.debug_tuple("Typed");
1230 formatter.field(v0);
1231 formatter.finish()
1239 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1240 formatter.write_str("ForeignItem::")?;
1242 ForeignItem::Fn(v0) => v0.debug(formatter, "Fn"),
1243 ForeignItem::Static(v0) => v0.debug(formatter, "Static"),
1244 ForeignItem::Type(v0) => v0.debug(formatter, "Type"),
1245 ForeignItem::Macro(v0) => v0.debug(formatter, "Macro"),
1247 let mut formatter = formatter.debug_tuple("Verbatim");
1248 formatter.field(v0);
1249 formatter.finish()
1257 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1259 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
1260 let mut formatter = formatter.debug_struct(name);
1261 formatter.field("attrs", &self.attrs);
1262 formatter.field("vis", &self.vis);
1263 formatter.field("sig", &self.sig);
1264 formatter.field("semi_token", &self.semi_token);
1265 formatter.finish()
1268 self.debug(formatter, "ForeignItemFn")
1274 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1276 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
1277 let mut formatter = formatter.debug_struct(name);
1278 formatter.field("attrs", &self.attrs);
1279 formatter.field("mac", &self.mac);
1280 formatter.field("semi_token", &self.semi_token);
1281 formatter.finish()
1284 self.debug(formatter, "ForeignItemMacro")
1290 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1292 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
1293 let mut formatter = formatter.debug_struct(name);
1294 formatter.field("attrs", &self.attrs);
1295 formatter.field("vis", &self.vis);
1296 formatter.field("static_token", &self.static_token);
1297 formatter.field("mutability", &self.mutability);
1298 formatter.field("ident", &self.ident);
1299 formatter.field("colon_token", &self.colon_token);
1300 formatter.field("ty", &self.ty);
1301 formatter.field("semi_token", &self.semi_token);
1302 formatter.finish()
1305 self.debug(formatter, "ForeignItemStatic")
1311 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1313 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
1314 let mut formatter = formatter.debug_struct(name);
1315 formatter.field("attrs", &self.attrs);
1316 formatter.field("vis", &self.vis);
1317 formatter.field("type_token", &self.type_token);
1318 formatter.field("ident", &self.ident);
1319 formatter.field("generics", &self.generics);
1320 formatter.field("semi_token", &self.semi_token);
1321 formatter.finish()
1324 self.debug(formatter, "ForeignItemType")
1330 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1331 formatter.write_str("GenericArgument::")?;
1334 let mut formatter = formatter.debug_tuple("Lifetime");
1335 formatter.field(v0);
1336 formatter.finish()
1339 let mut formatter = formatter.debug_tuple("Type");
1340 formatter.field(v0);
1341 formatter.finish()
1344 let mut formatter = formatter.debug_tuple("Const");
1345 formatter.field(v0);
1346 formatter.finish()
1349 let mut formatter = formatter.debug_tuple("AssocType");
1350 formatter.field(v0);
1351 formatter.finish()
1354 let mut formatter = formatter.debug_tuple("AssocConst");
1355 formatter.field(v0);
1356 formatter.finish()
1359 let mut formatter = formatter.debug_tuple("Constraint");
1360 formatter.field(v0);
1361 formatter.finish()
1369 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1370 formatter.write_str("GenericParam::")?;
1373 let mut formatter = formatter.debug_tuple("Lifetime");
1374 formatter.field(v0);
1375 formatter.finish()
1378 let mut formatter = formatter.debug_tuple("Type");
1379 formatter.field(v0);
1380 formatter.finish()
1383 let mut formatter = formatter.debug_tuple("Const");
1384 formatter.field(v0);
1385 formatter.finish()
1393 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1394 let mut formatter = formatter.debug_struct("Generics");
1395 formatter.field("lt_token", &self.lt_token);
1396 formatter.field("params", &self.params);
1397 formatter.field("gt_token", &self.gt_token);
1398 formatter.field("where_clause", &self.where_clause);
1399 formatter.finish()
1405 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1406 formatter.write_str("ImplItem::")?;
1408 ImplItem::Const(v0) => v0.debug(formatter, "Const"),
1409 ImplItem::Fn(v0) => v0.debug(formatter, "Fn"),
1410 ImplItem::Type(v0) => v0.debug(formatter, "Type"),
1411 ImplItem::Macro(v0) => v0.debug(formatter, "Macro"),
1413 let mut formatter = formatter.debug_tuple("Verbatim");
1414 formatter.field(v0);
1415 formatter.finish()
1423 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1425 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
1426 let mut formatter = formatter.debug_struct(name);
1427 formatter.field("attrs", &self.attrs);
1428 formatter.field("vis", &self.vis);
1429 formatter.field("defaultness", &self.defaultness);
1430 formatter.field("const_token", &self.const_token);
1431 formatter.field("ident", &self.ident);
1432 formatter.field("generics", &self.generics);
1433 formatter.field("colon_token", &self.colon_token);
1434 formatter.field("ty", &self.ty);
1435 formatter.field("eq_token", &self.eq_token);
1436 formatter.field("expr", &self.expr);
1437 formatter.field("semi_token", &self.semi_token);
1438 formatter.finish()
1441 self.debug(formatter, "ImplItemConst")
1447 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1449 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
1450 let mut formatter = formatter.debug_struct(name);
1451 formatter.field("attrs", &self.attrs);
1452 formatter.field("vis", &self.vis);
1453 formatter.field("defaultness", &self.defaultness);
1454 formatter.field("sig", &self.sig);
1455 formatter.field("block", &self.block);
1456 formatter.finish()
1459 self.debug(formatter, "ImplItemFn")
1465 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1467 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
1468 let mut formatter = formatter.debug_struct(name);
1469 formatter.field("attrs", &self.attrs);
1470 formatter.field("mac", &self.mac);
1471 formatter.field("semi_token", &self.semi_token);
1472 formatter.finish()
1475 self.debug(formatter, "ImplItemMacro")
1481 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1483 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
1484 let mut formatter = formatter.debug_struct(name);
1485 formatter.field("attrs", &self.attrs);
1486 formatter.field("vis", &self.vis);
1487 formatter.field("defaultness", &self.defaultness);
1488 formatter.field("type_token", &self.type_token);
1489 formatter.field("ident", &self.ident);
1490 formatter.field("generics", &self.generics);
1491 formatter.field("eq_token", &self.eq_token);
1492 formatter.field("ty", &self.ty);
1493 formatter.field("semi_token", &self.semi_token);
1494 formatter.finish()
1497 self.debug(formatter, "ImplItemType")
1510 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1511 let mut formatter = formatter.debug_struct("Index");
1512 formatter.field("index", &self.index);
1513 formatter.field("span", &self.span);
1514 formatter.finish()
1520 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1521 formatter.write_str("Item::")?;
1523 Item::Const(v0) => v0.debug(formatter, "Const"),
1524 Item::Enum(v0) => v0.debug(formatter, "Enum"),
1525 Item::ExternCrate(v0) => v0.debug(formatter, "ExternCrate"),
1526 Item::Fn(v0) => v0.debug(formatter, "Fn"),
1527 Item::ForeignMod(v0) => v0.debug(formatter, "ForeignMod"),
1528 Item::Impl(v0) => v0.debug(formatter, "Impl"),
1529 Item::Macro(v0) => v0.debug(formatter, "Macro"),
1530 Item::Mod(v0) => v0.debug(formatter, "Mod"),
1531 Item::Static(v0) => v0.debug(formatter, "Static"),
1532 Item::Struct(v0) => v0.debug(formatter, "Struct"),
1533 Item::Trait(v0) => v0.debug(formatter, "Trait"),
1534 Item::TraitAlias(v0) => v0.debug(formatter, "TraitAlias"),
1535 Item::Type(v0) => v0.debug(formatter, "Type"),
1536 Item::Union(v0) => v0.debug(formatter, "Union"),
1537 Item::Use(v0) => v0.debug(formatter, "Use"),
1539 let mut formatter = formatter.debug_tuple("Verbatim");
1540 formatter.field(v0);
1541 formatter.finish()
1549 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1551 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
1552 let mut formatter = formatter.debug_struct(name);
1553 formatter.field("attrs", &self.attrs);
1554 formatter.field("vis", &self.vis);
1555 formatter.field("const_token", &self.const_token);
1556 formatter.field("ident", &self.ident);
1557 formatter.field("generics", &self.generics);
1558 formatter.field("colon_token", &self.colon_token);
1559 formatter.field("ty", &self.ty);
1560 formatter.field("eq_token", &self.eq_token);
1561 formatter.field("expr", &self.expr);
1562 formatter.field("semi_token", &self.semi_token);
1563 formatter.finish()
1566 self.debug(formatter, "ItemConst")
1572 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1574 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
1575 let mut formatter = formatter.debug_struct(name);
1576 formatter.field("attrs", &self.attrs);
1577 formatter.field("vis", &self.vis);
1578 formatter.field("enum_token", &self.enum_token);
1579 formatter.field("ident", &self.ident);
1580 formatter.field("generics", &self.generics);
1581 formatter.field("brace_token", &self.brace_token);
1582 formatter.field("variants", &self.variants);
1583 formatter.finish()
1586 self.debug(formatter, "ItemEnum")
1592 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1594 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
1595 let mut formatter = formatter.debug_struct(name);
1596 formatter.field("attrs", &self.attrs);
1597 formatter.field("vis", &self.vis);
1598 formatter.field("extern_token", &self.extern_token);
1599 formatter.field("crate_token", &self.crate_token);
1600 formatter.field("ident", &self.ident);
1601 formatter.field("rename", &self.rename);
1602 formatter.field("semi_token", &self.semi_token);
1603 formatter.finish()
1606 self.debug(formatter, "ItemExternCrate")
1612 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1614 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
1615 let mut formatter = formatter.debug_struct(name);
1616 formatter.field("attrs", &self.attrs);
1617 formatter.field("vis", &self.vis);
1618 formatter.field("sig", &self.sig);
1619 formatter.field("block", &self.block);
1620 formatter.finish()
1623 self.debug(formatter, "ItemFn")
1629 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1631 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
1632 let mut formatter = formatter.debug_struct(name);
1633 formatter.field("attrs", &self.attrs);
1634 formatter.field("unsafety", &self.unsafety);
1635 formatter.field("abi", &self.abi);
1636 formatter.field("brace_token", &self.brace_token);
1637 formatter.field("items", &self.items);
1638 formatter.finish()
1641 self.debug(formatter, "ItemForeignMod")
1647 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1649 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
1650 let mut formatter = formatter.debug_struct(name);
1651 formatter.field("attrs", &self.attrs);
1652 formatter.field("defaultness", &self.defaultness);
1653 formatter.field("unsafety", &self.unsafety);
1654 formatter.field("impl_token", &self.impl_token);
1655 formatter.field("generics", &self.generics);
1656 formatter.field("trait_", &self.trait_);
1657 formatter.field("self_ty", &self.self_ty);
1658 formatter.field("brace_token", &self.brace_token);
1659 formatter.field("items", &self.items);
1660 formatter.finish()
1663 self.debug(formatter, "ItemImpl")
1669 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1671 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
1672 let mut formatter = formatter.debug_struct(name);
1673 formatter.field("attrs", &self.attrs);
1674 formatter.field("ident", &self.ident);
1675 formatter.field("mac", &self.mac);
1676 formatter.field("semi_token", &self.semi_token);
1677 formatter.finish()
1680 self.debug(formatter, "ItemMacro")
1686 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1688 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
1689 let mut formatter = formatter.debug_struct(name);
1690 formatter.field("attrs", &self.attrs);
1691 formatter.field("vis", &self.vis);
1692 formatter.field("unsafety", &self.unsafety);
1693 formatter.field("mod_token", &self.mod_token);
1694 formatter.field("ident", &self.ident);
1695 formatter.field("content", &self.content);
1696 formatter.field("semi", &self.semi);
1697 formatter.finish()
1700 self.debug(formatter, "ItemMod")
1706 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1708 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
1709 let mut formatter = formatter.debug_struct(name);
1710 formatter.field("attrs", &self.attrs);
1711 formatter.field("vis", &self.vis);
1712 formatter.field("static_token", &self.static_token);
1713 formatter.field("mutability", &self.mutability);
1714 formatter.field("ident", &self.ident);
1715 formatter.field("colon_token", &self.colon_token);
1716 formatter.field("ty", &self.ty);
1717 formatter.field("eq_token", &self.eq_token);
1718 formatter.field("expr", &self.expr);
1719 formatter.field("semi_token", &self.semi_token);
1720 formatter.finish()
1723 self.debug(formatter, "ItemStatic")
1729 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1731 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
1732 let mut formatter = formatter.debug_struct(name);
1733 formatter.field("attrs", &self.attrs);
1734 formatter.field("vis", &self.vis);
1735 formatter.field("struct_token", &self.struct_token);
1736 formatter.field("ident", &self.ident);
1737 formatter.field("generics", &self.generics);
1738 formatter.field("fields", &self.fields);
1739 formatter.field("semi_token", &self.semi_token);
1740 formatter.finish()
1743 self.debug(formatter, "ItemStruct")
1749 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
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("vis", &self.vis);
1755 formatter.field("unsafety", &self.unsafety);
1756 formatter.field("auto_token", &self.auto_token);
1757 formatter.field("restriction", &self.restriction);
1758 formatter.field("trait_token", &self.trait_token);
1759 formatter.field("ident", &self.ident);
1760 formatter.field("generics", &self.generics);
1761 formatter.field("colon_token", &self.colon_token);
1762 formatter.field("supertraits", &self.supertraits);
1763 formatter.field("brace_token", &self.brace_token);
1764 formatter.field("items", &self.items);
1765 formatter.finish()
1768 self.debug(formatter, "ItemTrait")
1774 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1776 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
1777 let mut formatter = formatter.debug_struct(name);
1778 formatter.field("attrs", &self.attrs);
1779 formatter.field("vis", &self.vis);
1780 formatter.field("trait_token", &self.trait_token);
1781 formatter.field("ident", &self.ident);
1782 formatter.field("generics", &self.generics);
1783 formatter.field("eq_token", &self.eq_token);
1784 formatter.field("bounds", &self.bounds);
1785 formatter.field("semi_token", &self.semi_token);
1786 formatter.finish()
1789 self.debug(formatter, "ItemTraitAlias")
1795 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1797 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
1798 let mut formatter = formatter.debug_struct(name);
1799 formatter.field("attrs", &self.attrs);
1800 formatter.field("vis", &self.vis);
1801 formatter.field("type_token", &self.type_token);
1802 formatter.field("ident", &self.ident);
1803 formatter.field("generics", &self.generics);
1804 formatter.field("eq_token", &self.eq_token);
1805 formatter.field("ty", &self.ty);
1806 formatter.field("semi_token", &self.semi_token);
1807 formatter.finish()
1810 self.debug(formatter, "ItemType")
1816 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1818 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
1819 let mut formatter = formatter.debug_struct(name);
1820 formatter.field("attrs", &self.attrs);
1821 formatter.field("vis", &self.vis);
1822 formatter.field("union_token", &self.union_token);
1823 formatter.field("ident", &self.ident);
1824 formatter.field("generics", &self.generics);
1825 formatter.field("fields", &self.fields);
1826 formatter.finish()
1829 self.debug(formatter, "ItemUnion")
1835 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
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("use_token", &self.use_token);
1842 formatter.field("leading_colon", &self.leading_colon);
1843 formatter.field("tree", &self.tree);
1844 formatter.field("semi_token", &self.semi_token);
1845 formatter.finish()
1848 self.debug(formatter, "ItemUse")
1854 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1855 let mut formatter = formatter.debug_struct("Label");
1856 formatter.field("name", &self.name);
1857 formatter.field("colon_token", &self.colon_token);
1858 formatter.finish()
1863 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1865 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
1866 let mut formatter = formatter.debug_struct(name);
1867 formatter.field("apostrophe", &self.apostrophe);
1868 formatter.field("ident", &self.ident);
1869 formatter.finish()
1872 self.debug(formatter, "Lifetime")
1878 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1879 let mut formatter = formatter.debug_struct("LifetimeParam");
1880 formatter.field("attrs", &self.attrs);
1881 formatter.field("lifetime", &self.lifetime);
1882 formatter.field("colon_token", &self.colon_token);
1883 formatter.field("bounds", &self.bounds);
1884 formatter.finish()
1889 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1890 formatter.write_str("Lit::")?;
1892 Lit::Str(v0) => v0.debug(formatter, "Str"),
1893 Lit::ByteStr(v0) => v0.debug(formatter, "ByteStr"),
1894 Lit::Byte(v0) => v0.debug(formatter, "Byte"),
1895 Lit::Char(v0) => v0.debug(formatter, "Char"),
1896 Lit::Int(v0) => v0.debug(formatter, "Int"),
1897 Lit::Float(v0) => v0.debug(formatter, "Float"),
1898 Lit::Bool(v0) => v0.debug(formatter, "Bool"),
1900 let mut formatter = formatter.debug_tuple("Verbatim");
1901 formatter.field(v0);
1902 formatter.finish()
1910 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1912 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
1913 let mut formatter = formatter.debug_struct(name);
1914 formatter.field("attrs", &self.attrs);
1915 formatter.field("let_token", &self.let_token);
1916 formatter.field("pat", &self.pat);
1917 formatter.field("init", &self.init);
1918 formatter.field("semi_token", &self.semi_token);
1919 formatter.finish()
1922 self.debug(formatter, "Local")
1928 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1929 let mut formatter = formatter.debug_struct("LocalInit");
1930 formatter.field("eq_token", &self.eq_token);
1931 formatter.field("expr", &self.expr);
1932 formatter.field("diverge", &self.diverge);
1933 formatter.finish()
1939 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1940 let mut formatter = formatter.debug_struct("Macro");
1941 formatter.field("path", &self.path);
1942 formatter.field("bang_token", &self.bang_token);
1943 formatter.field("delimiter", &self.delimiter);
1944 formatter.field("tokens", &self.tokens);
1945 formatter.finish()
1951 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1952 formatter.write_str("MacroDelimiter::")?;
1955 let mut formatter = formatter.debug_tuple("Paren");
1956 formatter.field(v0);
1957 formatter.finish()
1960 let mut formatter = formatter.debug_tuple("Brace");
1961 formatter.field(v0);
1962 formatter.finish()
1965 let mut formatter = formatter.debug_tuple("Bracket");
1966 formatter.field(v0);
1967 formatter.finish()
1975 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1976 formatter.write_str("Member::")?;
1979 let mut formatter = formatter.debug_tuple("Named");
1980 formatter.field(v0);
1981 formatter.finish()
1984 let mut formatter = formatter.debug_tuple("Unnamed");
1985 formatter.field(v0);
1986 formatter.finish()
1994 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1995 formatter.write_str("Meta::")?;
1997 Meta::Path(v0) => v0.debug(formatter, "Path"),
1998 Meta::List(v0) => v0.debug(formatter, "List"),
1999 Meta::NameValue(v0) => v0.debug(formatter, "NameValue"),
2006 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2008 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
2009 let mut formatter = formatter.debug_struct(name);
2010 formatter.field("path", &self.path);
2011 formatter.field("delimiter", &self.delimiter);
2012 formatter.field("tokens", &self.tokens);
2013 formatter.finish()
2016 self.debug(formatter, "MetaList")
2022 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2024 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
2025 let mut formatter = formatter.debug_struct(name);
2026 formatter.field("path", &self.path);
2027 formatter.field("eq_token", &self.eq_token);
2028 formatter.field("value", &self.value);
2029 formatter.finish()
2032 self.debug(formatter, "MetaNameValue")
2038 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2040 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
2041 let mut formatter = formatter.debug_struct(name);
2042 formatter.field("paren_token", &self.paren_token);
2043 formatter.field("inputs", &self.inputs);
2044 formatter.field("output", &self.output);
2045 formatter.finish()
2048 self.debug(formatter, "ParenthesizedGenericArguments")
2054 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2055 formatter.write_str("Pat::")?;
2057 Pat::Const(v0) => v0.debug(formatter, "Const"),
2058 Pat::Ident(v0) => v0.debug(formatter, "Ident"),
2059 Pat::Lit(v0) => v0.debug(formatter, "Lit"),
2060 Pat::Macro(v0) => v0.debug(formatter, "Macro"),
2061 Pat::Or(v0) => v0.debug(formatter, "Or"),
2062 Pat::Paren(v0) => v0.debug(formatter, "Paren"),
2063 Pat::Path(v0) => v0.debug(formatter, "Path"),
2064 Pat::Range(v0) => v0.debug(formatter, "Range"),
2065 Pat::Reference(v0) => v0.debug(formatter, "Reference"),
2066 Pat::Rest(v0) => v0.debug(formatter, "Rest"),
2067 Pat::Slice(v0) => v0.debug(formatter, "Slice"),
2068 Pat::Struct(v0) => v0.debug(formatter, "Struct"),
2069 Pat::Tuple(v0) => v0.debug(formatter, "Tuple"),
2070 Pat::TupleStruct(v0) => v0.debug(formatter, "TupleStruct"),
2071 Pat::Type(v0) => v0.debug(formatter, "Type"),
2073 let mut formatter = formatter.debug_tuple("Verbatim");
2074 formatter.field(v0);
2075 formatter.finish()
2077 Pat::Wild(v0) => v0.debug(formatter, "Wild"),
2084 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2086 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
2087 let mut formatter = formatter.debug_struct(name);
2088 formatter.field("attrs", &self.attrs);
2089 formatter.field("by_ref", &self.by_ref);
2090 formatter.field("mutability", &self.mutability);
2091 formatter.field("ident", &self.ident);
2092 formatter.field("subpat", &self.subpat);
2093 formatter.finish()
2096 self.debug(formatter, "PatIdent")
2102 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2104 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
2105 let mut formatter = formatter.debug_struct(name);
2106 formatter.field("attrs", &self.attrs);
2107 formatter.field("leading_vert", &self.leading_vert);
2108 formatter.field("cases", &self.cases);
2109 formatter.finish()
2112 self.debug(formatter, "PatOr")
2118 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2120 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
2121 let mut formatter = formatter.debug_struct(name);
2122 formatter.field("attrs", &self.attrs);
2123 formatter.field("paren_token", &self.paren_token);
2124 formatter.field("pat", &self.pat);
2125 formatter.finish()
2128 self.debug(formatter, "PatParen")
2134 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2136 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
2137 let mut formatter = formatter.debug_struct(name);
2138 formatter.field("attrs", &self.attrs);
2139 formatter.field("and_token", &self.and_token);
2140 formatter.field("mutability", &self.mutability);
2141 formatter.field("pat", &self.pat);
2142 formatter.finish()
2145 self.debug(formatter, "PatReference")
2151 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2153 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
2154 let mut formatter = formatter.debug_struct(name);
2155 formatter.field("attrs", &self.attrs);
2156 formatter.field("dot2_token", &self.dot2_token);
2157 formatter.finish()
2160 self.debug(formatter, "PatRest")
2166 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2168 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
2169 let mut formatter = formatter.debug_struct(name);
2170 formatter.field("attrs", &self.attrs);
2171 formatter.field("bracket_token", &self.bracket_token);
2172 formatter.field("elems", &self.elems);
2173 formatter.finish()
2176 self.debug(formatter, "PatSlice")
2182 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2184 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
2185 let mut formatter = formatter.debug_struct(name);
2186 formatter.field("attrs", &self.attrs);
2187 formatter.field("qself", &self.qself);
2188 formatter.field("path", &self.path);
2189 formatter.field("brace_token", &self.brace_token);
2190 formatter.field("fields", &self.fields);
2191 formatter.field("rest", &self.rest);
2192 formatter.finish()
2195 self.debug(formatter, "PatStruct")
2201 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
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("paren_token", &self.paren_token);
2207 formatter.field("elems", &self.elems);
2208 formatter.finish()
2211 self.debug(formatter, "PatTuple")
2217 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2219 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
2220 let mut formatter = formatter.debug_struct(name);
2221 formatter.field("attrs", &self.attrs);
2222 formatter.field("qself", &self.qself);
2223 formatter.field("path", &self.path);
2224 formatter.field("paren_token", &self.paren_token);
2225 formatter.field("elems", &self.elems);
2226 formatter.finish()
2229 self.debug(formatter, "PatTupleStruct")
2235 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2237 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
2238 let mut formatter = formatter.debug_struct(name);
2239 formatter.field("attrs", &self.attrs);
2240 formatter.field("pat", &self.pat);
2241 formatter.field("colon_token", &self.colon_token);
2242 formatter.field("ty", &self.ty);
2243 formatter.finish()
2246 self.debug(formatter, "PatType")
2252 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2254 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
2255 let mut formatter = formatter.debug_struct(name);
2256 formatter.field("attrs", &self.attrs);
2257 formatter.field("underscore_token", &self.underscore_token);
2258 formatter.finish()
2261 self.debug(formatter, "PatWild")
2267 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2269 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
2270 let mut formatter = formatter.debug_struct(name);
2271 formatter.field("leading_colon", &self.leading_colon);
2272 formatter.field("segments", &self.segments);
2273 formatter.finish()
2276 self.debug(formatter, "Path")
2282 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2283 formatter.write_str("PathArguments::")?;
2285 PathArguments::None => formatter.write_str("None"),
2286 PathArguments::AngleBracketed(v0) => v0.debug(formatter, "AngleBracketed"),
2287 PathArguments::Parenthesized(v0) => v0.debug(formatter, "Parenthesized"),
2294 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2295 let mut formatter = formatter.debug_struct("PathSegment");
2296 formatter.field("ident", &self.ident);
2297 formatter.field("arguments", &self.arguments);
2298 formatter.finish()
2304 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2305 let mut formatter = formatter.debug_struct("PredicateLifetime");
2306 formatter.field("lifetime", &self.lifetime);
2307 formatter.field("colon_token", &self.colon_token);
2308 formatter.field("bounds", &self.bounds);
2309 formatter.finish()
2315 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2316 let mut formatter = formatter.debug_struct("PredicateType");
2317 formatter.field("lifetimes", &self.lifetimes);
2318 formatter.field("bounded_ty", &self.bounded_ty);
2319 formatter.field("colon_token", &self.colon_token);
2320 formatter.field("bounds", &self.bounds);
2321 formatter.finish()
2327 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2328 let mut formatter = formatter.debug_struct("QSelf");
2329 formatter.field("lt_token", &self.lt_token);
2330 formatter.field("ty", &self.ty);
2331 formatter.field("position", &self.position);
2332 formatter.field("as_token", &self.as_token);
2333 formatter.field("gt_token", &self.gt_token);
2334 formatter.finish()
2340 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2341 formatter.write_str("RangeLimits::")?;
2344 let mut formatter = formatter.debug_tuple("HalfOpen");
2345 formatter.field(v0);
2346 formatter.finish()
2349 let mut formatter = formatter.debug_tuple("Closed");
2350 formatter.field(v0);
2351 formatter.finish()
2359 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2360 let mut formatter = formatter.debug_struct("Receiver");
2361 formatter.field("attrs", &self.attrs);
2362 formatter.field("reference", &self.reference);
2363 formatter.field("mutability", &self.mutability);
2364 formatter.field("self_token", &self.self_token);
2365 formatter.field("colon_token", &self.colon_token);
2366 formatter.field("ty", &self.ty);
2367 formatter.finish()
2373 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2374 formatter.write_str("ReturnType::")?;
2376 ReturnType::Default => formatter.write_str("Default"),
2378 let mut formatter = formatter.debug_tuple("Type");
2379 formatter.field(v0);
2380 formatter.field(v1);
2381 formatter.finish()
2389 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2390 let mut formatter = formatter.debug_struct("Signature");
2391 formatter.field("constness", &self.constness);
2392 formatter.field("asyncness", &self.asyncness);
2393 formatter.field("unsafety", &self.unsafety);
2394 formatter.field("abi", &self.abi);
2395 formatter.field("fn_token", &self.fn_token);
2396 formatter.field("ident", &self.ident);
2397 formatter.field("generics", &self.generics);
2398 formatter.field("paren_token", &self.paren_token);
2399 formatter.field("inputs", &self.inputs);
2400 formatter.field("variadic", &self.variadic);
2401 formatter.field("output", &self.output);
2402 formatter.finish()
2408 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2409 formatter.write_str("StaticMutability::")?;
2412 let mut formatter = formatter.debug_tuple("Mut");
2413 formatter.field(v0);
2414 formatter.finish()
2416 StaticMutability::None => formatter.write_str("None"),
2423 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2424 formatter.write_str("Stmt::")?;
2426 Stmt::Local(v0) => v0.debug(formatter, "Local"),
2428 let mut formatter = formatter.debug_tuple("Item");
2429 formatter.field(v0);
2430 formatter.finish()
2433 let mut formatter = formatter.debug_tuple("Expr");
2434 formatter.field(v0);
2435 formatter.field(v1);
2436 formatter.finish()
2438 Stmt::Macro(v0) => v0.debug(formatter, "Macro"),
2445 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2447 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
2448 let mut formatter = formatter.debug_struct(name);
2449 formatter.field("attrs", &self.attrs);
2450 formatter.field("mac", &self.mac);
2451 formatter.field("semi_token", &self.semi_token);
2452 formatter.finish()
2455 self.debug(formatter, "StmtMacro")
2461 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2462 let mut formatter = formatter.debug_struct("TraitBound");
2463 formatter.field("paren_token", &self.paren_token);
2464 formatter.field("modifier", &self.modifier);
2465 formatter.field("lifetimes", &self.lifetimes);
2466 formatter.field("path", &self.path);
2467 formatter.finish()
2473 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2474 formatter.write_str("TraitBoundModifier::")?;
2476 TraitBoundModifier::None => formatter.write_str("None"),
2478 let mut formatter = formatter.debug_tuple("Maybe");
2479 formatter.field(v0);
2480 formatter.finish()
2488 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2489 formatter.write_str("TraitItem::")?;
2491 TraitItem::Const(v0) => v0.debug(formatter, "Const"),
2492 TraitItem::Fn(v0) => v0.debug(formatter, "Fn"),
2493 TraitItem::Type(v0) => v0.debug(formatter, "Type"),
2494 TraitItem::Macro(v0) => v0.debug(formatter, "Macro"),
2496 let mut formatter = formatter.debug_tuple("Verbatim");
2497 formatter.field(v0);
2498 formatter.finish()
2506 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2508 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
2509 let mut formatter = formatter.debug_struct(name);
2510 formatter.field("attrs", &self.attrs);
2511 formatter.field("const_token", &self.const_token);
2512 formatter.field("ident", &self.ident);
2513 formatter.field("generics", &self.generics);
2514 formatter.field("colon_token", &self.colon_token);
2515 formatter.field("ty", &self.ty);
2516 formatter.field("default", &self.default);
2517 formatter.field("semi_token", &self.semi_token);
2518 formatter.finish()
2521 self.debug(formatter, "TraitItemConst")
2527 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2529 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
2530 let mut formatter = formatter.debug_struct(name);
2531 formatter.field("attrs", &self.attrs);
2532 formatter.field("sig", &self.sig);
2533 formatter.field("default", &self.default);
2534 formatter.field("semi_token", &self.semi_token);
2535 formatter.finish()
2538 self.debug(formatter, "TraitItemFn")
2544 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2546 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
2547 let mut formatter = formatter.debug_struct(name);
2548 formatter.field("attrs", &self.attrs);
2549 formatter.field("mac", &self.mac);
2550 formatter.field("semi_token", &self.semi_token);
2551 formatter.finish()
2554 self.debug(formatter, "TraitItemMacro")
2560 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2562 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
2563 let mut formatter = formatter.debug_struct(name);
2564 formatter.field("attrs", &self.attrs);
2565 formatter.field("type_token", &self.type_token);
2566 formatter.field("ident", &self.ident);
2567 formatter.field("generics", &self.generics);
2568 formatter.field("colon_token", &self.colon_token);
2569 formatter.field("bounds", &self.bounds);
2570 formatter.field("default", &self.default);
2571 formatter.field("semi_token", &self.semi_token);
2572 formatter.finish()
2575 self.debug(formatter, "TraitItemType")
2581 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2582 formatter.write_str("Type::")?;
2584 Type::Array(v0) => v0.debug(formatter, "Array"),
2585 Type::BareFn(v0) => v0.debug(formatter, "BareFn"),
2586 Type::Group(v0) => v0.debug(formatter, "Group"),
2587 Type::ImplTrait(v0) => v0.debug(formatter, "ImplTrait"),
2588 Type::Infer(v0) => v0.debug(formatter, "Infer"),
2589 Type::Macro(v0) => v0.debug(formatter, "Macro"),
2590 Type::Never(v0) => v0.debug(formatter, "Never"),
2591 Type::Paren(v0) => v0.debug(formatter, "Paren"),
2592 Type::Path(v0) => v0.debug(formatter, "Path"),
2593 Type::Ptr(v0) => v0.debug(formatter, "Ptr"),
2594 Type::Reference(v0) => v0.debug(formatter, "Reference"),
2595 Type::Slice(v0) => v0.debug(formatter, "Slice"),
2596 Type::TraitObject(v0) => v0.debug(formatter, "TraitObject"),
2597 Type::Tuple(v0) => v0.debug(formatter, "Tuple"),
2599 let mut formatter = formatter.debug_tuple("Verbatim");
2600 formatter.field(v0);
2601 formatter.finish()
2609 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2611 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
2612 let mut formatter = formatter.debug_struct(name);
2613 formatter.field("bracket_token", &self.bracket_token);
2614 formatter.field("elem", &self.elem);
2615 formatter.field("semi_token", &self.semi_token);
2616 formatter.field("len", &self.len);
2617 formatter.finish()
2620 self.debug(formatter, "TypeArray")
2626 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2628 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
2629 let mut formatter = formatter.debug_struct(name);
2630 formatter.field("lifetimes", &self.lifetimes);
2631 formatter.field("unsafety", &self.unsafety);
2632 formatter.field("abi", &self.abi);
2633 formatter.field("fn_token", &self.fn_token);
2634 formatter.field("paren_token", &self.paren_token);
2635 formatter.field("inputs", &self.inputs);
2636 formatter.field("variadic", &self.variadic);
2637 formatter.field("output", &self.output);
2638 formatter.finish()
2641 self.debug(formatter, "TypeBareFn")
2647 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2649 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
2650 let mut formatter = formatter.debug_struct(name);
2651 formatter.field("group_token", &self.group_token);
2652 formatter.field("elem", &self.elem);
2653 formatter.finish()
2656 self.debug(formatter, "TypeGroup")
2662 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2664 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
2665 let mut formatter = formatter.debug_struct(name);
2666 formatter.field("impl_token", &self.impl_token);
2667 formatter.field("bounds", &self.bounds);
2668 formatter.finish()
2671 self.debug(formatter, "TypeImplTrait")
2677 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2679 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
2680 let mut formatter = formatter.debug_struct(name);
2681 formatter.field("underscore_token", &self.underscore_token);
2682 formatter.finish()
2685 self.debug(formatter, "TypeInfer")
2691 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2693 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
2694 let mut formatter = formatter.debug_struct(name);
2695 formatter.field("mac", &self.mac);
2696 formatter.finish()
2699 self.debug(formatter, "TypeMacro")
2705 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2707 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
2708 let mut formatter = formatter.debug_struct(name);
2709 formatter.field("bang_token", &self.bang_token);
2710 formatter.finish()
2713 self.debug(formatter, "TypeNever")
2719 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2720 let mut formatter = formatter.debug_struct("TypeParam");
2721 formatter.field("attrs", &self.attrs);
2722 formatter.field("ident", &self.ident);
2723 formatter.field("colon_token", &self.colon_token);
2724 formatter.field("bounds", &self.bounds);
2725 formatter.field("eq_token", &self.eq_token);
2726 formatter.field("default", &self.default);
2727 formatter.finish()
2733 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2734 formatter.write_str("TypeParamBound::")?;
2737 let mut formatter = formatter.debug_tuple("Trait");
2738 formatter.field(v0);
2739 formatter.finish()
2741 TypeParamBound::Lifetime(v0) => v0.debug(formatter, "Lifetime"),
2743 let mut formatter = formatter.debug_tuple("Verbatim");
2744 formatter.field(v0);
2745 formatter.finish()
2753 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2755 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
2756 let mut formatter = formatter.debug_struct(name);
2757 formatter.field("paren_token", &self.paren_token);
2758 formatter.field("elem", &self.elem);
2759 formatter.finish()
2762 self.debug(formatter, "TypeParen")
2768 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2770 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
2771 let mut formatter = formatter.debug_struct(name);
2772 formatter.field("qself", &self.qself);
2773 formatter.field("path", &self.path);
2774 formatter.finish()
2777 self.debug(formatter, "TypePath")
2783 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2785 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
2786 let mut formatter = formatter.debug_struct(name);
2787 formatter.field("star_token", &self.star_token);
2788 formatter.field("const_token", &self.const_token);
2789 formatter.field("mutability", &self.mutability);
2790 formatter.field("elem", &self.elem);
2791 formatter.finish()
2794 self.debug(formatter, "TypePtr")
2800 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2802 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
2803 let mut formatter = formatter.debug_struct(name);
2804 formatter.field("and_token", &self.and_token);
2805 formatter.field("lifetime", &self.lifetime);
2806 formatter.field("mutability", &self.mutability);
2807 formatter.field("elem", &self.elem);
2808 formatter.finish()
2811 self.debug(formatter, "TypeReference")
2817 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2819 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
2820 let mut formatter = formatter.debug_struct(name);
2821 formatter.field("bracket_token", &self.bracket_token);
2822 formatter.field("elem", &self.elem);
2823 formatter.finish()
2826 self.debug(formatter, "TypeSlice")
2832 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2834 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
2835 let mut formatter = formatter.debug_struct(name);
2836 formatter.field("dyn_token", &self.dyn_token);
2837 formatter.field("bounds", &self.bounds);
2838 formatter.finish()
2841 self.debug(formatter, "TypeTraitObject")
2847 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2849 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
2850 let mut formatter = formatter.debug_struct(name);
2851 formatter.field("paren_token", &self.paren_token);
2852 formatter.field("elems", &self.elems);
2853 formatter.finish()
2856 self.debug(formatter, "TypeTuple")
2862 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2863 formatter.write_str("UnOp::")?;
2866 let mut formatter = formatter.debug_tuple("Deref");
2867 formatter.field(v0);
2868 formatter.finish()
2871 let mut formatter = formatter.debug_tuple("Not");
2872 formatter.field(v0);
2873 formatter.finish()
2876 let mut formatter = formatter.debug_tuple("Neg");
2877 formatter.field(v0);
2878 formatter.finish()
2886 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2887 let mut formatter = formatter.debug_struct("UseGlob");
2888 formatter.field("star_token", &self.star_token);
2889 formatter.finish()
2895 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2896 let mut formatter = formatter.debug_struct("UseGroup");
2897 formatter.field("brace_token", &self.brace_token);
2898 formatter.field("items", &self.items);
2899 formatter.finish()
2905 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2906 let mut formatter = formatter.debug_struct("UseName");
2907 formatter.field("ident", &self.ident);
2908 formatter.finish()
2914 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2915 let mut formatter = formatter.debug_struct("UsePath");
2916 formatter.field("ident", &self.ident);
2917 formatter.field("colon2_token", &self.colon2_token);
2918 formatter.field("tree", &self.tree);
2919 formatter.finish()
2925 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2926 let mut formatter = formatter.debug_struct("UseRename");
2927 formatter.field("ident", &self.ident);
2928 formatter.field("as_token", &self.as_token);
2929 formatter.field("rename", &self.rename);
2930 formatter.finish()
2936 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2937 formatter.write_str("UseTree::")?;
2940 let mut formatter = formatter.debug_tuple("Path");
2941 formatter.field(v0);
2942 formatter.finish()
2945 let mut formatter = formatter.debug_tuple("Name");
2946 formatter.field(v0);
2947 formatter.finish()
2950 let mut formatter = formatter.debug_tuple("Rename");
2951 formatter.field(v0);
2952 formatter.finish()
2955 let mut formatter = formatter.debug_tuple("Glob");
2956 formatter.field(v0);
2957 formatter.finish()
2960 let mut formatter = formatter.debug_tuple("Group");
2961 formatter.field(v0);
2962 formatter.finish()
2970 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2971 let mut formatter = formatter.debug_struct("Variadic");
2972 formatter.field("attrs", &self.attrs);
2973 formatter.field("pat", &self.pat);
2974 formatter.field("dots", &self.dots);
2975 formatter.field("comma", &self.comma);
2976 formatter.finish()
2982 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2983 let mut formatter = formatter.debug_struct("Variant");
2984 formatter.field("attrs", &self.attrs);
2985 formatter.field("ident", &self.ident);
2986 formatter.field("fields", &self.fields);
2987 formatter.field("discriminant", &self.discriminant);
2988 formatter.finish()
2994 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2996 fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
2997 let mut formatter = formatter.debug_struct(name);
2998 formatter.field("pub_token", &self.pub_token);
2999 formatter.field("paren_token", &self.paren_token);
3000 formatter.field("in_token", &self.in_token);
3001 formatter.field("path", &self.path);
3002 formatter.finish()
3005 self.debug(formatter, "VisRestricted")
3011 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3012 formatter.write_str("Visibility::")?;
3015 let mut formatter = formatter.debug_tuple("Public");
3016 formatter.field(v0);
3017 formatter.finish()
3019 Visibility::Restricted(v0) => v0.debug(formatter, "Restricted"),
3020 Visibility::Inherited => formatter.write_str("Inherited"),
3027 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3028 let mut formatter = formatter.debug_struct("WhereClause");
3029 formatter.field("where_token", &self.where_token);
3030 formatter.field("predicates", &self.predicates);
3031 formatter.finish()
3037 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3038 formatter.write_str("WherePredicate::")?;
3041 let mut formatter = formatter.debug_tuple("Lifetime");
3042 formatter.field(v0);
3043 formatter.finish()
3046 let mut formatter = formatter.debug_tuple("Type");
3047 formatter.field(v0);
3048 formatter.finish()