Lines Matching defs:formatter
10 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
11 let mut formatter = formatter.debug_struct("Abi");
17 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
18 formatter.write_str("Some(")?;
19 Debug::fmt(Lite(&self.0), formatter)?;
20 formatter.write_str(")")?;
24 formatter.field("name", Print::ref_cast(val));
26 formatter.finish()
30 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
31 let mut formatter = formatter.debug_struct("AngleBracketedGenericArguments");
33 formatter.field("colon2_token", &Present);
36 formatter.field("args", Lite(&self.value.args));
38 formatter.finish()
42 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
43 let mut formatter = formatter.debug_struct("Arm");
45 formatter.field("attrs", Lite(&self.value.attrs));
47 formatter.field("pat", Lite(&self.value.pat));
53 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
54 formatter.write_str("Some(")?;
55 Debug::fmt(Lite(&self.0.1), formatter)?;
56 formatter.write_str(")")?;
60 formatter.field("guard", Print::ref_cast(val));
62 formatter.field("body", Lite(&self.value.body));
64 formatter.field("comma", &Present);
66 formatter.finish()
70 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
71 let mut formatter = formatter.debug_struct("AssocConst");
72 formatter.field("ident", Lite(&self.value.ident));
78 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
79 formatter.write_str("Some(")?;
80 Debug::fmt(Lite(&self.0), formatter)?;
81 formatter.write_str(")")?;
85 formatter.field("generics", Print::ref_cast(val));
87 formatter.field("value", Lite(&self.value.value));
88 formatter.finish()
92 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
93 let mut formatter = formatter.debug_struct("AssocType");
94 formatter.field("ident", Lite(&self.value.ident));
100 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
101 formatter.write_str("Some(")?;
102 Debug::fmt(Lite(&self.0), formatter)?;
103 formatter.write_str(")")?;
107 formatter.field("generics", Print::ref_cast(val));
109 formatter.field("ty", Lite(&self.value.ty));
110 formatter.finish()
114 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
116 syn::AttrStyle::Outer => formatter.write_str("AttrStyle::Outer"),
118 formatter.write_str("AttrStyle::Inner")?;
125 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
126 let mut formatter = formatter.debug_struct("Attribute");
127 formatter.field("style", Lite(&self.value.style));
128 formatter.field("meta", Lite(&self.value.meta));
129 formatter.finish()
133 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
134 let mut formatter = formatter.debug_struct("BareFnArg");
136 formatter.field("attrs", Lite(&self.value.attrs));
143 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
144 formatter.write_str("Some(")?;
145 Debug::fmt(Lite(&self.0.0), formatter)?;
146 formatter.write_str(")")?;
150 formatter.field("name", Print::ref_cast(val));
152 formatter.field("ty", Lite(&self.value.ty));
153 formatter.finish()
157 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
158 let mut formatter = formatter.debug_struct("BareVariadic");
160 formatter.field("attrs", Lite(&self.value.attrs));
167 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
168 formatter.write_str("Some(")?;
169 Debug::fmt(Lite(&self.0.0), formatter)?;
170 formatter.write_str(")")?;
174 formatter.field("name", Print::ref_cast(val));
177 formatter.field("comma", &Present);
179 formatter.finish()
183 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
186 formatter.write_str("BinOp::Add")?;
190 formatter.write_str("BinOp::Sub")?;
194 formatter.write_str("BinOp::Mul")?;
198 formatter.write_str("BinOp::Div")?;
202 formatter.write_str("BinOp::Rem")?;
206 formatter.write_str("BinOp::And")?;
210 formatter.write_str("BinOp::Or")?;
214 formatter.write_str("BinOp::BitXor")?;
218 formatter.write_str("BinOp::BitAnd")?;
222 formatter.write_str("BinOp::BitOr")?;
226 formatter.write_str("BinOp::Shl")?;
230 formatter.write_str("BinOp::Shr")?;
234 formatter.write_str("BinOp::Eq")?;
238 formatter.write_str("BinOp::Lt")?;
242 formatter.write_str("BinOp::Le")?;
246 formatter.write_str("BinOp::Ne")?;
250 formatter.write_str("BinOp::Ge")?;
254 formatter.write_str("BinOp::Gt")?;
258 formatter.write_str("BinOp::AddAssign")?;
262 formatter.write_str("BinOp::SubAssign")?;
266 formatter.write_str("BinOp::MulAssign")?;
270 formatter.write_str("BinOp::DivAssign")?;
274 formatter.write_str("BinOp::RemAssign")?;
278 formatter.write_str("BinOp::BitXorAssign")?;
282 formatter.write_str("BinOp::BitAndAssign")?;
286 formatter.write_str("BinOp::BitOrAssign")?;
290 formatter.write_str("BinOp::ShlAssign")?;
294 formatter.write_str("BinOp::ShrAssign")?;
302 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
303 let mut formatter = formatter.debug_struct("Block");
304 formatter.field("stmts", Lite(&self.value.stmts));
305 formatter.finish()
309 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
310 let mut formatter = formatter.debug_struct("BoundLifetimes");
312 formatter.field("lifetimes", Lite(&self.value.lifetimes));
314 formatter.finish()
318 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
319 let mut formatter = formatter.debug_struct("ConstParam");
321 formatter.field("attrs", Lite(&self.value.attrs));
323 formatter.field("ident", Lite(&self.value.ident));
324 formatter.field("ty", Lite(&self.value.ty));
326 formatter.field("eq_token", &Present);
333 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
334 formatter.write_str("Some(")?;
335 Debug::fmt(Lite(&self.0), formatter)?;
336 formatter.write_str(")")?;
340 formatter.field("default", Print::ref_cast(val));
342 formatter.finish()
346 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
347 let mut formatter = formatter.debug_struct("Constraint");
348 formatter.field("ident", Lite(&self.value.ident));
354 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
355 formatter.write_str("Some(")?;
356 Debug::fmt(Lite(&self.0), formatter)?;
357 formatter.write_str(")")?;
361 formatter.field("generics", Print::ref_cast(val));
364 formatter.field("bounds", Lite(&self.value.bounds));
366 formatter.finish()
370 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
373 let mut formatter = formatter.debug_struct("Data::Struct");
374 formatter.field("fields", Lite(&_val.fields));
376 formatter.field("semi_token", &Present);
378 formatter.finish()
381 let mut formatter = formatter.debug_struct("Data::Enum");
383 formatter.field("variants", Lite(&_val.variants));
385 formatter.finish()
388 let mut formatter = formatter.debug_struct("Data::Union");
389 formatter.field("fields", Lite(&_val.fields));
390 formatter.finish()
396 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
397 let mut formatter = formatter.debug_struct("DataEnum");
399 formatter.field("variants", Lite(&self.value.variants));
401 formatter.finish()
405 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
406 let mut formatter = formatter.debug_struct("DataStruct");
407 formatter.field("fields", Lite(&self.value.fields));
409 formatter.field("semi_token", &Present);
411 formatter.finish()
415 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
416 let mut formatter = formatter.debug_struct("DataUnion");
417 formatter.field("fields", Lite(&self.value.fields));
418 formatter.finish()
422 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
423 let mut formatter = formatter.debug_struct("DeriveInput");
425 formatter.field("attrs", Lite(&self.value.attrs));
427 formatter.field("vis", Lite(&self.value.vis));
428 formatter.field("ident", Lite(&self.value.ident));
429 formatter.field("generics", Lite(&self.value.generics));
430 formatter.field("data", Lite(&self.value.data));
431 formatter.finish()
435 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
438 let mut formatter = formatter.debug_struct("Expr::Array");
440 formatter.field("attrs", Lite(&_val.attrs));
443 formatter.field("elems", Lite(&_val.elems));
445 formatter.finish()
448 let mut formatter = formatter.debug_struct("Expr::Assign");
450 formatter.field("attrs", Lite(&_val.attrs));
452 formatter.field("left", Lite(&_val.left));
453 formatter.field("right", Lite(&_val.right));
454 formatter.finish()
457 let mut formatter = formatter.debug_struct("Expr::Async");
459 formatter.field("attrs", Lite(&_val.attrs));
462 formatter.field("capture", &Present);
464 formatter.field("block", Lite(&_val.block));
465 formatter.finish()
468 let mut formatter = formatter.debug_struct("Expr::Await");
470 formatter.field("attrs", Lite(&_val.attrs));
472 formatter.field("base", Lite(&_val.base));
473 formatter.finish()
476 let mut formatter = formatter.debug_struct("Expr::Binary");
478 formatter.field("attrs", Lite(&_val.attrs));
480 formatter.field("left", Lite(&_val.left));
481 formatter.field("op", Lite(&_val.op));
482 formatter.field("right", Lite(&_val.right));
483 formatter.finish()
486 let mut formatter = formatter.debug_struct("Expr::Block");
488 formatter.field("attrs", Lite(&_val.attrs));
495 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
496 formatter.write_str("Some(")?;
497 Debug::fmt(Lite(&self.0), formatter)?;
498 formatter.write_str(")")?;
502 formatter.field("label", Print::ref_cast(val));
504 formatter.field("block", Lite(&_val.block));
505 formatter.finish()
508 let mut formatter = formatter.debug_struct("Expr::Break");
510 formatter.field("attrs", Lite(&_val.attrs));
517 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
518 formatter.write_str("Some(")?;
519 Debug::fmt(Lite(&self.0), formatter)?;
520 formatter.write_str(")")?;
524 formatter.field("label", Print::ref_cast(val));
531 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
532 formatter.write_str("Some(")?;
533 Debug::fmt(Lite(&self.0), formatter)?;
534 formatter.write_str(")")?;
538 formatter.field("expr", Print::ref_cast(val));
540 formatter.finish()
543 let mut formatter = formatter.debug_struct("Expr::Call");
545 formatter.field("attrs", Lite(&_val.attrs));
547 formatter.field("func", Lite(&_val.func));
549 formatter.field("args", Lite(&_val.args));
551 formatter.finish()
554 let mut formatter = formatter.debug_struct("Expr::Cast");
556 formatter.field("attrs", Lite(&_val.attrs));
558 formatter.field("expr", Lite(&_val.expr));
559 formatter.field("ty", Lite(&_val.ty));
560 formatter.finish()
563 let mut formatter = formatter.debug_struct("Expr::Closure");
565 formatter.field("attrs", Lite(&_val.attrs));
572 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
573 formatter.write_str("Some(")?;
574 Debug::fmt(Lite(&self.0), formatter)?;
575 formatter.write_str(")")?;
579 formatter.field("lifetimes", Print::ref_cast(val));
582 formatter.field("constness", &Present);
585 formatter.field("movability", &Present);
588 formatter.field("asyncness", &Present);
591 formatter.field("capture", &Present);
594 formatter.field("inputs", Lite(&_val.inputs));
596 formatter.field("output", Lite(&_val.output));
597 formatter.field("body", Lite(&_val.body));
598 formatter.finish()
601 let mut formatter = formatter.debug_struct("Expr::Const");
603 formatter.field("attrs", Lite(&_val.attrs));
605 formatter.field("block", Lite(&_val.block));
606 formatter.finish()
609 let mut formatter = formatter.debug_struct("Expr::Continue");
611 formatter.field("attrs", Lite(&_val.attrs));
618 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
619 formatter.write_str("Some(")?;
620 Debug::fmt(Lite(&self.0), formatter)?;
621 formatter.write_str(")")?;
625 formatter.field("label", Print::ref_cast(val));
627 formatter.finish()
630 let mut formatter = formatter.debug_struct("Expr::Field");
632 formatter.field("attrs", Lite(&_val.attrs));
634 formatter.field("base", Lite(&_val.base));
635 formatter.field("member", Lite(&_val.member));
636 formatter.finish()
639 let mut formatter = formatter.debug_struct("Expr::ForLoop");
641 formatter.field("attrs", Lite(&_val.attrs));
648 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
649 formatter.write_str("Some(")?;
650 Debug::fmt(Lite(&self.0), formatter)?;
651 formatter.write_str(")")?;
655 formatter.field("label", Print::ref_cast(val));
657 formatter.field("pat", Lite(&_val.pat));
658 formatter.field("expr", Lite(&_val.expr));
659 formatter.field("body", Lite(&_val.body));
660 formatter.finish()
663 let mut formatter = formatter.debug_struct("Expr::Group");
665 formatter.field("attrs", Lite(&_val.attrs));
667 formatter.field("expr", Lite(&_val.expr));
668 formatter.finish()
671 let mut formatter = formatter.debug_struct("Expr::If");
673 formatter.field("attrs", Lite(&_val.attrs));
675 formatter.field("cond", Lite(&_val.cond));
676 formatter.field("then_branch", Lite(&_val.then_branch));
682 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
683 formatter.write_str("Some(")?;
684 Debug::fmt(Lite(&self.0.1), formatter)?;
685 formatter.write_str(")")?;
689 formatter.field("else_branch", Print::ref_cast(val));
691 formatter.finish()
694 let mut formatter = formatter.debug_struct("Expr::Index");
696 formatter.field("attrs", Lite(&_val.attrs));
698 formatter.field("expr", Lite(&_val.expr));
699 formatter.field("index", Lite(&_val.index));
700 formatter.finish()
703 let mut formatter = formatter.debug_struct("Expr::Infer");
705 formatter.field("attrs", Lite(&_val.attrs));
707 formatter.finish()
710 let mut formatter = formatter.debug_struct("Expr::Let");
712 formatter.field("attrs", Lite(&_val.attrs));
714 formatter.field("pat", Lite(&_val.pat));
715 formatter.field("expr", Lite(&_val.expr));
716 formatter.finish()
719 let mut formatter = formatter.debug_struct("Expr::Lit");
721 formatter.field("attrs", Lite(&_val.attrs));
723 formatter.field("lit", Lite(&_val.lit));
724 formatter.finish()
727 let mut formatter = formatter.debug_struct("Expr::Loop");
729 formatter.field("attrs", Lite(&_val.attrs));
736 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
737 formatter.write_str("Some(")?;
738 Debug::fmt(Lite(&self.0), formatter)?;
739 formatter.write_str(")")?;
743 formatter.field("label", Print::ref_cast(val));
745 formatter.field("body", Lite(&_val.body));
746 formatter.finish()
749 let mut formatter = formatter.debug_struct("Expr::Macro");
751 formatter.field("attrs", Lite(&_val.attrs));
753 formatter.field("mac", Lite(&_val.mac));
754 formatter.finish()
757 let mut formatter = formatter.debug_struct("Expr::Match");
759 formatter.field("attrs", Lite(&_val.attrs));
761 formatter.field("expr", Lite(&_val.expr));
763 formatter.field("arms", Lite(&_val.arms));
765 formatter.finish()
768 let mut formatter = formatter.debug_struct("Expr::MethodCall");
770 formatter.field("attrs", Lite(&_val.attrs));
772 formatter.field("receiver", Lite(&_val.receiver));
773 formatter.field("method", Lite(&_val.method));
779 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
780 formatter.write_str("Some(")?;
781 Debug::fmt(Lite(&self.0), formatter)?;
782 formatter.write_str(")")?;
786 formatter.field("turbofish", Print::ref_cast(val));
789 formatter.field("args", Lite(&_val.args));
791 formatter.finish()
794 let mut formatter = formatter.debug_struct("Expr::Paren");
796 formatter.field("attrs", Lite(&_val.attrs));
798 formatter.field("expr", Lite(&_val.expr));
799 formatter.finish()
802 let mut formatter = formatter.debug_struct("Expr::Path");
804 formatter.field("attrs", Lite(&_val.attrs));
811 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
812 formatter.write_str("Some(")?;
813 Debug::fmt(Lite(&self.0), formatter)?;
814 formatter.write_str(")")?;
818 formatter.field("qself", Print::ref_cast(val));
820 formatter.field("path", Lite(&_val.path));
821 formatter.finish()
824 let mut formatter = formatter.debug_struct("Expr::Range");
826 formatter.field("attrs", Lite(&_val.attrs));
833 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
834 formatter.write_str("Some(")?;
835 Debug::fmt(Lite(&self.0), formatter)?;
836 formatter.write_str(")")?;
840 formatter.field("start", Print::ref_cast(val));
842 formatter.field("limits", Lite(&_val.limits));
848 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
849 formatter.write_str("Some(")?;
850 Debug::fmt(Lite(&self.0), formatter)?;
851 formatter.write_str(")")?;
855 formatter.field("end", Print::ref_cast(val));
857 formatter.finish()
860 let mut formatter = formatter.debug_struct("Expr::Reference");
862 formatter.field("attrs", Lite(&_val.attrs));
865 formatter.field("mutability", &Present);
867 formatter.field("expr", Lite(&_val.expr));
868 formatter.finish()
871 let mut formatter = formatter.debug_struct("Expr::Repeat");
873 formatter.field("attrs", Lite(&_val.attrs));
875 formatter.field("expr", Lite(&_val.expr));
876 formatter.field("len", Lite(&_val.len));
877 formatter.finish()
880 let mut formatter = formatter.debug_struct("Expr::Return");
882 formatter.field("attrs", Lite(&_val.attrs));
889 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
890 formatter.write_str("Some(")?;
891 Debug::fmt(Lite(&self.0), formatter)?;
892 formatter.write_str(")")?;
896 formatter.field("expr", Print::ref_cast(val));
898 formatter.finish()
901 let mut formatter = formatter.debug_struct("Expr::Struct");
903 formatter.field("attrs", Lite(&_val.attrs));
910 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
911 formatter.write_str("Some(")?;
912 Debug::fmt(Lite(&self.0), formatter)?;
913 formatter.write_str(")")?;
917 formatter.field("qself", Print::ref_cast(val));
919 formatter.field("path", Lite(&_val.path));
921 formatter.field("fields", Lite(&_val.fields));
924 formatter.field("dot2_token", &Present);
931 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
932 formatter.write_str("Some(")?;
933 Debug::fmt(Lite(&self.0), formatter)?;
934 formatter.write_str(")")?;
938 formatter.field("rest", Print::ref_cast(val));
940 formatter.finish()
943 let mut formatter = formatter.debug_struct("Expr::Try");
945 formatter.field("attrs", Lite(&_val.attrs));
947 formatter.field("expr", Lite(&_val.expr));
948 formatter.finish()
951 let mut formatter = formatter.debug_struct("Expr::TryBlock");
953 formatter.field("attrs", Lite(&_val.attrs));
955 formatter.field("block", Lite(&_val.block));
956 formatter.finish()
959 let mut formatter = formatter.debug_struct("Expr::Tuple");
961 formatter.field("attrs", Lite(&_val.attrs));
964 formatter.field("elems", Lite(&_val.elems));
966 formatter.finish()
969 let mut formatter = formatter.debug_struct("Expr::Unary");
971 formatter.field("attrs", Lite(&_val.attrs));
973 formatter.field("op", Lite(&_val.op));
974 formatter.field("expr", Lite(&_val.expr));
975 formatter.finish()
978 let mut formatter = formatter.debug_struct("Expr::Unsafe");
980 formatter.field("attrs", Lite(&_val.attrs));
982 formatter.field("block", Lite(&_val.block));
983 formatter.finish()
986 formatter.write_str("Expr::Verbatim")?;
987 formatter.write_str("(`")?;
988 Display::fmt(_val, formatter)?;
989 formatter.write_str("`)")?;
993 let mut formatter = formatter.debug_struct("Expr::While");
995 formatter.field("attrs", Lite(&_val.attrs));
1002 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1003 formatter.write_str("Some(")?;
1004 Debug::fmt(Lite(&self.0), formatter)?;
1005 formatter.write_str(")")?;
1009 formatter.field("label", Print::ref_cast(val));
1011 formatter.field("cond", Lite(&_val.cond));
1012 formatter.field("body", Lite(&_val.body));
1013 formatter.finish()
1016 let mut formatter = formatter.debug_struct("Expr::Yield");
1018 formatter.field("attrs", Lite(&_val.attrs));
1025 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1026 formatter.write_str("Some(")?;
1027 Debug::fmt(Lite(&self.0), formatter)?;
1028 formatter.write_str(")")?;
1032 formatter.field("expr", Print::ref_cast(val));
1034 formatter.finish()
1041 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1042 let mut formatter = formatter.debug_struct("ExprArray");
1044 formatter.field("attrs", Lite(&self.value.attrs));
1047 formatter.field("elems", Lite(&self.value.elems));
1049 formatter.finish()
1053 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1054 let mut formatter = formatter.debug_struct("ExprAssign");
1056 formatter.field("attrs", Lite(&self.value.attrs));
1058 formatter.field("left", Lite(&self.value.left));
1059 formatter.field("right", Lite(&self.value.right));
1060 formatter.finish()
1064 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1065 let mut formatter = formatter.debug_struct("ExprAsync");
1067 formatter.field("attrs", Lite(&self.value.attrs));
1070 formatter.field("capture", &Present);
1072 formatter.field("block", Lite(&self.value.block));
1073 formatter.finish()
1077 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1078 let mut formatter = formatter.debug_struct("ExprAwait");
1080 formatter.field("attrs", Lite(&self.value.attrs));
1082 formatter.field("base", Lite(&self.value.base));
1083 formatter.finish()
1087 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1088 let mut formatter = formatter.debug_struct("ExprBinary");
1090 formatter.field("attrs", Lite(&self.value.attrs));
1092 formatter.field("left", Lite(&self.value.left));
1093 formatter.field("op", Lite(&self.value.op));
1094 formatter.field("right", Lite(&self.value.right));
1095 formatter.finish()
1099 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1100 let mut formatter = formatter.debug_struct("ExprBlock");
1102 formatter.field("attrs", Lite(&self.value.attrs));
1109 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1110 formatter.write_str("Some(")?;
1111 Debug::fmt(Lite(&self.0), formatter)?;
1112 formatter.write_str(")")?;
1116 formatter.field("label", Print::ref_cast(val));
1118 formatter.field("block", Lite(&self.value.block));
1119 formatter.finish()
1123 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1124 let mut formatter = formatter.debug_struct("ExprBreak");
1126 formatter.field("attrs", Lite(&self.value.attrs));
1133 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1134 formatter.write_str("Some(")?;
1135 Debug::fmt(Lite(&self.0), formatter)?;
1136 formatter.write_str(")")?;
1140 formatter.field("label", Print::ref_cast(val));
1147 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1148 formatter.write_str("Some(")?;
1149 Debug::fmt(Lite(&self.0), formatter)?;
1150 formatter.write_str(")")?;
1154 formatter.field("expr", Print::ref_cast(val));
1156 formatter.finish()
1160 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1161 let mut formatter = formatter.debug_struct("ExprCall");
1163 formatter.field("attrs", Lite(&self.value.attrs));
1165 formatter.field("func", Lite(&self.value.func));
1167 formatter.field("args", Lite(&self.value.args));
1169 formatter.finish()
1173 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1174 let mut formatter = formatter.debug_struct("ExprCast");
1176 formatter.field("attrs", Lite(&self.value.attrs));
1178 formatter.field("expr", Lite(&self.value.expr));
1179 formatter.field("ty", Lite(&self.value.ty));
1180 formatter.finish()
1184 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1185 let mut formatter = formatter.debug_struct("ExprClosure");
1187 formatter.field("attrs", Lite(&self.value.attrs));
1194 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1195 formatter.write_str("Some(")?;
1196 Debug::fmt(Lite(&self.0), formatter)?;
1197 formatter.write_str(")")?;
1201 formatter.field("lifetimes", Print::ref_cast(val));
1204 formatter.field("constness", &Present);
1207 formatter.field("movability", &Present);
1210 formatter.field("asyncness", &Present);
1213 formatter.field("capture", &Present);
1216 formatter.field("inputs", Lite(&self.value.inputs));
1218 formatter.field("output", Lite(&self.value.output));
1219 formatter.field("body", Lite(&self.value.body));
1220 formatter.finish()
1224 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1225 let mut formatter = formatter.debug_struct("ExprConst");
1227 formatter.field("attrs", Lite(&self.value.attrs));
1229 formatter.field("block", Lite(&self.value.block));
1230 formatter.finish()
1234 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1235 let mut formatter = formatter.debug_struct("ExprContinue");
1237 formatter.field("attrs", Lite(&self.value.attrs));
1244 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1245 formatter.write_str("Some(")?;
1246 Debug::fmt(Lite(&self.0), formatter)?;
1247 formatter.write_str(")")?;
1251 formatter.field("label", Print::ref_cast(val));
1253 formatter.finish()
1257 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1258 let mut formatter = formatter.debug_struct("ExprField");
1260 formatter.field("attrs", Lite(&self.value.attrs));
1262 formatter.field("base", Lite(&self.value.base));
1263 formatter.field("member", Lite(&self.value.member));
1264 formatter.finish()
1268 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1269 let mut formatter = formatter.debug_struct("ExprForLoop");
1271 formatter.field("attrs", Lite(&self.value.attrs));
1278 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1279 formatter.write_str("Some(")?;
1280 Debug::fmt(Lite(&self.0), formatter)?;
1281 formatter.write_str(")")?;
1285 formatter.field("label", Print::ref_cast(val));
1287 formatter.field("pat", Lite(&self.value.pat));
1288 formatter.field("expr", Lite(&self.value.expr));
1289 formatter.field("body", Lite(&self.value.body));
1290 formatter.finish()
1294 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1295 let mut formatter = formatter.debug_struct("ExprGroup");
1297 formatter.field("attrs", Lite(&self.value.attrs));
1299 formatter.field("expr", Lite(&self.value.expr));
1300 formatter.finish()
1304 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1305 let mut formatter = formatter.debug_struct("ExprIf");
1307 formatter.field("attrs", Lite(&self.value.attrs));
1309 formatter.field("cond", Lite(&self.value.cond));
1310 formatter.field("then_branch", Lite(&self.value.then_branch));
1316 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1317 formatter.write_str("Some(")?;
1318 Debug::fmt(Lite(&self.0.1), formatter)?;
1319 formatter.write_str(")")?;
1323 formatter.field("else_branch", Print::ref_cast(val));
1325 formatter.finish()
1329 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1330 let mut formatter = formatter.debug_struct("ExprIndex");
1332 formatter.field("attrs", Lite(&self.value.attrs));
1334 formatter.field("expr", Lite(&self.value.expr));
1335 formatter.field("index", Lite(&self.value.index));
1336 formatter.finish()
1340 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1341 let mut formatter = formatter.debug_struct("ExprInfer");
1343 formatter.field("attrs", Lite(&self.value.attrs));
1345 formatter.finish()
1349 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1350 let mut formatter = formatter.debug_struct("ExprLet");
1352 formatter.field("attrs", Lite(&self.value.attrs));
1354 formatter.field("pat", Lite(&self.value.pat));
1355 formatter.field("expr", Lite(&self.value.expr));
1356 formatter.finish()
1360 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1361 let mut formatter = formatter.debug_struct("ExprLit");
1363 formatter.field("attrs", Lite(&self.value.attrs));
1365 formatter.field("lit", Lite(&self.value.lit));
1366 formatter.finish()
1370 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1371 let mut formatter = formatter.debug_struct("ExprLoop");
1373 formatter.field("attrs", Lite(&self.value.attrs));
1380 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1381 formatter.write_str("Some(")?;
1382 Debug::fmt(Lite(&self.0), formatter)?;
1383 formatter.write_str(")")?;
1387 formatter.field("label", Print::ref_cast(val));
1389 formatter.field("body", Lite(&self.value.body));
1390 formatter.finish()
1394 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1395 let mut formatter = formatter.debug_struct("ExprMacro");
1397 formatter.field("attrs", Lite(&self.value.attrs));
1399 formatter.field("mac", Lite(&self.value.mac));
1400 formatter.finish()
1404 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1405 let mut formatter = formatter.debug_struct("ExprMatch");
1407 formatter.field("attrs", Lite(&self.value.attrs));
1409 formatter.field("expr", Lite(&self.value.expr));
1411 formatter.field("arms", Lite(&self.value.arms));
1413 formatter.finish()
1417 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1418 let mut formatter = formatter.debug_struct("ExprMethodCall");
1420 formatter.field("attrs", Lite(&self.value.attrs));
1422 formatter.field("receiver", Lite(&self.value.receiver));
1423 formatter.field("method", Lite(&self.value.method));
1429 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1430 formatter.write_str("Some(")?;
1431 Debug::fmt(Lite(&self.0), formatter)?;
1432 formatter.write_str(")")?;
1436 formatter.field("turbofish", Print::ref_cast(val));
1439 formatter.field("args", Lite(&self.value.args));
1441 formatter.finish()
1445 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1446 let mut formatter = formatter.debug_struct("ExprParen");
1448 formatter.field("attrs", Lite(&self.value.attrs));
1450 formatter.field("expr", Lite(&self.value.expr));
1451 formatter.finish()
1455 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1456 let mut formatter = formatter.debug_struct("ExprPath");
1458 formatter.field("attrs", Lite(&self.value.attrs));
1465 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1466 formatter.write_str("Some(")?;
1467 Debug::fmt(Lite(&self.0), formatter)?;
1468 formatter.write_str(")")?;
1472 formatter.field("qself", Print::ref_cast(val));
1474 formatter.field("path", Lite(&self.value.path));
1475 formatter.finish()
1479 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1480 let mut formatter = formatter.debug_struct("ExprRange");
1482 formatter.field("attrs", Lite(&self.value.attrs));
1489 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1490 formatter.write_str("Some(")?;
1491 Debug::fmt(Lite(&self.0), formatter)?;
1492 formatter.write_str(")")?;
1496 formatter.field("start", Print::ref_cast(val));
1498 formatter.field("limits", Lite(&self.value.limits));
1504 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1505 formatter.write_str("Some(")?;
1506 Debug::fmt(Lite(&self.0), formatter)?;
1507 formatter.write_str(")")?;
1511 formatter.field("end", Print::ref_cast(val));
1513 formatter.finish()
1517 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1518 let mut formatter = formatter.debug_struct("ExprReference");
1520 formatter.field("attrs", Lite(&self.value.attrs));
1523 formatter.field("mutability", &Present);
1525 formatter.field("expr", Lite(&self.value.expr));
1526 formatter.finish()
1530 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1531 let mut formatter = formatter.debug_struct("ExprRepeat");
1533 formatter.field("attrs", Lite(&self.value.attrs));
1535 formatter.field("expr", Lite(&self.value.expr));
1536 formatter.field("len", Lite(&self.value.len));
1537 formatter.finish()
1541 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1542 let mut formatter = formatter.debug_struct("ExprReturn");
1544 formatter.field("attrs", Lite(&self.value.attrs));
1551 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1552 formatter.write_str("Some(")?;
1553 Debug::fmt(Lite(&self.0), formatter)?;
1554 formatter.write_str(")")?;
1558 formatter.field("expr", Print::ref_cast(val));
1560 formatter.finish()
1564 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1565 let mut formatter = formatter.debug_struct("ExprStruct");
1567 formatter.field("attrs", Lite(&self.value.attrs));
1574 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1575 formatter.write_str("Some(")?;
1576 Debug::fmt(Lite(&self.0), formatter)?;
1577 formatter.write_str(")")?;
1581 formatter.field("qself", Print::ref_cast(val));
1583 formatter.field("path", Lite(&self.value.path));
1585 formatter.field("fields", Lite(&self.value.fields));
1588 formatter.field("dot2_token", &Present);
1595 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1596 formatter.write_str("Some(")?;
1597 Debug::fmt(Lite(&self.0), formatter)?;
1598 formatter.write_str(")")?;
1602 formatter.field("rest", Print::ref_cast(val));
1604 formatter.finish()
1608 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1609 let mut formatter = formatter.debug_struct("ExprTry");
1611 formatter.field("attrs", Lite(&self.value.attrs));
1613 formatter.field("expr", Lite(&self.value.expr));
1614 formatter.finish()
1618 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1619 let mut formatter = formatter.debug_struct("ExprTryBlock");
1621 formatter.field("attrs", Lite(&self.value.attrs));
1623 formatter.field("block", Lite(&self.value.block));
1624 formatter.finish()
1628 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1629 let mut formatter = formatter.debug_struct("ExprTuple");
1631 formatter.field("attrs", Lite(&self.value.attrs));
1634 formatter.field("elems", Lite(&self.value.elems));
1636 formatter.finish()
1640 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1641 let mut formatter = formatter.debug_struct("ExprUnary");
1643 formatter.field("attrs", Lite(&self.value.attrs));
1645 formatter.field("op", Lite(&self.value.op));
1646 formatter.field("expr", Lite(&self.value.expr));
1647 formatter.finish()
1651 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1652 let mut formatter = formatter.debug_struct("ExprUnsafe");
1654 formatter.field("attrs", Lite(&self.value.attrs));
1656 formatter.field("block", Lite(&self.value.block));
1657 formatter.finish()
1661 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1662 let mut formatter = formatter.debug_struct("ExprWhile");
1664 formatter.field("attrs", Lite(&self.value.attrs));
1671 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1672 formatter.write_str("Some(")?;
1673 Debug::fmt(Lite(&self.0), formatter)?;
1674 formatter.write_str(")")?;
1678 formatter.field("label", Print::ref_cast(val));
1680 formatter.field("cond", Lite(&self.value.cond));
1681 formatter.field("body", Lite(&self.value.body));
1682 formatter.finish()
1686 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1687 let mut formatter = formatter.debug_struct("ExprYield");
1689 formatter.field("attrs", Lite(&self.value.attrs));
1696 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1697 formatter.write_str("Some(")?;
1698 Debug::fmt(Lite(&self.0), formatter)?;
1699 formatter.write_str(")")?;
1703 formatter.field("expr", Print::ref_cast(val));
1705 formatter.finish()
1709 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1710 let mut formatter = formatter.debug_struct("Field");
1712 formatter.field("attrs", Lite(&self.value.attrs));
1714 formatter.field("vis", Lite(&self.value.vis));
1718 formatter.field("mutability", Lite(&self.value.mutability));
1726 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1727 formatter.write_str("Some(")?;
1728 Debug::fmt(Lite(&self.0), formatter)?;
1729 formatter.write_str(")")?;
1733 formatter.field("ident", Print::ref_cast(val));
1736 formatter.field("colon_token", &Present);
1738 formatter.field("ty", Lite(&self.value.ty));
1739 formatter.finish()
1743 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1745 syn::FieldMutability::None => formatter.write_str("FieldMutability::None"),
1751 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1752 let mut formatter = formatter.debug_struct("FieldPat");
1754 formatter.field("attrs", Lite(&self.value.attrs));
1756 formatter.field("member", Lite(&self.value.member));
1758 formatter.field("colon_token", &Present);
1760 formatter.field("pat", Lite(&self.value.pat));
1761 formatter.finish()
1765 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1766 let mut formatter = formatter.debug_struct("FieldValue");
1768 formatter.field("attrs", Lite(&self.value.attrs));
1770 formatter.field("member", Lite(&self.value.member));
1772 formatter.field("colon_token", &Present);
1774 formatter.field("expr", Lite(&self.value.expr));
1775 formatter.finish()
1779 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1782 let mut formatter = formatter.debug_struct("Fields::Named");
1784 formatter.field("named", Lite(&_val.named));
1786 formatter.finish()
1789 let mut formatter = formatter.debug_struct("Fields::Unnamed");
1791 formatter.field("unnamed", Lite(&_val.unnamed));
1793 formatter.finish()
1795 syn::Fields::Unit => formatter.write_str("Fields::Unit"),
1800 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1801 let mut formatter = formatter.debug_struct("FieldsNamed");
1803 formatter.field("named", Lite(&self.value.named));
1805 formatter.finish()
1809 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1810 let mut formatter = formatter.debug_struct("FieldsUnnamed");
1812 formatter.field("unnamed", Lite(&self.value.unnamed));
1814 formatter.finish()
1818 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1819 let mut formatter = formatter.debug_struct("File");
1825 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1826 formatter.write_str("Some(")?;
1827 Debug::fmt(Lite(&self.0), formatter)?;
1828 formatter.write_str(")")?;
1832 formatter.field("shebang", Print::ref_cast(val));
1835 formatter.field("attrs", Lite(&self.value.attrs));
1838 formatter.field("items", Lite(&self.value.items));
1840 formatter.finish()
1844 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1847 formatter.write_str("FnArg::Receiver")?;
1848 formatter.write_str("(")?;
1849 Debug::fmt(Lite(_val), formatter)?;
1850 formatter.write_str(")")?;
1854 formatter.write_str("FnArg::Typed")?;
1855 formatter.write_str("(")?;
1856 Debug::fmt(Lite(_val), formatter)?;
1857 formatter.write_str(")")?;
1864 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1867 let mut formatter = formatter.debug_struct("ForeignItem::Fn");
1869 formatter.field("attrs", Lite(&_val.attrs));
1871 formatter.field("vis", Lite(&_val.vis));
1872 formatter.field("sig", Lite(&_val.sig));
1873 formatter.finish()
1876 let mut formatter = formatter.debug_struct("ForeignItem::Static");
1878 formatter.field("attrs", Lite(&_val.attrs));
1880 formatter.field("vis", Lite(&_val.vis));
1884 formatter.field("mutability", Lite(&_val.mutability));
1887 formatter.field("ident", Lite(&_val.ident));
1888 formatter.field("ty", Lite(&_val.ty));
1889 formatter.finish()
1892 let mut formatter = formatter.debug_struct("ForeignItem::Type");
1894 formatter.field("attrs", Lite(&_val.attrs));
1896 formatter.field("vis", Lite(&_val.vis));
1897 formatter.field("ident", Lite(&_val.ident));
1898 formatter.field("generics", Lite(&_val.generics));
1899 formatter.finish()
1902 let mut formatter = formatter.debug_struct("ForeignItem::Macro");
1904 formatter.field("attrs", Lite(&_val.attrs));
1906 formatter.field("mac", Lite(&_val.mac));
1908 formatter.field("semi_token", &Present);
1910 formatter.finish()
1913 formatter.write_str("ForeignItem::Verbatim")?;
1914 formatter.write_str("(`")?;
1915 Display::fmt(_val, formatter)?;
1916 formatter.write_str("`)")?;
1924 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1925 let mut formatter = formatter.debug_struct("ForeignItemFn");
1927 formatter.field("attrs", Lite(&self.value.attrs));
1929 formatter.field("vis", Lite(&self.value.vis));
1930 formatter.field("sig", Lite(&self.value.sig));
1931 formatter.finish()
1935 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1936 let mut formatter = formatter.debug_struct("ForeignItemMacro");
1938 formatter.field("attrs", Lite(&self.value.attrs));
1940 formatter.field("mac", Lite(&self.value.mac));
1942 formatter.field("semi_token", &Present);
1944 formatter.finish()
1948 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1949 let mut formatter = formatter.debug_struct("ForeignItemStatic");
1951 formatter.field("attrs", Lite(&self.value.attrs));
1953 formatter.field("vis", Lite(&self.value.vis));
1957 formatter.field("mutability", Lite(&self.value.mutability));
1960 formatter.field("ident", Lite(&self.value.ident));
1961 formatter.field("ty", Lite(&self.value.ty));
1962 formatter.finish()
1966 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1967 let mut formatter = formatter.debug_struct("ForeignItemType");
1969 formatter.field("attrs", Lite(&self.value.attrs));
1971 formatter.field("vis", Lite(&self.value.vis));
1972 formatter.field("ident", Lite(&self.value.ident));
1973 formatter.field("generics", Lite(&self.value.generics));
1974 formatter.finish()
1978 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1981 formatter.write_str("GenericArgument::Lifetime")?;
1982 formatter.write_str("(")?;
1983 Debug::fmt(Lite(_val), formatter)?;
1984 formatter.write_str(")")?;
1988 formatter.write_str("GenericArgument::Type")?;
1989 formatter.write_str("(")?;
1990 Debug::fmt(Lite(_val), formatter)?;
1991 formatter.write_str(")")?;
1995 formatter.write_str("GenericArgument::Const")?;
1996 formatter.write_str("(")?;
1997 Debug::fmt(Lite(_val), formatter)?;
1998 formatter.write_str(")")?;
2002 formatter.write_str("GenericArgument::AssocType")?;
2003 formatter.write_str("(")?;
2004 Debug::fmt(Lite(_val), formatter)?;
2005 formatter.write_str(")")?;
2009 formatter.write_str("GenericArgument::AssocConst")?;
2010 formatter.write_str("(")?;
2011 Debug::fmt(Lite(_val), formatter)?;
2012 formatter.write_str(")")?;
2016 formatter.write_str("GenericArgument::Constraint")?;
2017 formatter.write_str("(")?;
2018 Debug::fmt(Lite(_val), formatter)?;
2019 formatter.write_str(")")?;
2027 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2030 formatter.write_str("GenericParam::Lifetime")?;
2031 formatter.write_str("(")?;
2032 Debug::fmt(Lite(_val), formatter)?;
2033 formatter.write_str(")")?;
2037 formatter.write_str("GenericParam::Type")?;
2038 formatter.write_str("(")?;
2039 Debug::fmt(Lite(_val), formatter)?;
2040 formatter.write_str(")")?;
2044 formatter.write_str("GenericParam::Const")?;
2045 formatter.write_str("(")?;
2046 Debug::fmt(Lite(_val), formatter)?;
2047 formatter.write_str(")")?;
2054 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2055 let mut formatter = formatter.debug_struct("Generics");
2057 formatter.field("lt_token", &Present);
2060 formatter.field("params", Lite(&self.value.params));
2063 formatter.field("gt_token", &Present);
2070 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2071 formatter.write_str("Some(")?;
2072 Debug::fmt(Lite(&self.0), formatter)?;
2073 formatter.write_str(")")?;
2077 formatter.field("where_clause", Print::ref_cast(val));
2079 formatter.finish()
2083 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2086 let mut formatter = formatter.debug_struct("ImplItem::Const");
2088 formatter.field("attrs", Lite(&_val.attrs));
2090 formatter.field("vis", Lite(&_val.vis));
2092 formatter.field("defaultness", &Present);
2094 formatter.field("ident", Lite(&_val.ident));
2095 formatter.field("generics", Lite(&_val.generics));
2096 formatter.field("ty", Lite(&_val.ty));
2097 formatter.field("expr", Lite(&_val.expr));
2098 formatter.finish()
2101 let mut formatter = formatter.debug_struct("ImplItem::Fn");
2103 formatter.field("attrs", Lite(&_val.attrs));
2105 formatter.field("vis", Lite(&_val.vis));
2107 formatter.field("defaultness", &Present);
2109 formatter.field("sig", Lite(&_val.sig));
2110 formatter.field("block", Lite(&_val.block));
2111 formatter.finish()
2114 let mut formatter = formatter.debug_struct("ImplItem::Type");
2116 formatter.field("attrs", Lite(&_val.attrs));
2118 formatter.field("vis", Lite(&_val.vis));
2120 formatter.field("defaultness", &Present);
2122 formatter.field("ident", Lite(&_val.ident));
2123 formatter.field("generics", Lite(&_val.generics));
2124 formatter.field("ty", Lite(&_val.ty));
2125 formatter.finish()
2128 let mut formatter = formatter.debug_struct("ImplItem::Macro");
2130 formatter.field("attrs", Lite(&_val.attrs));
2132 formatter.field("mac", Lite(&_val.mac));
2134 formatter.field("semi_token", &Present);
2136 formatter.finish()
2139 formatter.write_str("ImplItem::Verbatim")?;
2140 formatter.write_str("(`")?;
2141 Display::fmt(_val, formatter)?;
2142 formatter.write_str("`)")?;
2150 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2151 let mut formatter = formatter.debug_struct("ImplItemConst");
2153 formatter.field("attrs", Lite(&self.value.attrs));
2155 formatter.field("vis", Lite(&self.value.vis));
2157 formatter.field("defaultness", &Present);
2159 formatter.field("ident", Lite(&self.value.ident));
2160 formatter.field("generics", Lite(&self.value.generics));
2161 formatter.field("ty", Lite(&self.value.ty));
2162 formatter.field("expr", Lite(&self.value.expr));
2163 formatter.finish()
2167 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2168 let mut formatter = formatter.debug_struct("ImplItemFn");
2170 formatter.field("attrs", Lite(&self.value.attrs));
2172 formatter.field("vis", Lite(&self.value.vis));
2174 formatter.field("defaultness", &Present);
2176 formatter.field("sig", Lite(&self.value.sig));
2177 formatter.field("block", Lite(&self.value.block));
2178 formatter.finish()
2182 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2183 let mut formatter = formatter.debug_struct("ImplItemMacro");
2185 formatter.field("attrs", Lite(&self.value.attrs));
2187 formatter.field("mac", Lite(&self.value.mac));
2189 formatter.field("semi_token", &Present);
2191 formatter.finish()
2195 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2196 let mut formatter = formatter.debug_struct("ImplItemType");
2198 formatter.field("attrs", Lite(&self.value.attrs));
2200 formatter.field("vis", Lite(&self.value.vis));
2202 formatter.field("defaultness", &Present);
2204 formatter.field("ident", Lite(&self.value.ident));
2205 formatter.field("generics", Lite(&self.value.generics));
2206 formatter.field("ty", Lite(&self.value.ty));
2207 formatter.finish()
2216 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2217 let mut formatter = formatter.debug_struct("Index");
2218 formatter.field("index", Lite(&self.value.index));
2219 formatter.finish()
2223 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2226 let mut formatter = formatter.debug_struct("Item::Const");
2228 formatter.field("attrs", Lite(&_val.attrs));
2230 formatter.field("vis", Lite(&_val.vis));
2231 formatter.field("ident", Lite(&_val.ident));
2232 formatter.field("generics", Lite(&_val.generics));
2233 formatter.field("ty", Lite(&_val.ty));
2234 formatter.field("expr", Lite(&_val.expr));
2235 formatter.finish()
2238 let mut formatter = formatter.debug_struct("Item::Enum");
2240 formatter.field("attrs", Lite(&_val.attrs));
2242 formatter.field("vis", Lite(&_val.vis));
2243 formatter.field("ident", Lite(&_val.ident));
2244 formatter.field("generics", Lite(&_val.generics));
2246 formatter.field("variants", Lite(&_val.variants));
2248 formatter.finish()
2251 let mut formatter = formatter.debug_struct("Item::ExternCrate");
2253 formatter.field("attrs", Lite(&_val.attrs));
2255 formatter.field("vis", Lite(&_val.vis));
2256 formatter.field("ident", Lite(&_val.ident));
2262 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2263 formatter.write_str("Some(")?;
2264 Debug::fmt(Lite(&self.0.1), formatter)?;
2265 formatter.write_str(")")?;
2269 formatter.field("rename", Print::ref_cast(val));
2271 formatter.finish()
2274 let mut formatter = formatter.debug_struct("Item::Fn");
2276 formatter.field("attrs", Lite(&_val.attrs));
2278 formatter.field("vis", Lite(&_val.vis));
2279 formatter.field("sig", Lite(&_val.sig));
2280 formatter.field("block", Lite(&_val.block));
2281 formatter.finish()
2284 let mut formatter = formatter.debug_struct("Item::ForeignMod");
2286 formatter.field("attrs", Lite(&_val.attrs));
2289 formatter.field("unsafety", &Present);
2291 formatter.field("abi", Lite(&_val.abi));
2293 formatter.field("items", Lite(&_val.items));
2295 formatter.finish()
2298 let mut formatter = formatter.debug_struct("Item::Impl");
2300 formatter.field("attrs", Lite(&_val.attrs));
2303 formatter.field("defaultness", &Present);
2306 formatter.field("unsafety", &Present);
2308 formatter.field("generics", Lite(&_val.generics));
2314 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2315 formatter.write_str("Some(")?;
2323 formatter,
2325 formatter.write_str(")")?;
2329 formatter.field("trait_", Print::ref_cast(val));
2331 formatter.field("self_ty", Lite(&_val.self_ty));
2333 formatter.field("items", Lite(&_val.items));
2335 formatter.finish()
2338 let mut formatter = formatter.debug_struct("Item::Macro");
2340 formatter.field("attrs", Lite(&_val.attrs));
2347 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2348 formatter.write_str("Some(")?;
2349 Debug::fmt(Lite(&self.0), formatter)?;
2350 formatter.write_str(")")?;
2354 formatter.field("ident", Print::ref_cast(val));
2356 formatter.field("mac", Lite(&_val.mac));
2358 formatter.field("semi_token", &Present);
2360 formatter.finish()
2363 let mut formatter = formatter.debug_struct("Item::Mod");
2365 formatter.field("attrs", Lite(&_val.attrs));
2367 formatter.field("vis", Lite(&_val.vis));
2369 formatter.field("unsafety", &Present);
2371 formatter.field("ident", Lite(&_val.ident));
2377 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2378 formatter.write_str("Some(")?;
2379 Debug::fmt(Lite(&self.0.1), formatter)?;
2380 formatter.write_str(")")?;
2384 formatter.field("content", Print::ref_cast(val));
2387 formatter.field("semi", &Present);
2389 formatter.finish()
2392 let mut formatter = formatter.debug_struct("Item::Static");
2394 formatter.field("attrs", Lite(&_val.attrs));
2396 formatter.field("vis", Lite(&_val.vis));
2400 formatter.field("mutability", Lite(&_val.mutability));
2403 formatter.field("ident", Lite(&_val.ident));
2404 formatter.field("ty", Lite(&_val.ty));
2405 formatter.field("expr", Lite(&_val.expr));
2406 formatter.finish()
2409 let mut formatter = formatter.debug_struct("Item::Struct");
2411 formatter.field("attrs", Lite(&_val.attrs));
2413 formatter.field("vis", Lite(&_val.vis));
2414 formatter.field("ident", Lite(&_val.ident));
2415 formatter.field("generics", Lite(&_val.generics));
2416 formatter.field("fields", Lite(&_val.fields));
2418 formatter.field("semi_token", &Present);
2420 formatter.finish()
2423 let mut formatter = formatter.debug_struct("Item::Trait");
2425 formatter.field("attrs", Lite(&_val.attrs));
2427 formatter.field("vis", Lite(&_val.vis));
2429 formatter.field("unsafety", &Present);
2432 formatter.field("auto_token", &Present);
2439 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2440 formatter.write_str("Some(")?;
2441 Debug::fmt(Lite(&self.0), formatter)?;
2442 formatter.write_str(")")?;
2446 formatter.field("restriction", Print::ref_cast(val));
2448 formatter.field("ident", Lite(&_val.ident));
2449 formatter.field("generics", Lite(&_val.generics));
2451 formatter.field("colon_token", &Present);
2454 formatter.field("supertraits", Lite(&_val.supertraits));
2457 formatter.field("items", Lite(&_val.items));
2459 formatter.finish()
2462 let mut formatter = formatter.debug_struct("Item::TraitAlias");
2464 formatter.field("attrs", Lite(&_val.attrs));
2466 formatter.field("vis", Lite(&_val.vis));
2467 formatter.field("ident", Lite(&_val.ident));
2468 formatter.field("generics", Lite(&_val.generics));
2470 formatter.field("bounds", Lite(&_val.bounds));
2472 formatter.finish()
2475 let mut formatter = formatter.debug_struct("Item::Type");
2477 formatter.field("attrs", Lite(&_val.attrs));
2479 formatter.field("vis", Lite(&_val.vis));
2480 formatter.field("ident", Lite(&_val.ident));
2481 formatter.field("generics", Lite(&_val.generics));
2482 formatter.field("ty", Lite(&_val.ty));
2483 formatter.finish()
2486 let mut formatter = formatter.debug_struct("Item::Union");
2488 formatter.field("attrs", Lite(&_val.attrs));
2490 formatter.field("vis", Lite(&_val.vis));
2491 formatter.field("ident", Lite(&_val.ident));
2492 formatter.field("generics", Lite(&_val.generics));
2493 formatter.field("fields", Lite(&_val.fields));
2494 formatter.finish()
2497 let mut formatter = formatter.debug_struct("Item::Use");
2499 formatter.field("attrs", Lite(&_val.attrs));
2501 formatter.field("vis", Lite(&_val.vis));
2503 formatter.field("leading_colon", &Present);
2505 formatter.field("tree", Lite(&_val.tree));
2506 formatter.finish()
2509 formatter.write_str("Item::Verbatim")?;
2510 formatter.write_str("(`")?;
2511 Display::fmt(_val, formatter)?;
2512 formatter.write_str("`)")?;
2520 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2521 let mut formatter = formatter.debug_struct("ItemConst");
2523 formatter.field("attrs", Lite(&self.value.attrs));
2525 formatter.field("vis", Lite(&self.value.vis));
2526 formatter.field("ident", Lite(&self.value.ident));
2527 formatter.field("generics", Lite(&self.value.generics));
2528 formatter.field("ty", Lite(&self.value.ty));
2529 formatter.field("expr", Lite(&self.value.expr));
2530 formatter.finish()
2534 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2535 let mut formatter = formatter.debug_struct("ItemEnum");
2537 formatter.field("attrs", Lite(&self.value.attrs));
2539 formatter.field("vis", Lite(&self.value.vis));
2540 formatter.field("ident", Lite(&self.value.ident));
2541 formatter.field("generics", Lite(&self.value.generics));
2543 formatter.field("variants", Lite(&self.value.variants));
2545 formatter.finish()
2549 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2550 let mut formatter = formatter.debug_struct("ItemExternCrate");
2552 formatter.field("attrs", Lite(&self.value.attrs));
2554 formatter.field("vis", Lite(&self.value.vis));
2555 formatter.field("ident", Lite(&self.value.ident));
2561 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2562 formatter.write_str("Some(")?;
2563 Debug::fmt(Lite(&self.0.1), formatter)?;
2564 formatter.write_str(")")?;
2568 formatter.field("rename", Print::ref_cast(val));
2570 formatter.finish()
2574 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2575 let mut formatter = formatter.debug_struct("ItemFn");
2577 formatter.field("attrs", Lite(&self.value.attrs));
2579 formatter.field("vis", Lite(&self.value.vis));
2580 formatter.field("sig", Lite(&self.value.sig));
2581 formatter.field("block", Lite(&self.value.block));
2582 formatter.finish()
2586 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2587 let mut formatter = formatter.debug_struct("ItemForeignMod");
2589 formatter.field("attrs", Lite(&self.value.attrs));
2592 formatter.field("unsafety", &Present);
2594 formatter.field("abi", Lite(&self.value.abi));
2596 formatter.field("items", Lite(&self.value.items));
2598 formatter.finish()
2602 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2603 let mut formatter = formatter.debug_struct("ItemImpl");
2605 formatter.field("attrs", Lite(&self.value.attrs));
2608 formatter.field("defaultness", &Present);
2611 formatter.field("unsafety", &Present);
2613 formatter.field("generics", Lite(&self.value.generics));
2619 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2620 formatter.write_str("Some(")?;
2628 formatter,
2630 formatter.write_str(")")?;
2634 formatter.field("trait_", Print::ref_cast(val));
2636 formatter.field("self_ty", Lite(&self.value.self_ty));
2638 formatter.field("items", Lite(&self.value.items));
2640 formatter.finish()
2644 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2645 let mut formatter = formatter.debug_struct("ItemMacro");
2647 formatter.field("attrs", Lite(&self.value.attrs));
2654 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2655 formatter.write_str("Some(")?;
2656 Debug::fmt(Lite(&self.0), formatter)?;
2657 formatter.write_str(")")?;
2661 formatter.field("ident", Print::ref_cast(val));
2663 formatter.field("mac", Lite(&self.value.mac));
2665 formatter.field("semi_token", &Present);
2667 formatter.finish()
2671 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2672 let mut formatter = formatter.debug_struct("ItemMod");
2674 formatter.field("attrs", Lite(&self.value.attrs));
2676 formatter.field("vis", Lite(&self.value.vis));
2678 formatter.field("unsafety", &Present);
2680 formatter.field("ident", Lite(&self.value.ident));
2686 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2687 formatter.write_str("Some(")?;
2688 Debug::fmt(Lite(&self.0.1), formatter)?;
2689 formatter.write_str(")")?;
2693 formatter.field("content", Print::ref_cast(val));
2696 formatter.field("semi", &Present);
2698 formatter.finish()
2702 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2703 let mut formatter = formatter.debug_struct("ItemStatic");
2705 formatter.field("attrs", Lite(&self.value.attrs));
2707 formatter.field("vis", Lite(&self.value.vis));
2711 formatter.field("mutability", Lite(&self.value.mutability));
2714 formatter.field("ident", Lite(&self.value.ident));
2715 formatter.field("ty", Lite(&self.value.ty));
2716 formatter.field("expr", Lite(&self.value.expr));
2717 formatter.finish()
2721 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2722 let mut formatter = formatter.debug_struct("ItemStruct");
2724 formatter.field("attrs", Lite(&self.value.attrs));
2726 formatter.field("vis", Lite(&self.value.vis));
2727 formatter.field("ident", Lite(&self.value.ident));
2728 formatter.field("generics", Lite(&self.value.generics));
2729 formatter.field("fields", Lite(&self.value.fields));
2731 formatter.field("semi_token", &Present);
2733 formatter.finish()
2737 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2738 let mut formatter = formatter.debug_struct("ItemTrait");
2740 formatter.field("attrs", Lite(&self.value.attrs));
2742 formatter.field("vis", Lite(&self.value.vis));
2744 formatter.field("unsafety", &Present);
2747 formatter.field("auto_token", &Present);
2754 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2755 formatter.write_str("Some(")?;
2756 Debug::fmt(Lite(&self.0), formatter)?;
2757 formatter.write_str(")")?;
2761 formatter.field("restriction", Print::ref_cast(val));
2763 formatter.field("ident", Lite(&self.value.ident));
2764 formatter.field("generics", Lite(&self.value.generics));
2766 formatter.field("colon_token", &Present);
2769 formatter.field("supertraits", Lite(&self.value.supertraits));
2772 formatter.field("items", Lite(&self.value.items));
2774 formatter.finish()
2778 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2779 let mut formatter = formatter.debug_struct("ItemTraitAlias");
2781 formatter.field("attrs", Lite(&self.value.attrs));
2783 formatter.field("vis", Lite(&self.value.vis));
2784 formatter.field("ident", Lite(&self.value.ident));
2785 formatter.field("generics", Lite(&self.value.generics));
2787 formatter.field("bounds", Lite(&self.value.bounds));
2789 formatter.finish()
2793 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2794 let mut formatter = formatter.debug_struct("ItemType");
2796 formatter.field("attrs", Lite(&self.value.attrs));
2798 formatter.field("vis", Lite(&self.value.vis));
2799 formatter.field("ident", Lite(&self.value.ident));
2800 formatter.field("generics", Lite(&self.value.generics));
2801 formatter.field("ty", Lite(&self.value.ty));
2802 formatter.finish()
2806 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2807 let mut formatter = formatter.debug_struct("ItemUnion");
2809 formatter.field("attrs", Lite(&self.value.attrs));
2811 formatter.field("vis", Lite(&self.value.vis));
2812 formatter.field("ident", Lite(&self.value.ident));
2813 formatter.field("generics", Lite(&self.value.generics));
2814 formatter.field("fields", Lite(&self.value.fields));
2815 formatter.finish()
2819 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2820 let mut formatter = formatter.debug_struct("ItemUse");
2822 formatter.field("attrs", Lite(&self.value.attrs));
2824 formatter.field("vis", Lite(&self.value.vis));
2826 formatter.field("leading_colon", &Present);
2828 formatter.field("tree", Lite(&self.value.tree));
2829 formatter.finish()
2833 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2834 let mut formatter = formatter.debug_struct("Label");
2835 formatter.field("name", Lite(&self.value.name));
2836 formatter.finish()
2840 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2841 let mut formatter = formatter.debug_struct("Lifetime");
2842 formatter.field("ident", Lite(&self.value.ident));
2843 formatter.finish()
2847 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2848 let mut formatter = formatter.debug_struct("LifetimeParam");
2850 formatter.field("attrs", Lite(&self.value.attrs));
2852 formatter.field("lifetime", Lite(&self.value.lifetime));
2854 formatter.field("colon_token", &Present);
2857 formatter.field("bounds", Lite(&self.value.bounds));
2859 formatter.finish()
2863 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2865 syn::Lit::Str(_val) => write!(formatter, "{:?}", _val.value()),
2866 syn::Lit::ByteStr(_val) => write!(formatter, "{:?}", _val.value()),
2867 syn::Lit::Byte(_val) => write!(formatter, "{:?}", _val.value()),
2868 syn::Lit::Char(_val) => write!(formatter, "{:?}", _val.value()),
2869 syn::Lit::Int(_val) => write!(formatter, "{}", _val),
2870 syn::Lit::Float(_val) => write!(formatter, "{}", _val),
2872 let mut formatter = formatter.debug_struct("Lit::Bool");
2873 formatter.field("value", Lite(&_val.value));
2874 formatter.finish()
2877 formatter.write_str("Lit::Verbatim")?;
2878 formatter.write_str("(`")?;
2879 Display::fmt(_val, formatter)?;
2880 formatter.write_str("`)")?;
2888 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2889 let mut formatter = formatter.debug_struct("LitBool");
2890 formatter.field("value", Lite(&self.value.value));
2891 formatter.finish()
2895 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2896 write!(formatter, "{:?}", self.value.value())
2900 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2901 write!(formatter, "{:?}", self.value.value())
2905 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2906 write!(formatter, "{:?}", self.value.value())
2910 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2911 write!(formatter, "{}", & self.value)
2915 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2916 write!(formatter, "{}", & self.value)
2920 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2921 write!(formatter, "{:?}", self.value.value())
2925 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2926 let mut formatter = formatter.debug_struct("Local");
2928 formatter.field("attrs", Lite(&self.value.attrs));
2930 formatter.field("pat", Lite(&self.value.pat));
2936 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2937 formatter.write_str("Some(")?;
2938 Debug::fmt(Lite(&self.0), formatter)?;
2939 formatter.write_str(")")?;
2943 formatter.field("init", Print::ref_cast(val));
2945 formatter.finish()
2949 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2950 let mut formatter = formatter.debug_struct("LocalInit");
2951 formatter.field("expr", Lite(&self.value.expr));
2957 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2958 formatter.write_str("Some(")?;
2959 Debug::fmt(Lite(&self.0.1), formatter)?;
2960 formatter.write_str(")")?;
2964 formatter.field("diverge", Print::ref_cast(val));
2966 formatter.finish()
2970 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2971 let mut formatter = formatter.debug_struct("Macro");
2972 formatter.field("path", Lite(&self.value.path));
2973 formatter.field("delimiter", Lite(&self.value.delimiter));
2974 formatter.field("tokens", Lite(&self.value.tokens));
2975 formatter.finish()
2979 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2982 formatter.write_str("MacroDelimiter::Paren")?;
2986 formatter.write_str("MacroDelimiter::Brace")?;
2990 formatter.write_str("MacroDelimiter::Bracket")?;
2997 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3000 formatter.write_str("Member::Named")?;
3001 formatter.write_str("(")?;
3002 Debug::fmt(Lite(_val), formatter)?;
3003 formatter.write_str(")")?;
3007 formatter.write_str("Member::Unnamed")?;
3008 formatter.write_str("(")?;
3009 Debug::fmt(Lite(_val), formatter)?;
3010 formatter.write_str(")")?;
3017 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3020 let mut formatter = formatter.debug_struct("Meta::Path");
3022 formatter.field("leading_colon", &Present);
3025 formatter.field("segments", Lite(&_val.segments));
3027 formatter.finish()
3030 let mut formatter = formatter.debug_struct("Meta::List");
3031 formatter.field("path", Lite(&_val.path));
3032 formatter.field("delimiter", Lite(&_val.delimiter));
3033 formatter.field("tokens", Lite(&_val.tokens));
3034 formatter.finish()
3037 let mut formatter = formatter.debug_struct("Meta::NameValue");
3038 formatter.field("path", Lite(&_val.path));
3039 formatter.field("value", Lite(&_val.value));
3040 formatter.finish()
3046 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3047 let mut formatter = formatter.debug_struct("MetaList");
3048 formatter.field("path", Lite(&self.value.path));
3049 formatter.field("delimiter", Lite(&self.value.delimiter));
3050 formatter.field("tokens", Lite(&self.value.tokens));
3051 formatter.finish()
3055 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3056 let mut formatter = formatter.debug_struct("MetaNameValue");
3057 formatter.field("path", Lite(&self.value.path));
3058 formatter.field("value", Lite(&self.value.value));
3059 formatter.finish()
3063 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3064 let mut formatter = formatter.debug_struct("ParenthesizedGenericArguments");
3066 formatter.field("inputs", Lite(&self.value.inputs));
3068 formatter.field("output", Lite(&self.value.output));
3069 formatter.finish()
3073 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3076 formatter.write_str("Pat::Const")?;
3077 formatter.write_str("(")?;
3078 Debug::fmt(Lite(_val), formatter)?;
3079 formatter.write_str(")")?;
3083 let mut formatter = formatter.debug_struct("Pat::Ident");
3085 formatter.field("attrs", Lite(&_val.attrs));
3088 formatter.field("by_ref", &Present);
3091 formatter.field("mutability", &Present);
3093 formatter.field("ident", Lite(&_val.ident));
3099 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3100 formatter.write_str("Some(")?;
3101 Debug::fmt(Lite(&self.0.1), formatter)?;
3102 formatter.write_str(")")?;
3106 formatter.field("subpat", Print::ref_cast(val));
3108 formatter.finish()
3111 formatter.write_str("Pat::Lit")?;
3112 formatter.write_str("(")?;
3113 Debug::fmt(Lite(_val), formatter)?;
3114 formatter.write_str(")")?;
3118 formatter.write_str("Pat::Macro")?;
3119 formatter.write_str("(")?;
3120 Debug::fmt(Lite(_val), formatter)?;
3121 formatter.write_str(")")?;
3125 let mut formatter = formatter.debug_struct("Pat::Or");
3127 formatter.field("attrs", Lite(&_val.attrs));
3130 formatter.field("leading_vert", &Present);
3133 formatter.field("cases", Lite(&_val.cases));
3135 formatter.finish()
3138 let mut formatter = formatter.debug_struct("Pat::Paren");
3140 formatter.field("attrs", Lite(&_val.attrs));
3142 formatter.field("pat", Lite(&_val.pat));
3143 formatter.finish()
3146 formatter.write_str("Pat::Path")?;
3147 formatter.write_str("(")?;
3148 Debug::fmt(Lite(_val), formatter)?;
3149 formatter.write_str(")")?;
3153 formatter.write_str("Pat::Range")?;
3154 formatter.write_str("(")?;
3155 Debug::fmt(Lite(_val), formatter)?;
3156 formatter.write_str(")")?;
3160 let mut formatter = formatter.debug_struct("Pat::Reference");
3162 formatter.field("attrs", Lite(&_val.attrs));
3165 formatter.field("mutability", &Present);
3167 formatter.field("pat", Lite(&_val.pat));
3168 formatter.finish()
3171 let mut formatter = formatter.debug_struct("Pat::Rest");
3173 formatter.field("attrs", Lite(&_val.attrs));
3175 formatter.finish()
3178 let mut formatter = formatter.debug_struct("Pat::Slice");
3180 formatter.field("attrs", Lite(&_val.attrs));
3183 formatter.field("elems", Lite(&_val.elems));
3185 formatter.finish()
3188 let mut formatter = formatter.debug_struct("Pat::Struct");
3190 formatter.field("attrs", Lite(&_val.attrs));
3197 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3198 formatter.write_str("Some(")?;
3199 Debug::fmt(Lite(&self.0), formatter)?;
3200 formatter.write_str(")")?;
3204 formatter.field("qself", Print::ref_cast(val));
3206 formatter.field("path", Lite(&_val.path));
3208 formatter.field("fields", Lite(&_val.fields));
3215 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3216 formatter.write_str("Some(")?;
3217 Debug::fmt(Lite(&self.0), formatter)?;
3218 formatter.write_str(")")?;
3222 formatter.field("rest", Print::ref_cast(val));
3224 formatter.finish()
3227 let mut formatter = formatter.debug_struct("Pat::Tuple");
3229 formatter.field("attrs", Lite(&_val.attrs));
3232 formatter.field("elems", Lite(&_val.elems));
3234 formatter.finish()
3237 let mut formatter = formatter.debug_struct("Pat::TupleStruct");
3239 formatter.field("attrs", Lite(&_val.attrs));
3246 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3247 formatter.write_str("Some(")?;
3248 Debug::fmt(Lite(&self.0), formatter)?;
3249 formatter.write_str(")")?;
3253 formatter.field("qself", Print::ref_cast(val));
3255 formatter.field("path", Lite(&_val.path));
3257 formatter.field("elems", Lite(&_val.elems));
3259 formatter.finish()
3262 let mut formatter = formatter.debug_struct("Pat::Type");
3264 formatter.field("attrs", Lite(&_val.attrs));
3266 formatter.field("pat", Lite(&_val.pat));
3267 formatter.field("ty", Lite(&_val.ty));
3268 formatter.finish()
3271 formatter.write_str("Pat::Verbatim")?;
3272 formatter.write_str("(`")?;
3273 Display::fmt(_val, formatter)?;
3274 formatter.write_str("`)")?;
3278 let mut formatter = formatter.debug_struct("Pat::Wild");
3280 formatter.field("attrs", Lite(&_val.attrs));
3282 formatter.finish()
3289 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3290 let mut formatter = formatter.debug_struct("PatIdent");
3292 formatter.field("attrs", Lite(&self.value.attrs));
3295 formatter.field("by_ref", &Present);
3298 formatter.field("mutability", &Present);
3300 formatter.field("ident", Lite(&self.value.ident));
3306 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3307 formatter.write_str("Some(")?;
3308 Debug::fmt(Lite(&self.0.1), formatter)?;
3309 formatter.write_str(")")?;
3313 formatter.field("subpat", Print::ref_cast(val));
3315 formatter.finish()
3319 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3320 let mut formatter = formatter.debug_struct("PatOr");
3322 formatter.field("attrs", Lite(&self.value.attrs));
3325 formatter.field("leading_vert", &Present);
3328 formatter.field("cases", Lite(&self.value.cases));
3330 formatter.finish()
3334 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3335 let mut formatter = formatter.debug_struct("PatParen");
3337 formatter.field("attrs", Lite(&self.value.attrs));
3339 formatter.field("pat", Lite(&self.value.pat));
3340 formatter.finish()
3344 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3345 let mut formatter = formatter.debug_struct("PatReference");
3347 formatter.field("attrs", Lite(&self.value.attrs));
3350 formatter.field("mutability", &Present);
3352 formatter.field("pat", Lite(&self.value.pat));
3353 formatter.finish()
3357 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3358 let mut formatter = formatter.debug_struct("PatRest");
3360 formatter.field("attrs", Lite(&self.value.attrs));
3362 formatter.finish()
3366 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3367 let mut formatter = formatter.debug_struct("PatSlice");
3369 formatter.field("attrs", Lite(&self.value.attrs));
3372 formatter.field("elems", Lite(&self.value.elems));
3374 formatter.finish()
3378 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3379 let mut formatter = formatter.debug_struct("PatStruct");
3381 formatter.field("attrs", Lite(&self.value.attrs));
3388 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3389 formatter.write_str("Some(")?;
3390 Debug::fmt(Lite(&self.0), formatter)?;
3391 formatter.write_str(")")?;
3395 formatter.field("qself", Print::ref_cast(val));
3397 formatter.field("path", Lite(&self.value.path));
3399 formatter.field("fields", Lite(&self.value.fields));
3406 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3407 formatter.write_str("Some(")?;
3408 Debug::fmt(Lite(&self.0), formatter)?;
3409 formatter.write_str(")")?;
3413 formatter.field("rest", Print::ref_cast(val));
3415 formatter.finish()
3419 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3420 let mut formatter = formatter.debug_struct("PatTuple");
3422 formatter.field("attrs", Lite(&self.value.attrs));
3425 formatter.field("elems", Lite(&self.value.elems));
3427 formatter.finish()
3431 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3432 let mut formatter = formatter.debug_struct("PatTupleStruct");
3434 formatter.field("attrs", Lite(&self.value.attrs));
3441 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3442 formatter.write_str("Some(")?;
3443 Debug::fmt(Lite(&self.0), formatter)?;
3444 formatter.write_str(")")?;
3448 formatter.field("qself", Print::ref_cast(val));
3450 formatter.field("path", Lite(&self.value.path));
3452 formatter.field("elems", Lite(&self.value.elems));
3454 formatter.finish()
3458 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3459 let mut formatter = formatter.debug_struct("PatType");
3461 formatter.field("attrs", Lite(&self.value.attrs));
3463 formatter.field("pat", Lite(&self.value.pat));
3464 formatter.field("ty", Lite(&self.value.ty));
3465 formatter.finish()
3469 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3470 let mut formatter = formatter.debug_struct("PatWild");
3472 formatter.field("attrs", Lite(&self.value.attrs));
3474 formatter.finish()
3478 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3479 let mut formatter = formatter.debug_struct("Path");
3481 formatter.field("leading_colon", &Present);
3484 formatter.field("segments", Lite(&self.value.segments));
3486 formatter.finish()
3490 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3492 syn::PathArguments::None => formatter.write_str("PathArguments::None"),
3494 let mut formatter = formatter
3497 formatter.field("colon2_token", &Present);
3500 formatter.field("args", Lite(&_val.args));
3502 formatter.finish()
3505 let mut formatter = formatter
3508 formatter.field("inputs", Lite(&_val.inputs));
3510 formatter.field("output", Lite(&_val.output));
3511 formatter.finish()
3517 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3518 let mut formatter = formatter.debug_struct("PathSegment");
3519 formatter.field("ident", Lite(&self.value.ident));
3523 formatter.field("arguments", Lite(&self.value.arguments));
3526 formatter.finish()
3530 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3531 let mut formatter = formatter.debug_struct("PredicateLifetime");
3532 formatter.field("lifetime", Lite(&self.value.lifetime));
3534 formatter.field("bounds", Lite(&self.value.bounds));
3536 formatter.finish()
3540 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3541 let mut formatter = formatter.debug_struct("PredicateType");
3547 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3548 formatter.write_str("Some(")?;
3549 Debug::fmt(Lite(&self.0), formatter)?;
3550 formatter.write_str(")")?;
3554 formatter.field("lifetimes", Print::ref_cast(val));
3556 formatter.field("bounded_ty", Lite(&self.value.bounded_ty));
3558 formatter.field("bounds", Lite(&self.value.bounds));
3560 formatter.finish()
3564 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3565 let mut formatter = formatter.debug_struct("QSelf");
3566 formatter.field("ty", Lite(&self.value.ty));
3567 formatter.field("position", Lite(&self.value.position));
3569 formatter.field("as_token", &Present);
3571 formatter.finish()
3575 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3578 formatter.write_str("RangeLimits::HalfOpen")?;
3582 formatter.write_str("RangeLimits::Closed")?;
3589 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3590 let mut formatter = formatter.debug_struct("Receiver");
3592 formatter.field("attrs", Lite(&self.value.attrs));
3599 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3600 formatter.write_str("Some(")?;
3609 formatter: &mut fmt::Formatter,
3613 formatter.write_str("Some(")?;
3614 Debug::fmt(Lite(_val), formatter)?;
3615 formatter.write_str(")")?;
3618 None => formatter.write_str("None"),
3624 formatter,
3626 formatter.write_str(")")?;
3630 formatter.field("reference", Print::ref_cast(val));
3633 formatter.field("mutability", &Present);
3636 formatter.field("colon_token", &Present);
3638 formatter.field("ty", Lite(&self.value.ty));
3639 formatter.finish()
3643 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3645 syn::ReturnType::Default => formatter.write_str("ReturnType::Default"),
3647 let mut formatter = formatter.debug_tuple("ReturnType::Type");
3648 formatter.field(Lite(_v1));
3649 formatter.finish()
3655 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3656 let mut formatter = formatter.debug_struct("Signature");
3658 formatter.field("constness", &Present);
3661 formatter.field("asyncness", &Present);
3664 formatter.field("unsafety", &Present);
3671 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3672 formatter.write_str("Some(")?;
3673 Debug::fmt(Lite(&self.0), formatter)?;
3674 formatter.write_str(")")?;
3678 formatter.field("abi", Print::ref_cast(val));
3680 formatter.field("ident", Lite(&self.value.ident));
3681 formatter.field("generics", Lite(&self.value.generics));
3683 formatter.field("inputs", Lite(&self.value.inputs));
3690 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3691 formatter.write_str("Some(")?;
3692 Debug::fmt(Lite(&self.0), formatter)?;
3693 formatter.write_str(")")?;
3697 formatter.field("variadic", Print::ref_cast(val));
3699 formatter.field("output", Lite(&self.value.output));
3700 formatter.finish()
3704 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3707 formatter.write_str("StaticMutability::Mut")?;
3710 syn::StaticMutability::None => formatter.write_str("StaticMutability::None"),
3716 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3719 let mut formatter = formatter.debug_struct("Stmt::Local");
3721 formatter.field("attrs", Lite(&_val.attrs));
3723 formatter.field("pat", Lite(&_val.pat));
3729 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3730 formatter.write_str("Some(")?;
3731 Debug::fmt(Lite(&self.0), formatter)?;
3732 formatter.write_str(")")?;
3736 formatter.field("init", Print::ref_cast(val));
3738 formatter.finish()
3741 formatter.write_str("Stmt::Item")?;
3742 formatter.write_str("(")?;
3743 Debug::fmt(Lite(_val), formatter)?;
3744 formatter.write_str(")")?;
3748 let mut formatter = formatter.debug_tuple("Stmt::Expr");
3749 formatter.field(Lite(_v0));
3750 formatter
3756 formatter.finish()
3759 let mut formatter = formatter.debug_struct("Stmt::Macro");
3761 formatter.field("attrs", Lite(&_val.attrs));
3763 formatter.field("mac", Lite(&_val.mac));
3765 formatter.field("semi_token", &Present);
3767 formatter.finish()
3773 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3774 let mut formatter = formatter.debug_struct("StmtMacro");
3776 formatter.field("attrs", Lite(&self.value.attrs));
3778 formatter.field("mac", Lite(&self.value.mac));
3780 formatter.field("semi_token", &Present);
3782 formatter.finish()
3786 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3787 let mut formatter = formatter.debug_struct("TraitBound");
3789 formatter.field("paren_token", &Present);
3794 formatter.field("modifier", Lite(&self.value.modifier));
3802 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3803 formatter.write_str("Some(")?;
3804 Debug::fmt(Lite(&self.0), formatter)?;
3805 formatter.write_str(")")?;
3809 formatter.field("lifetimes", Print::ref_cast(val));
3811 formatter.field("path", Lite(&self.value.path));
3812 formatter.finish()
3816 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3819 formatter.write_str("TraitBoundModifier::None")
3822 formatter.write_str("TraitBoundModifier::Maybe")?;
3829 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3832 let mut formatter = formatter.debug_struct("TraitItem::Const");
3834 formatter.field("attrs", Lite(&_val.attrs));
3836 formatter.field("ident", Lite(&_val.ident));
3837 formatter.field("generics", Lite(&_val.generics));
3838 formatter.field("ty", Lite(&_val.ty));
3844 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3845 formatter.write_str("Some(")?;
3846 Debug::fmt(Lite(&self.0.1), formatter)?;
3847 formatter.write_str(")")?;
3851 formatter.field("default", Print::ref_cast(val));
3853 formatter.finish()
3856 let mut formatter = formatter.debug_struct("TraitItem::Fn");
3858 formatter.field("attrs", Lite(&_val.attrs));
3860 formatter.field("sig", Lite(&_val.sig));
3866 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3867 formatter.write_str("Some(")?;
3868 Debug::fmt(Lite(&self.0), formatter)?;
3869 formatter.write_str(")")?;
3873 formatter.field("default", Print::ref_cast(val));
3876 formatter.field("semi_token", &Present);
3878 formatter.finish()
3881 let mut formatter = formatter.debug_struct("TraitItem::Type");
3883 formatter.field("attrs", Lite(&_val.attrs));
3885 formatter.field("ident", Lite(&_val.ident));
3886 formatter.field("generics", Lite(&_val.generics));
3888 formatter.field("colon_token", &Present);
3891 formatter.field("bounds", Lite(&_val.bounds));
3898 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3899 formatter.write_str("Some(")?;
3900 Debug::fmt(Lite(&self.0.1), formatter)?;
3901 formatter.write_str(")")?;
3905 formatter.field("default", Print::ref_cast(val));
3907 formatter.finish()
3910 let mut formatter = formatter.debug_struct("TraitItem::Macro");
3912 formatter.field("attrs", Lite(&_val.attrs));
3914 formatter.field("mac", Lite(&_val.mac));
3916 formatter.field("semi_token", &Present);
3918 formatter.finish()
3921 formatter.write_str("TraitItem::Verbatim")?;
3922 formatter.write_str("(`")?;
3923 Display::fmt(_val, formatter)?;
3924 formatter.write_str("`)")?;
3932 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3933 let mut formatter = formatter.debug_struct("TraitItemConst");
3935 formatter.field("attrs", Lite(&self.value.attrs));
3937 formatter.field("ident", Lite(&self.value.ident));
3938 formatter.field("generics", Lite(&self.value.generics));
3939 formatter.field("ty", Lite(&self.value.ty));
3945 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3946 formatter.write_str("Some(")?;
3947 Debug::fmt(Lite(&self.0.1), formatter)?;
3948 formatter.write_str(")")?;
3952 formatter.field("default", Print::ref_cast(val));
3954 formatter.finish()
3958 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3959 let mut formatter = formatter.debug_struct("TraitItemFn");
3961 formatter.field("attrs", Lite(&self.value.attrs));
3963 formatter.field("sig", Lite(&self.value.sig));
3969 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3970 formatter.write_str("Some(")?;
3971 Debug::fmt(Lite(&self.0), formatter)?;
3972 formatter.write_str(")")?;
3976 formatter.field("default", Print::ref_cast(val));
3979 formatter.field("semi_token", &Present);
3981 formatter.finish()
3985 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3986 let mut formatter = formatter.debug_struct("TraitItemMacro");
3988 formatter.field("attrs", Lite(&self.value.attrs));
3990 formatter.field("mac", Lite(&self.value.mac));
3992 formatter.field("semi_token", &Present);
3994 formatter.finish()
3998 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
3999 let mut formatter = formatter.debug_struct("TraitItemType");
4001 formatter.field("attrs", Lite(&self.value.attrs));
4003 formatter.field("ident", Lite(&self.value.ident));
4004 formatter.field("generics", Lite(&self.value.generics));
4006 formatter.field("colon_token", &Present);
4009 formatter.field("bounds", Lite(&self.value.bounds));
4016 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4017 formatter.write_str("Some(")?;
4018 Debug::fmt(Lite(&self.0.1), formatter)?;
4019 formatter.write_str(")")?;
4023 formatter.field("default", Print::ref_cast(val));
4025 formatter.finish()
4029 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4032 let mut formatter = formatter.debug_struct("Type::Array");
4033 formatter.field("elem", Lite(&_val.elem));
4034 formatter.field("len", Lite(&_val.len));
4035 formatter.finish()
4038 let mut formatter = formatter.debug_struct("Type::BareFn");
4044 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4045 formatter.write_str("Some(")?;
4046 Debug::fmt(Lite(&self.0), formatter)?;
4047 formatter.write_str(")")?;
4051 formatter.field("lifetimes", Print::ref_cast(val));
4054 formatter.field("unsafety", &Present);
4061 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4062 formatter.write_str("Some(")?;
4063 Debug::fmt(Lite(&self.0), formatter)?;
4064 formatter.write_str(")")?;
4068 formatter.field("abi", Print::ref_cast(val));
4071 formatter.field("inputs", Lite(&_val.inputs));
4078 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4079 formatter.write_str("Some(")?;
4080 Debug::fmt(Lite(&self.0), formatter)?;
4081 formatter.write_str(")")?;
4085 formatter.field("variadic", Print::ref_cast(val));
4087 formatter.field("output", Lite(&_val.output));
4088 formatter.finish()
4091 let mut formatter = formatter.debug_struct("Type::Group");
4092 formatter.field("elem", Lite(&_val.elem));
4093 formatter.finish()
4096 let mut formatter = formatter.debug_struct("Type::ImplTrait");
4098 formatter.field("bounds", Lite(&_val.bounds));
4100 formatter.finish()
4103 let mut formatter = formatter.debug_struct("Type::Infer");
4104 formatter.finish()
4107 let mut formatter = formatter.debug_struct("Type::Macro");
4108 formatter.field("mac", Lite(&_val.mac));
4109 formatter.finish()
4112 let mut formatter = formatter.debug_struct("Type::Never");
4113 formatter.finish()
4116 let mut formatter = formatter.debug_struct("Type::Paren");
4117 formatter.field("elem", Lite(&_val.elem));
4118 formatter.finish()
4121 let mut formatter = formatter.debug_struct("Type::Path");
4127 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4128 formatter.write_str("Some(")?;
4129 Debug::fmt(Lite(&self.0), formatter)?;
4130 formatter.write_str(")")?;
4134 formatter.field("qself", Print::ref_cast(val));
4136 formatter.field("path", Lite(&_val.path));
4137 formatter.finish()
4140 let mut formatter = formatter.debug_struct("Type::Ptr");
4142 formatter.field("const_token", &Present);
4145 formatter.field("mutability", &Present);
4147 formatter.field("elem", Lite(&_val.elem));
4148 formatter.finish()
4151 let mut formatter = formatter.debug_struct("Type::Reference");
4157 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4158 formatter.write_str("Some(")?;
4159 Debug::fmt(Lite(&self.0), formatter)?;
4160 formatter.write_str(")")?;
4164 formatter.field("lifetime", Print::ref_cast(val));
4167 formatter.field("mutability", &Present);
4169 formatter.field("elem", Lite(&_val.elem));
4170 formatter.finish()
4173 let mut formatter = formatter.debug_struct("Type::Slice");
4174 formatter.field("elem", Lite(&_val.elem));
4175 formatter.finish()
4178 let mut formatter = formatter.debug_struct("Type::TraitObject");
4180 formatter.field("dyn_token", &Present);
4183 formatter.field("bounds", Lite(&_val.bounds));
4185 formatter.finish()
4188 let mut formatter = formatter.debug_struct("Type::Tuple");
4190 formatter.field("elems", Lite(&_val.elems));
4192 formatter.finish()
4195 formatter.write_str("Type::Verbatim")?;
4196 formatter.write_str("(`")?;
4197 Display::fmt(_val, formatter)?;
4198 formatter.write_str("`)")?;
4206 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4207 let mut formatter = formatter.debug_struct("TypeArray");
4208 formatter.field("elem", Lite(&self.value.elem));
4209 formatter.field("len", Lite(&self.value.len));
4210 formatter.finish()
4214 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4215 let mut formatter = formatter.debug_struct("TypeBareFn");
4221 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4222 formatter.write_str("Some(")?;
4223 Debug::fmt(Lite(&self.0), formatter)?;
4224 formatter.write_str(")")?;
4228 formatter.field("lifetimes", Print::ref_cast(val));
4231 formatter.field("unsafety", &Present);
4238 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4239 formatter.write_str("Some(")?;
4240 Debug::fmt(Lite(&self.0), formatter)?;
4241 formatter.write_str(")")?;
4245 formatter.field("abi", Print::ref_cast(val));
4248 formatter.field("inputs", Lite(&self.value.inputs));
4255 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4256 formatter.write_str("Some(")?;
4257 Debug::fmt(Lite(&self.0), formatter)?;
4258 formatter.write_str(")")?;
4262 formatter.field("variadic", Print::ref_cast(val));
4264 formatter.field("output", Lite(&self.value.output));
4265 formatter.finish()
4269 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4270 let mut formatter = formatter.debug_struct("TypeGroup");
4271 formatter.field("elem", Lite(&self.value.elem));
4272 formatter.finish()
4276 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4277 let mut formatter = formatter.debug_struct("TypeImplTrait");
4279 formatter.field("bounds", Lite(&self.value.bounds));
4281 formatter.finish()
4285 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4286 let mut formatter = formatter.debug_struct("TypeInfer");
4287 formatter.finish()
4291 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4292 let mut formatter = formatter.debug_struct("TypeMacro");
4293 formatter.field("mac", Lite(&self.value.mac));
4294 formatter.finish()
4298 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4299 let mut formatter = formatter.debug_struct("TypeNever");
4300 formatter.finish()
4304 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4305 let mut formatter = formatter.debug_struct("TypeParam");
4307 formatter.field("attrs", Lite(&self.value.attrs));
4309 formatter.field("ident", Lite(&self.value.ident));
4311 formatter.field("colon_token", &Present);
4314 formatter.field("bounds", Lite(&self.value.bounds));
4317 formatter.field("eq_token", &Present);
4324 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4325 formatter.write_str("Some(")?;
4326 Debug::fmt(Lite(&self.0), formatter)?;
4327 formatter.write_str(")")?;
4331 formatter.field("default", Print::ref_cast(val));
4333 formatter.finish()
4337 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4340 formatter.write_str("TypeParamBound::Trait")?;
4341 formatter.write_str("(")?;
4342 Debug::fmt(Lite(_val), formatter)?;
4343 formatter.write_str(")")?;
4347 let mut formatter = formatter.debug_struct("TypeParamBound::Lifetime");
4348 formatter.field("ident", Lite(&_val.ident));
4349 formatter.finish()
4352 formatter.write_str("TypeParamBound::Verbatim")?;
4353 formatter.write_str("(`")?;
4354 Display::fmt(_val, formatter)?;
4355 formatter.write_str("`)")?;
4363 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4364 let mut formatter = formatter.debug_struct("TypeParen");
4365 formatter.field("elem", Lite(&self.value.elem));
4366 formatter.finish()
4370 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4371 let mut formatter = formatter.debug_struct("TypePath");
4377 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4378 formatter.write_str("Some(")?;
4379 Debug::fmt(Lite(&self.0), formatter)?;
4380 formatter.write_str(")")?;
4384 formatter.field("qself", Print::ref_cast(val));
4386 formatter.field("path", Lite(&self.value.path));
4387 formatter.finish()
4391 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4392 let mut formatter = formatter.debug_struct("TypePtr");
4394 formatter.field("const_token", &Present);
4397 formatter.field("mutability", &Present);
4399 formatter.field("elem", Lite(&self.value.elem));
4400 formatter.finish()
4404 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4405 let mut formatter = formatter.debug_struct("TypeReference");
4411 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4412 formatter.write_str("Some(")?;
4413 Debug::fmt(Lite(&self.0), formatter)?;
4414 formatter.write_str(")")?;
4418 formatter.field("lifetime", Print::ref_cast(val));
4421 formatter.field("mutability", &Present);
4423 formatter.field("elem", Lite(&self.value.elem));
4424 formatter.finish()
4428 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4429 let mut formatter = formatter.debug_struct("TypeSlice");
4430 formatter.field("elem", Lite(&self.value.elem));
4431 formatter.finish()
4435 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4436 let mut formatter = formatter.debug_struct("TypeTraitObject");
4438 formatter.field("dyn_token", &Present);
4441 formatter.field("bounds", Lite(&self.value.bounds));
4443 formatter.finish()
4447 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4448 let mut formatter = formatter.debug_struct("TypeTuple");
4450 formatter.field("elems", Lite(&self.value.elems));
4452 formatter.finish()
4456 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4459 formatter.write_str("UnOp::Deref")?;
4463 formatter.write_str("UnOp::Not")?;
4467 formatter.write_str("UnOp::Neg")?;
4475 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4476 let mut formatter = formatter.debug_struct("UseGlob");
4477 formatter.finish()
4481 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4482 let mut formatter = formatter.debug_struct("UseGroup");
4484 formatter.field("items", Lite(&self.value.items));
4486 formatter.finish()
4490 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4491 let mut formatter = formatter.debug_struct("UseName");
4492 formatter.field("ident", Lite(&self.value.ident));
4493 formatter.finish()
4497 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4498 let mut formatter = formatter.debug_struct("UsePath");
4499 formatter.field("ident", Lite(&self.value.ident));
4500 formatter.field("tree", Lite(&self.value.tree));
4501 formatter.finish()
4505 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4506 let mut formatter = formatter.debug_struct("UseRename");
4507 formatter.field("ident", Lite(&self.value.ident));
4508 formatter.field("rename", Lite(&self.value.rename));
4509 formatter.finish()
4513 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4516 formatter.write_str("UseTree::Path")?;
4517 formatter.write_str("(")?;
4518 Debug::fmt(Lite(_val), formatter)?;
4519 formatter.write_str(")")?;
4523 formatter.write_str("UseTree::Name")?;
4524 formatter.write_str("(")?;
4525 Debug::fmt(Lite(_val), formatter)?;
4526 formatter.write_str(")")?;
4530 formatter.write_str("UseTree::Rename")?;
4531 formatter.write_str("(")?;
4532 Debug::fmt(Lite(_val), formatter)?;
4533 formatter.write_str(")")?;
4537 formatter.write_str("UseTree::Glob")?;
4538 formatter.write_str("(")?;
4539 Debug::fmt(Lite(_val), formatter)?;
4540 formatter.write_str(")")?;
4544 formatter.write_str("UseTree::Group")?;
4545 formatter.write_str("(")?;
4546 Debug::fmt(Lite(_val), formatter)?;
4547 formatter.write_str(")")?;
4554 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4555 let mut formatter = formatter.debug_struct("Variadic");
4557 formatter.field("attrs", Lite(&self.value.attrs));
4564 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4565 formatter.write_str("Some(")?;
4566 Debug::fmt(Lite(&self.0.0), formatter)?;
4567 formatter.write_str(")")?;
4571 formatter.field("pat", Print::ref_cast(val));
4574 formatter.field("comma", &Present);
4576 formatter.finish()
4580 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4581 let mut formatter = formatter.debug_struct("Variant");
4583 formatter.field("attrs", Lite(&self.value.attrs));
4585 formatter.field("ident", Lite(&self.value.ident));
4586 formatter.field("fields", Lite(&self.value.fields));
4592 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4593 formatter.write_str("Some(")?;
4594 Debug::fmt(Lite(&self.0.1), formatter)?;
4595 formatter.write_str(")")?;
4599 formatter.field("discriminant", Print::ref_cast(val));
4601 formatter.finish()
4605 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4606 let mut formatter = formatter.debug_struct("VisRestricted");
4608 formatter.field("in_token", &Present);
4610 formatter.field("path", Lite(&self.value.path));
4611 formatter.finish()
4615 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4618 formatter.write_str("Visibility::Public")?;
4622 let mut formatter = formatter.debug_struct("Visibility::Restricted");
4624 formatter.field("in_token", &Present);
4626 formatter.field("path", Lite(&_val.path));
4627 formatter.finish()
4629 syn::Visibility::Inherited => formatter.write_str("Visibility::Inherited"),
4634 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4635 let mut formatter = formatter.debug_struct("WhereClause");
4637 formatter.field("predicates", Lite(&self.value.predicates));
4639 formatter.finish()
4643 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4646 formatter.write_str("WherePredicate::Lifetime")?;
4647 formatter.write_str("(")?;
4648 Debug::fmt(Lite(_val), formatter)?;
4649 formatter.write_str(")")?;
4653 formatter.write_str("WherePredicate::Type")?;
4654 formatter.write_str("(")?;
4655 Debug::fmt(Lite(_val), formatter)?;
4656 formatter.write_str(")")?;
4664 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4665 formatter.write_str("Token![abstract]")
4669 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4670 formatter.write_str("Token![&]")
4674 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4675 formatter.write_str("Token![&&]")
4679 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4680 formatter.write_str("Token![&=]")
4684 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4685 formatter.write_str("Token![as]")
4689 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4690 formatter.write_str("Token![async]")
4694 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4695 formatter.write_str("Token![@]")
4699 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4700 formatter.write_str("Token![auto]")
4704 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4705 formatter.write_str("Token![await]")
4709 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4710 formatter.write_str("Token![become]")
4714 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4715 formatter.write_str("Token![box]")
4719 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4720 formatter.write_str("Token![break]")
4724 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4725 formatter.write_str("Token![^]")
4729 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4730 formatter.write_str("Token![^=]")
4734 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4735 formatter.write_str("Token![:]")
4739 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4740 formatter.write_str("Token![,]")
4744 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4745 formatter.write_str("Token![const]")
4749 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4750 formatter.write_str("Token![continue]")
4754 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4755 formatter.write_str("Token![crate]")
4759 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4760 formatter.write_str("Token![default]")
4764 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4765 formatter.write_str("Token![do]")
4769 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4770 formatter.write_str("Token![$]")
4774 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4775 formatter.write_str("Token![.]")
4779 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4780 formatter.write_str("Token![..]")
4784 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4785 formatter.write_str("Token![...]")
4789 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4790 formatter.write_str("Token![..=]")
4794 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4795 formatter.write_str("Token![dyn]")
4799 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4800 formatter.write_str("Token![else]")
4804 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4805 formatter.write_str("Token![enum]")
4809 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4810 formatter.write_str("Token![=]")
4814 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4815 formatter.write_str("Token![==]")
4819 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4820 formatter.write_str("Token![extern]")
4824 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4825 formatter.write_str("Token![=>]")
4829 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4830 formatter.write_str("Token![final]")
4834 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4835 formatter.write_str("Token![fn]")
4839 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4840 formatter.write_str("Token![for]")
4844 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4845 formatter.write_str("Token![>=]")
4849 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4850 formatter.write_str("Token![>]")
4854 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4855 formatter.write_str("Token![if]")
4859 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4860 formatter.write_str("Token![impl]")
4864 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4865 formatter.write_str("Token![in]")
4869 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4870 formatter.write_str("Token![<-]")
4874 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4875 formatter.write_str("Token![<=]")
4879 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4880 formatter.write_str("Token![let]")
4884 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4885 formatter.write_str("Token![loop]")
4889 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4890 formatter.write_str("Token![<]")
4894 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4895 formatter.write_str("Token![macro]")
4899 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4900 formatter.write_str("Token![match]")
4904 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4905 formatter.write_str("Token![-]")
4909 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4910 formatter.write_str("Token![-=]")
4914 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4915 formatter.write_str("Token![mod]")
4919 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4920 formatter.write_str("Token![move]")
4924 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4925 formatter.write_str("Token![mut]")
4929 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4930 formatter.write_str("Token![!=]")
4934 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4935 formatter.write_str("Token![!]")
4939 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4940 formatter.write_str("Token![|]")
4944 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4945 formatter.write_str("Token![|=]")
4949 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4950 formatter.write_str("Token![||]")
4954 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4955 formatter.write_str("Token![override]")
4959 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4960 formatter.write_str("Token![::]")
4964 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4965 formatter.write_str("Token![%]")
4969 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4970 formatter.write_str("Token![%=]")
4974 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4975 formatter.write_str("Token![+]")
4979 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4980 formatter.write_str("Token![+=]")
4984 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4985 formatter.write_str("Token![#]")
4989 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4990 formatter.write_str("Token![priv]")
4994 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
4995 formatter.write_str("Token![pub]")
4999 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5000 formatter.write_str("Token![?]")
5004 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5005 formatter.write_str("Token![->]")
5009 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5010 formatter.write_str("Token![ref]")
5014 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5015 formatter.write_str("Token![return]")
5019 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5020 formatter.write_str("Token![Self]")
5024 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5025 formatter.write_str("Token![self]")
5029 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5030 formatter.write_str("Token![;]")
5034 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5035 formatter.write_str("Token![<<]")
5039 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5040 formatter.write_str("Token![<<=]")
5044 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5045 formatter.write_str("Token![>>]")
5049 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5050 formatter.write_str("Token![>>=]")
5054 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5055 formatter.write_str("Token![/]")
5059 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5060 formatter.write_str("Token![/=]")
5064 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5065 formatter.write_str("Token![*]")
5069 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5070 formatter.write_str("Token![*=]")
5074 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5075 formatter.write_str("Token![static]")
5079 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5080 formatter.write_str("Token![struct]")
5084 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5085 formatter.write_str("Token![super]")
5089 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5090 formatter.write_str("Token![~]")
5094 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5095 formatter.write_str("Token![trait]")
5099 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5100 formatter.write_str("Token![try]")
5104 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5105 formatter.write_str("Token![type]")
5109 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5110 formatter.write_str("Token![typeof]")
5114 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5115 formatter.write_str("Token![_]")
5119 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5120 formatter.write_str("Token![union]")
5124 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5125 formatter.write_str("Token![unsafe]")
5129 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5130 formatter.write_str("Token![unsized]")
5134 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5135 formatter.write_str("Token![use]")
5139 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5140 formatter.write_str("Token![virtual]")
5144 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5145 formatter.write_str("Token![where]")
5149 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5150 formatter.write_str("Token![while]")
5154 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
5155 formatter.write_str("Token![yield]")