aboutsummaryrefslogtreecommitdiff
path: root/crates/ra_syntax/src/ast
diff options
context:
space:
mode:
Diffstat (limited to 'crates/ra_syntax/src/ast')
-rw-r--r--crates/ra_syntax/src/ast/generated/nodes.rs1380
1 files changed, 690 insertions, 690 deletions
diff --git a/crates/ra_syntax/src/ast/generated/nodes.rs b/crates/ra_syntax/src/ast/generated/nodes.rs
index 846212a6f..8b348ad6e 100644
--- a/crates/ra_syntax/src/ast/generated/nodes.rs
+++ b/crates/ra_syntax/src/ast/generated/nodes.rs
@@ -10,11 +10,6 @@ use crate::{
10pub struct SourceFile { 10pub struct SourceFile {
11 pub(crate) syntax: SyntaxNode, 11 pub(crate) syntax: SyntaxNode,
12} 12}
13impl std::fmt::Display for SourceFile {
14 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
15 std::fmt::Display::fmt(self.syntax(), f)
16 }
17}
18impl AstNode for SourceFile { 13impl AstNode for SourceFile {
19 fn can_cast(kind: SyntaxKind) -> bool { kind == SOURCE_FILE } 14 fn can_cast(kind: SyntaxKind) -> bool { kind == SOURCE_FILE }
20 fn cast(syntax: SyntaxNode) -> Option<Self> { 15 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -36,11 +31,6 @@ impl SourceFile {
36pub struct FnDef { 31pub struct FnDef {
37 pub(crate) syntax: SyntaxNode, 32 pub(crate) syntax: SyntaxNode,
38} 33}
39impl std::fmt::Display for FnDef {
40 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
41 std::fmt::Display::fmt(self.syntax(), f)
42 }
43}
44impl AstNode for FnDef { 34impl AstNode for FnDef {
45 fn can_cast(kind: SyntaxKind) -> bool { kind == FN_DEF } 35 fn can_cast(kind: SyntaxKind) -> bool { kind == FN_DEF }
46 fn cast(syntax: SyntaxNode) -> Option<Self> { 36 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -73,11 +63,6 @@ impl FnDef {
73pub struct RetType { 63pub struct RetType {
74 pub(crate) syntax: SyntaxNode, 64 pub(crate) syntax: SyntaxNode,
75} 65}
76impl std::fmt::Display for RetType {
77 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
78 std::fmt::Display::fmt(self.syntax(), f)
79 }
80}
81impl AstNode for RetType { 66impl AstNode for RetType {
82 fn can_cast(kind: SyntaxKind) -> bool { kind == RET_TYPE } 67 fn can_cast(kind: SyntaxKind) -> bool { kind == RET_TYPE }
83 fn cast(syntax: SyntaxNode) -> Option<Self> { 68 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -97,11 +82,6 @@ impl RetType {
97pub struct StructDef { 82pub struct StructDef {
98 pub(crate) syntax: SyntaxNode, 83 pub(crate) syntax: SyntaxNode,
99} 84}
100impl std::fmt::Display for StructDef {
101 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
102 std::fmt::Display::fmt(self.syntax(), f)
103 }
104}
105impl AstNode for StructDef { 85impl AstNode for StructDef {
106 fn can_cast(kind: SyntaxKind) -> bool { kind == STRUCT_DEF } 86 fn can_cast(kind: SyntaxKind) -> bool { kind == STRUCT_DEF }
107 fn cast(syntax: SyntaxNode) -> Option<Self> { 87 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -127,11 +107,6 @@ impl StructDef {
127pub struct UnionDef { 107pub struct UnionDef {
128 pub(crate) syntax: SyntaxNode, 108 pub(crate) syntax: SyntaxNode,
129} 109}
130impl std::fmt::Display for UnionDef {
131 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
132 std::fmt::Display::fmt(self.syntax(), f)
133 }
134}
135impl AstNode for UnionDef { 110impl AstNode for UnionDef {
136 fn can_cast(kind: SyntaxKind) -> bool { kind == UNION_DEF } 111 fn can_cast(kind: SyntaxKind) -> bool { kind == UNION_DEF }
137 fn cast(syntax: SyntaxNode) -> Option<Self> { 112 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -158,11 +133,6 @@ impl UnionDef {
158pub struct RecordFieldDefList { 133pub struct RecordFieldDefList {
159 pub(crate) syntax: SyntaxNode, 134 pub(crate) syntax: SyntaxNode,
160} 135}
161impl std::fmt::Display for RecordFieldDefList {
162 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
163 std::fmt::Display::fmt(self.syntax(), f)
164 }
165}
166impl AstNode for RecordFieldDefList { 136impl AstNode for RecordFieldDefList {
167 fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD_DEF_LIST } 137 fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD_DEF_LIST }
168 fn cast(syntax: SyntaxNode) -> Option<Self> { 138 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -183,11 +153,6 @@ impl RecordFieldDefList {
183pub struct RecordFieldDef { 153pub struct RecordFieldDef {
184 pub(crate) syntax: SyntaxNode, 154 pub(crate) syntax: SyntaxNode,
185} 155}
186impl std::fmt::Display for RecordFieldDef {
187 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
188 std::fmt::Display::fmt(self.syntax(), f)
189 }
190}
191impl AstNode for RecordFieldDef { 156impl AstNode for RecordFieldDef {
192 fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD_DEF } 157 fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD_DEF }
193 fn cast(syntax: SyntaxNode) -> Option<Self> { 158 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -209,11 +174,6 @@ impl RecordFieldDef {}
209pub struct TupleFieldDefList { 174pub struct TupleFieldDefList {
210 pub(crate) syntax: SyntaxNode, 175 pub(crate) syntax: SyntaxNode,
211} 176}
212impl std::fmt::Display for TupleFieldDefList {
213 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
214 std::fmt::Display::fmt(self.syntax(), f)
215 }
216}
217impl AstNode for TupleFieldDefList { 177impl AstNode for TupleFieldDefList {
218 fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_FIELD_DEF_LIST } 178 fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_FIELD_DEF_LIST }
219 fn cast(syntax: SyntaxNode) -> Option<Self> { 179 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -234,11 +194,6 @@ impl TupleFieldDefList {
234pub struct TupleFieldDef { 194pub struct TupleFieldDef {
235 pub(crate) syntax: SyntaxNode, 195 pub(crate) syntax: SyntaxNode,
236} 196}
237impl std::fmt::Display for TupleFieldDef {
238 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
239 std::fmt::Display::fmt(self.syntax(), f)
240 }
241}
242impl AstNode for TupleFieldDef { 197impl AstNode for TupleFieldDef {
243 fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_FIELD_DEF } 198 fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_FIELD_DEF }
244 fn cast(syntax: SyntaxNode) -> Option<Self> { 199 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -259,11 +214,6 @@ impl TupleFieldDef {
259pub struct EnumDef { 214pub struct EnumDef {
260 pub(crate) syntax: SyntaxNode, 215 pub(crate) syntax: SyntaxNode,
261} 216}
262impl std::fmt::Display for EnumDef {
263 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
264 std::fmt::Display::fmt(self.syntax(), f)
265 }
266}
267impl AstNode for EnumDef { 217impl AstNode for EnumDef {
268 fn can_cast(kind: SyntaxKind) -> bool { kind == ENUM_DEF } 218 fn can_cast(kind: SyntaxKind) -> bool { kind == ENUM_DEF }
269 fn cast(syntax: SyntaxNode) -> Option<Self> { 219 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -288,11 +238,6 @@ impl EnumDef {
288pub struct EnumVariantList { 238pub struct EnumVariantList {
289 pub(crate) syntax: SyntaxNode, 239 pub(crate) syntax: SyntaxNode,
290} 240}
291impl std::fmt::Display for EnumVariantList {
292 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
293 std::fmt::Display::fmt(self.syntax(), f)
294 }
295}
296impl AstNode for EnumVariantList { 241impl AstNode for EnumVariantList {
297 fn can_cast(kind: SyntaxKind) -> bool { kind == ENUM_VARIANT_LIST } 242 fn can_cast(kind: SyntaxKind) -> bool { kind == ENUM_VARIANT_LIST }
298 fn cast(syntax: SyntaxNode) -> Option<Self> { 243 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -313,11 +258,6 @@ impl EnumVariantList {
313pub struct EnumVariant { 258pub struct EnumVariant {
314 pub(crate) syntax: SyntaxNode, 259 pub(crate) syntax: SyntaxNode,
315} 260}
316impl std::fmt::Display for EnumVariant {
317 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
318 std::fmt::Display::fmt(self.syntax(), f)
319 }
320}
321impl AstNode for EnumVariant { 261impl AstNode for EnumVariant {
322 fn can_cast(kind: SyntaxKind) -> bool { kind == ENUM_VARIANT } 262 fn can_cast(kind: SyntaxKind) -> bool { kind == ENUM_VARIANT }
323 fn cast(syntax: SyntaxNode) -> Option<Self> { 263 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -342,11 +282,6 @@ impl EnumVariant {
342pub struct TraitDef { 282pub struct TraitDef {
343 pub(crate) syntax: SyntaxNode, 283 pub(crate) syntax: SyntaxNode,
344} 284}
345impl std::fmt::Display for TraitDef {
346 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
347 std::fmt::Display::fmt(self.syntax(), f)
348 }
349}
350impl AstNode for TraitDef { 285impl AstNode for TraitDef {
351 fn can_cast(kind: SyntaxKind) -> bool { kind == TRAIT_DEF } 286 fn can_cast(kind: SyntaxKind) -> bool { kind == TRAIT_DEF }
352 fn cast(syntax: SyntaxNode) -> Option<Self> { 287 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -374,11 +309,6 @@ impl TraitDef {
374pub struct Module { 309pub struct Module {
375 pub(crate) syntax: SyntaxNode, 310 pub(crate) syntax: SyntaxNode,
376} 311}
377impl std::fmt::Display for Module {
378 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
379 std::fmt::Display::fmt(self.syntax(), f)
380 }
381}
382impl AstNode for Module { 312impl AstNode for Module {
383 fn can_cast(kind: SyntaxKind) -> bool { kind == MODULE } 313 fn can_cast(kind: SyntaxKind) -> bool { kind == MODULE }
384 fn cast(syntax: SyntaxNode) -> Option<Self> { 314 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -403,11 +333,6 @@ impl Module {
403pub struct ItemList { 333pub struct ItemList {
404 pub(crate) syntax: SyntaxNode, 334 pub(crate) syntax: SyntaxNode,
405} 335}
406impl std::fmt::Display for ItemList {
407 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
408 std::fmt::Display::fmt(self.syntax(), f)
409 }
410}
411impl AstNode for ItemList { 336impl AstNode for ItemList {
412 fn can_cast(kind: SyntaxKind) -> bool { kind == ITEM_LIST } 337 fn can_cast(kind: SyntaxKind) -> bool { kind == ITEM_LIST }
413 fn cast(syntax: SyntaxNode) -> Option<Self> { 338 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -430,11 +355,6 @@ impl ItemList {
430pub struct ConstDef { 355pub struct ConstDef {
431 pub(crate) syntax: SyntaxNode, 356 pub(crate) syntax: SyntaxNode,
432} 357}
433impl std::fmt::Display for ConstDef {
434 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
435 std::fmt::Display::fmt(self.syntax(), f)
436 }
437}
438impl AstNode for ConstDef { 358impl AstNode for ConstDef {
439 fn can_cast(kind: SyntaxKind) -> bool { kind == CONST_DEF } 359 fn can_cast(kind: SyntaxKind) -> bool { kind == CONST_DEF }
440 fn cast(syntax: SyntaxNode) -> Option<Self> { 360 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -463,11 +383,6 @@ impl ConstDef {
463pub struct StaticDef { 383pub struct StaticDef {
464 pub(crate) syntax: SyntaxNode, 384 pub(crate) syntax: SyntaxNode,
465} 385}
466impl std::fmt::Display for StaticDef {
467 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
468 std::fmt::Display::fmt(self.syntax(), f)
469 }
470}
471impl AstNode for StaticDef { 386impl AstNode for StaticDef {
472 fn can_cast(kind: SyntaxKind) -> bool { kind == STATIC_DEF } 387 fn can_cast(kind: SyntaxKind) -> bool { kind == STATIC_DEF }
473 fn cast(syntax: SyntaxNode) -> Option<Self> { 388 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -496,11 +411,6 @@ impl StaticDef {
496pub struct TypeAliasDef { 411pub struct TypeAliasDef {
497 pub(crate) syntax: SyntaxNode, 412 pub(crate) syntax: SyntaxNode,
498} 413}
499impl std::fmt::Display for TypeAliasDef {
500 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
501 std::fmt::Display::fmt(self.syntax(), f)
502 }
503}
504impl AstNode for TypeAliasDef { 414impl AstNode for TypeAliasDef {
505 fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_ALIAS_DEF } 415 fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_ALIAS_DEF }
506 fn cast(syntax: SyntaxNode) -> Option<Self> { 416 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -529,11 +439,6 @@ impl TypeAliasDef {
529pub struct ImplDef { 439pub struct ImplDef {
530 pub(crate) syntax: SyntaxNode, 440 pub(crate) syntax: SyntaxNode,
531} 441}
532impl std::fmt::Display for ImplDef {
533 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
534 std::fmt::Display::fmt(self.syntax(), f)
535 }
536}
537impl AstNode for ImplDef { 442impl AstNode for ImplDef {
538 fn can_cast(kind: SyntaxKind) -> bool { kind == IMPL_DEF } 443 fn can_cast(kind: SyntaxKind) -> bool { kind == IMPL_DEF }
539 fn cast(syntax: SyntaxNode) -> Option<Self> { 444 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -560,11 +465,6 @@ impl ImplDef {
560pub struct ParenType { 465pub struct ParenType {
561 pub(crate) syntax: SyntaxNode, 466 pub(crate) syntax: SyntaxNode,
562} 467}
563impl std::fmt::Display for ParenType {
564 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
565 std::fmt::Display::fmt(self.syntax(), f)
566 }
567}
568impl AstNode for ParenType { 468impl AstNode for ParenType {
569 fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_TYPE } 469 fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_TYPE }
570 fn cast(syntax: SyntaxNode) -> Option<Self> { 470 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -585,11 +485,6 @@ impl ParenType {
585pub struct TupleType { 485pub struct TupleType {
586 pub(crate) syntax: SyntaxNode, 486 pub(crate) syntax: SyntaxNode,
587} 487}
588impl std::fmt::Display for TupleType {
589 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
590 std::fmt::Display::fmt(self.syntax(), f)
591 }
592}
593impl AstNode for TupleType { 488impl AstNode for TupleType {
594 fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_TYPE } 489 fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_TYPE }
595 fn cast(syntax: SyntaxNode) -> Option<Self> { 490 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -610,11 +505,6 @@ impl TupleType {
610pub struct NeverType { 505pub struct NeverType {
611 pub(crate) syntax: SyntaxNode, 506 pub(crate) syntax: SyntaxNode,
612} 507}
613impl std::fmt::Display for NeverType {
614 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
615 std::fmt::Display::fmt(self.syntax(), f)
616 }
617}
618impl AstNode for NeverType { 508impl AstNode for NeverType {
619 fn can_cast(kind: SyntaxKind) -> bool { kind == NEVER_TYPE } 509 fn can_cast(kind: SyntaxKind) -> bool { kind == NEVER_TYPE }
620 fn cast(syntax: SyntaxNode) -> Option<Self> { 510 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -633,11 +523,6 @@ impl NeverType {
633pub struct PathType { 523pub struct PathType {
634 pub(crate) syntax: SyntaxNode, 524 pub(crate) syntax: SyntaxNode,
635} 525}
636impl std::fmt::Display for PathType {
637 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
638 std::fmt::Display::fmt(self.syntax(), f)
639 }
640}
641impl AstNode for PathType { 526impl AstNode for PathType {
642 fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_TYPE } 527 fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_TYPE }
643 fn cast(syntax: SyntaxNode) -> Option<Self> { 528 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -656,11 +541,6 @@ impl PathType {
656pub struct PointerType { 541pub struct PointerType {
657 pub(crate) syntax: SyntaxNode, 542 pub(crate) syntax: SyntaxNode,
658} 543}
659impl std::fmt::Display for PointerType {
660 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
661 std::fmt::Display::fmt(self.syntax(), f)
662 }
663}
664impl AstNode for PointerType { 544impl AstNode for PointerType {
665 fn can_cast(kind: SyntaxKind) -> bool { kind == POINTER_TYPE } 545 fn can_cast(kind: SyntaxKind) -> bool { kind == POINTER_TYPE }
666 fn cast(syntax: SyntaxNode) -> Option<Self> { 546 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -681,11 +561,6 @@ impl PointerType {
681pub struct ArrayType { 561pub struct ArrayType {
682 pub(crate) syntax: SyntaxNode, 562 pub(crate) syntax: SyntaxNode,
683} 563}
684impl std::fmt::Display for ArrayType {
685 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
686 std::fmt::Display::fmt(self.syntax(), f)
687 }
688}
689impl AstNode for ArrayType { 564impl AstNode for ArrayType {
690 fn can_cast(kind: SyntaxKind) -> bool { kind == ARRAY_TYPE } 565 fn can_cast(kind: SyntaxKind) -> bool { kind == ARRAY_TYPE }
691 fn cast(syntax: SyntaxNode) -> Option<Self> { 566 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -708,11 +583,6 @@ impl ArrayType {
708pub struct SliceType { 583pub struct SliceType {
709 pub(crate) syntax: SyntaxNode, 584 pub(crate) syntax: SyntaxNode,
710} 585}
711impl std::fmt::Display for SliceType {
712 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
713 std::fmt::Display::fmt(self.syntax(), f)
714 }
715}
716impl AstNode for SliceType { 586impl AstNode for SliceType {
717 fn can_cast(kind: SyntaxKind) -> bool { kind == SLICE_TYPE } 587 fn can_cast(kind: SyntaxKind) -> bool { kind == SLICE_TYPE }
718 fn cast(syntax: SyntaxNode) -> Option<Self> { 588 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -733,11 +603,6 @@ impl SliceType {
733pub struct ReferenceType { 603pub struct ReferenceType {
734 pub(crate) syntax: SyntaxNode, 604 pub(crate) syntax: SyntaxNode,
735} 605}
736impl std::fmt::Display for ReferenceType {
737 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
738 std::fmt::Display::fmt(self.syntax(), f)
739 }
740}
741impl AstNode for ReferenceType { 606impl AstNode for ReferenceType {
742 fn can_cast(kind: SyntaxKind) -> bool { kind == REFERENCE_TYPE } 607 fn can_cast(kind: SyntaxKind) -> bool { kind == REFERENCE_TYPE }
743 fn cast(syntax: SyntaxNode) -> Option<Self> { 608 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -759,11 +624,6 @@ impl ReferenceType {
759pub struct PlaceholderType { 624pub struct PlaceholderType {
760 pub(crate) syntax: SyntaxNode, 625 pub(crate) syntax: SyntaxNode,
761} 626}
762impl std::fmt::Display for PlaceholderType {
763 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
764 std::fmt::Display::fmt(self.syntax(), f)
765 }
766}
767impl AstNode for PlaceholderType { 627impl AstNode for PlaceholderType {
768 fn can_cast(kind: SyntaxKind) -> bool { kind == PLACEHOLDER_TYPE } 628 fn can_cast(kind: SyntaxKind) -> bool { kind == PLACEHOLDER_TYPE }
769 fn cast(syntax: SyntaxNode) -> Option<Self> { 629 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -782,11 +642,6 @@ impl PlaceholderType {
782pub struct FnPointerType { 642pub struct FnPointerType {
783 pub(crate) syntax: SyntaxNode, 643 pub(crate) syntax: SyntaxNode,
784} 644}
785impl std::fmt::Display for FnPointerType {
786 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
787 std::fmt::Display::fmt(self.syntax(), f)
788 }
789}
790impl AstNode for FnPointerType { 645impl AstNode for FnPointerType {
791 fn can_cast(kind: SyntaxKind) -> bool { kind == FN_POINTER_TYPE } 646 fn can_cast(kind: SyntaxKind) -> bool { kind == FN_POINTER_TYPE }
792 fn cast(syntax: SyntaxNode) -> Option<Self> { 647 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -809,11 +664,6 @@ impl FnPointerType {
809pub struct ForType { 664pub struct ForType {
810 pub(crate) syntax: SyntaxNode, 665 pub(crate) syntax: SyntaxNode,
811} 666}
812impl std::fmt::Display for ForType {
813 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
814 std::fmt::Display::fmt(self.syntax(), f)
815 }
816}
817impl AstNode for ForType { 667impl AstNode for ForType {
818 fn can_cast(kind: SyntaxKind) -> bool { kind == FOR_TYPE } 668 fn can_cast(kind: SyntaxKind) -> bool { kind == FOR_TYPE }
819 fn cast(syntax: SyntaxNode) -> Option<Self> { 669 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -834,11 +684,6 @@ impl ForType {
834pub struct ImplTraitType { 684pub struct ImplTraitType {
835 pub(crate) syntax: SyntaxNode, 685 pub(crate) syntax: SyntaxNode,
836} 686}
837impl std::fmt::Display for ImplTraitType {
838 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
839 std::fmt::Display::fmt(self.syntax(), f)
840 }
841}
842impl AstNode for ImplTraitType { 687impl AstNode for ImplTraitType {
843 fn can_cast(kind: SyntaxKind) -> bool { kind == IMPL_TRAIT_TYPE } 688 fn can_cast(kind: SyntaxKind) -> bool { kind == IMPL_TRAIT_TYPE }
844 fn cast(syntax: SyntaxNode) -> Option<Self> { 689 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -858,11 +703,6 @@ impl ImplTraitType {
858pub struct DynTraitType { 703pub struct DynTraitType {
859 pub(crate) syntax: SyntaxNode, 704 pub(crate) syntax: SyntaxNode,
860} 705}
861impl std::fmt::Display for DynTraitType {
862 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
863 std::fmt::Display::fmt(self.syntax(), f)
864 }
865}
866impl AstNode for DynTraitType { 706impl AstNode for DynTraitType {
867 fn can_cast(kind: SyntaxKind) -> bool { kind == DYN_TRAIT_TYPE } 707 fn can_cast(kind: SyntaxKind) -> bool { kind == DYN_TRAIT_TYPE }
868 fn cast(syntax: SyntaxNode) -> Option<Self> { 708 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -882,11 +722,6 @@ impl DynTraitType {
882pub struct TupleExpr { 722pub struct TupleExpr {
883 pub(crate) syntax: SyntaxNode, 723 pub(crate) syntax: SyntaxNode,
884} 724}
885impl std::fmt::Display for TupleExpr {
886 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
887 std::fmt::Display::fmt(self.syntax(), f)
888 }
889}
890impl AstNode for TupleExpr { 725impl AstNode for TupleExpr {
891 fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_EXPR } 726 fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_EXPR }
892 fn cast(syntax: SyntaxNode) -> Option<Self> { 727 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -908,11 +743,6 @@ impl TupleExpr {
908pub struct ArrayExpr { 743pub struct ArrayExpr {
909 pub(crate) syntax: SyntaxNode, 744 pub(crate) syntax: SyntaxNode,
910} 745}
911impl std::fmt::Display for ArrayExpr {
912 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
913 std::fmt::Display::fmt(self.syntax(), f)
914 }
915}
916impl AstNode for ArrayExpr { 746impl AstNode for ArrayExpr {
917 fn can_cast(kind: SyntaxKind) -> bool { kind == ARRAY_EXPR } 747 fn can_cast(kind: SyntaxKind) -> bool { kind == ARRAY_EXPR }
918 fn cast(syntax: SyntaxNode) -> Option<Self> { 748 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -935,11 +765,6 @@ impl ArrayExpr {
935pub struct ParenExpr { 765pub struct ParenExpr {
936 pub(crate) syntax: SyntaxNode, 766 pub(crate) syntax: SyntaxNode,
937} 767}
938impl std::fmt::Display for ParenExpr {
939 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
940 std::fmt::Display::fmt(self.syntax(), f)
941 }
942}
943impl AstNode for ParenExpr { 768impl AstNode for ParenExpr {
944 fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_EXPR } 769 fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_EXPR }
945 fn cast(syntax: SyntaxNode) -> Option<Self> { 770 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -961,11 +786,6 @@ impl ParenExpr {
961pub struct PathExpr { 786pub struct PathExpr {
962 pub(crate) syntax: SyntaxNode, 787 pub(crate) syntax: SyntaxNode,
963} 788}
964impl std::fmt::Display for PathExpr {
965 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
966 std::fmt::Display::fmt(self.syntax(), f)
967 }
968}
969impl AstNode for PathExpr { 789impl AstNode for PathExpr {
970 fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_EXPR } 790 fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_EXPR }
971 fn cast(syntax: SyntaxNode) -> Option<Self> { 791 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -984,11 +804,6 @@ impl PathExpr {
984pub struct LambdaExpr { 804pub struct LambdaExpr {
985 pub(crate) syntax: SyntaxNode, 805 pub(crate) syntax: SyntaxNode,
986} 806}
987impl std::fmt::Display for LambdaExpr {
988 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
989 std::fmt::Display::fmt(self.syntax(), f)
990 }
991}
992impl AstNode for LambdaExpr { 807impl AstNode for LambdaExpr {
993 fn can_cast(kind: SyntaxKind) -> bool { kind == LAMBDA_EXPR } 808 fn can_cast(kind: SyntaxKind) -> bool { kind == LAMBDA_EXPR }
994 fn cast(syntax: SyntaxNode) -> Option<Self> { 809 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1013,11 +828,6 @@ impl LambdaExpr {
1013pub struct IfExpr { 828pub struct IfExpr {
1014 pub(crate) syntax: SyntaxNode, 829 pub(crate) syntax: SyntaxNode,
1015} 830}
1016impl std::fmt::Display for IfExpr {
1017 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1018 std::fmt::Display::fmt(self.syntax(), f)
1019 }
1020}
1021impl AstNode for IfExpr { 831impl AstNode for IfExpr {
1022 fn can_cast(kind: SyntaxKind) -> bool { kind == IF_EXPR } 832 fn can_cast(kind: SyntaxKind) -> bool { kind == IF_EXPR }
1023 fn cast(syntax: SyntaxNode) -> Option<Self> { 833 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1038,11 +848,6 @@ impl IfExpr {
1038pub struct LoopExpr { 848pub struct LoopExpr {
1039 pub(crate) syntax: SyntaxNode, 849 pub(crate) syntax: SyntaxNode,
1040} 850}
1041impl std::fmt::Display for LoopExpr {
1042 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1043 std::fmt::Display::fmt(self.syntax(), f)
1044 }
1045}
1046impl AstNode for LoopExpr { 851impl AstNode for LoopExpr {
1047 fn can_cast(kind: SyntaxKind) -> bool { kind == LOOP_EXPR } 852 fn can_cast(kind: SyntaxKind) -> bool { kind == LOOP_EXPR }
1048 fn cast(syntax: SyntaxNode) -> Option<Self> { 853 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1063,11 +868,6 @@ impl LoopExpr {
1063pub struct TryBlockExpr { 868pub struct TryBlockExpr {
1064 pub(crate) syntax: SyntaxNode, 869 pub(crate) syntax: SyntaxNode,
1065} 870}
1066impl std::fmt::Display for TryBlockExpr {
1067 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1068 std::fmt::Display::fmt(self.syntax(), f)
1069 }
1070}
1071impl AstNode for TryBlockExpr { 871impl AstNode for TryBlockExpr {
1072 fn can_cast(kind: SyntaxKind) -> bool { kind == TRY_BLOCK_EXPR } 872 fn can_cast(kind: SyntaxKind) -> bool { kind == TRY_BLOCK_EXPR }
1073 fn cast(syntax: SyntaxNode) -> Option<Self> { 873 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1088,11 +888,6 @@ impl TryBlockExpr {
1088pub struct ForExpr { 888pub struct ForExpr {
1089 pub(crate) syntax: SyntaxNode, 889 pub(crate) syntax: SyntaxNode,
1090} 890}
1091impl std::fmt::Display for ForExpr {
1092 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1093 std::fmt::Display::fmt(self.syntax(), f)
1094 }
1095}
1096impl AstNode for ForExpr { 891impl AstNode for ForExpr {
1097 fn can_cast(kind: SyntaxKind) -> bool { kind == FOR_EXPR } 892 fn can_cast(kind: SyntaxKind) -> bool { kind == FOR_EXPR }
1098 fn cast(syntax: SyntaxNode) -> Option<Self> { 893 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1116,11 +911,6 @@ impl ForExpr {
1116pub struct WhileExpr { 911pub struct WhileExpr {
1117 pub(crate) syntax: SyntaxNode, 912 pub(crate) syntax: SyntaxNode,
1118} 913}
1119impl std::fmt::Display for WhileExpr {
1120 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1121 std::fmt::Display::fmt(self.syntax(), f)
1122 }
1123}
1124impl AstNode for WhileExpr { 914impl AstNode for WhileExpr {
1125 fn can_cast(kind: SyntaxKind) -> bool { kind == WHILE_EXPR } 915 fn can_cast(kind: SyntaxKind) -> bool { kind == WHILE_EXPR }
1126 fn cast(syntax: SyntaxNode) -> Option<Self> { 916 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1142,11 +932,6 @@ impl WhileExpr {
1142pub struct ContinueExpr { 932pub struct ContinueExpr {
1143 pub(crate) syntax: SyntaxNode, 933 pub(crate) syntax: SyntaxNode,
1144} 934}
1145impl std::fmt::Display for ContinueExpr {
1146 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1147 std::fmt::Display::fmt(self.syntax(), f)
1148 }
1149}
1150impl AstNode for ContinueExpr { 935impl AstNode for ContinueExpr {
1151 fn can_cast(kind: SyntaxKind) -> bool { kind == CONTINUE_EXPR } 936 fn can_cast(kind: SyntaxKind) -> bool { kind == CONTINUE_EXPR }
1152 fn cast(syntax: SyntaxNode) -> Option<Self> { 937 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1167,11 +952,6 @@ impl ContinueExpr {
1167pub struct BreakExpr { 952pub struct BreakExpr {
1168 pub(crate) syntax: SyntaxNode, 953 pub(crate) syntax: SyntaxNode,
1169} 954}
1170impl std::fmt::Display for BreakExpr {
1171 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1172 std::fmt::Display::fmt(self.syntax(), f)
1173 }
1174}
1175impl AstNode for BreakExpr { 955impl AstNode for BreakExpr {
1176 fn can_cast(kind: SyntaxKind) -> bool { kind == BREAK_EXPR } 956 fn can_cast(kind: SyntaxKind) -> bool { kind == BREAK_EXPR }
1177 fn cast(syntax: SyntaxNode) -> Option<Self> { 957 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1193,11 +973,6 @@ impl BreakExpr {
1193pub struct Label { 973pub struct Label {
1194 pub(crate) syntax: SyntaxNode, 974 pub(crate) syntax: SyntaxNode,
1195} 975}
1196impl std::fmt::Display for Label {
1197 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1198 std::fmt::Display::fmt(self.syntax(), f)
1199 }
1200}
1201impl AstNode for Label { 976impl AstNode for Label {
1202 fn can_cast(kind: SyntaxKind) -> bool { kind == LABEL } 977 fn can_cast(kind: SyntaxKind) -> bool { kind == LABEL }
1203 fn cast(syntax: SyntaxNode) -> Option<Self> { 978 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1216,11 +991,6 @@ impl Label {
1216pub struct BlockExpr { 991pub struct BlockExpr {
1217 pub(crate) syntax: SyntaxNode, 992 pub(crate) syntax: SyntaxNode,
1218} 993}
1219impl std::fmt::Display for BlockExpr {
1220 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1221 std::fmt::Display::fmt(self.syntax(), f)
1222 }
1223}
1224impl AstNode for BlockExpr { 994impl AstNode for BlockExpr {
1225 fn can_cast(kind: SyntaxKind) -> bool { kind == BLOCK_EXPR } 995 fn can_cast(kind: SyntaxKind) -> bool { kind == BLOCK_EXPR }
1226 fn cast(syntax: SyntaxNode) -> Option<Self> { 996 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1242,11 +1012,6 @@ impl BlockExpr {
1242pub struct ReturnExpr { 1012pub struct ReturnExpr {
1243 pub(crate) syntax: SyntaxNode, 1013 pub(crate) syntax: SyntaxNode,
1244} 1014}
1245impl std::fmt::Display for ReturnExpr {
1246 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1247 std::fmt::Display::fmt(self.syntax(), f)
1248 }
1249}
1250impl AstNode for ReturnExpr { 1015impl AstNode for ReturnExpr {
1251 fn can_cast(kind: SyntaxKind) -> bool { kind == RETURN_EXPR } 1016 fn can_cast(kind: SyntaxKind) -> bool { kind == RETURN_EXPR }
1252 fn cast(syntax: SyntaxNode) -> Option<Self> { 1017 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1266,11 +1031,6 @@ impl ReturnExpr {
1266pub struct CallExpr { 1031pub struct CallExpr {
1267 pub(crate) syntax: SyntaxNode, 1032 pub(crate) syntax: SyntaxNode,
1268} 1033}
1269impl std::fmt::Display for CallExpr {
1270 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1271 std::fmt::Display::fmt(self.syntax(), f)
1272 }
1273}
1274impl AstNode for CallExpr { 1034impl AstNode for CallExpr {
1275 fn can_cast(kind: SyntaxKind) -> bool { kind == CALL_EXPR } 1035 fn can_cast(kind: SyntaxKind) -> bool { kind == CALL_EXPR }
1276 fn cast(syntax: SyntaxNode) -> Option<Self> { 1036 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1290,11 +1050,6 @@ impl CallExpr {
1290pub struct MethodCallExpr { 1050pub struct MethodCallExpr {
1291 pub(crate) syntax: SyntaxNode, 1051 pub(crate) syntax: SyntaxNode,
1292} 1052}
1293impl std::fmt::Display for MethodCallExpr {
1294 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1295 std::fmt::Display::fmt(self.syntax(), f)
1296 }
1297}
1298impl AstNode for MethodCallExpr { 1053impl AstNode for MethodCallExpr {
1299 fn can_cast(kind: SyntaxKind) -> bool { kind == METHOD_CALL_EXPR } 1054 fn can_cast(kind: SyntaxKind) -> bool { kind == METHOD_CALL_EXPR }
1300 fn cast(syntax: SyntaxNode) -> Option<Self> { 1055 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1318,11 +1073,6 @@ impl MethodCallExpr {
1318pub struct IndexExpr { 1073pub struct IndexExpr {
1319 pub(crate) syntax: SyntaxNode, 1074 pub(crate) syntax: SyntaxNode,
1320} 1075}
1321impl std::fmt::Display for IndexExpr {
1322 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1323 std::fmt::Display::fmt(self.syntax(), f)
1324 }
1325}
1326impl AstNode for IndexExpr { 1076impl AstNode for IndexExpr {
1327 fn can_cast(kind: SyntaxKind) -> bool { kind == INDEX_EXPR } 1077 fn can_cast(kind: SyntaxKind) -> bool { kind == INDEX_EXPR }
1328 fn cast(syntax: SyntaxNode) -> Option<Self> { 1078 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1343,11 +1093,6 @@ impl IndexExpr {
1343pub struct FieldExpr { 1093pub struct FieldExpr {
1344 pub(crate) syntax: SyntaxNode, 1094 pub(crate) syntax: SyntaxNode,
1345} 1095}
1346impl std::fmt::Display for FieldExpr {
1347 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1348 std::fmt::Display::fmt(self.syntax(), f)
1349 }
1350}
1351impl AstNode for FieldExpr { 1096impl AstNode for FieldExpr {
1352 fn can_cast(kind: SyntaxKind) -> bool { kind == FIELD_EXPR } 1097 fn can_cast(kind: SyntaxKind) -> bool { kind == FIELD_EXPR }
1353 fn cast(syntax: SyntaxNode) -> Option<Self> { 1098 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1369,11 +1114,6 @@ impl FieldExpr {
1369pub struct AwaitExpr { 1114pub struct AwaitExpr {
1370 pub(crate) syntax: SyntaxNode, 1115 pub(crate) syntax: SyntaxNode,
1371} 1116}
1372impl std::fmt::Display for AwaitExpr {
1373 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1374 std::fmt::Display::fmt(self.syntax(), f)
1375 }
1376}
1377impl AstNode for AwaitExpr { 1117impl AstNode for AwaitExpr {
1378 fn can_cast(kind: SyntaxKind) -> bool { kind == AWAIT_EXPR } 1118 fn can_cast(kind: SyntaxKind) -> bool { kind == AWAIT_EXPR }
1379 fn cast(syntax: SyntaxNode) -> Option<Self> { 1119 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1395,11 +1135,6 @@ impl AwaitExpr {
1395pub struct TryExpr { 1135pub struct TryExpr {
1396 pub(crate) syntax: SyntaxNode, 1136 pub(crate) syntax: SyntaxNode,
1397} 1137}
1398impl std::fmt::Display for TryExpr {
1399 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1400 std::fmt::Display::fmt(self.syntax(), f)
1401 }
1402}
1403impl AstNode for TryExpr { 1138impl AstNode for TryExpr {
1404 fn can_cast(kind: SyntaxKind) -> bool { kind == TRY_EXPR } 1139 fn can_cast(kind: SyntaxKind) -> bool { kind == TRY_EXPR }
1405 fn cast(syntax: SyntaxNode) -> Option<Self> { 1140 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1420,11 +1155,6 @@ impl TryExpr {
1420pub struct CastExpr { 1155pub struct CastExpr {
1421 pub(crate) syntax: SyntaxNode, 1156 pub(crate) syntax: SyntaxNode,
1422} 1157}
1423impl std::fmt::Display for CastExpr {
1424 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1425 std::fmt::Display::fmt(self.syntax(), f)
1426 }
1427}
1428impl AstNode for CastExpr { 1158impl AstNode for CastExpr {
1429 fn can_cast(kind: SyntaxKind) -> bool { kind == CAST_EXPR } 1159 fn can_cast(kind: SyntaxKind) -> bool { kind == CAST_EXPR }
1430 fn cast(syntax: SyntaxNode) -> Option<Self> { 1160 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1446,11 +1176,6 @@ impl CastExpr {
1446pub struct RefExpr { 1176pub struct RefExpr {
1447 pub(crate) syntax: SyntaxNode, 1177 pub(crate) syntax: SyntaxNode,
1448} 1178}
1449impl std::fmt::Display for RefExpr {
1450 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1451 std::fmt::Display::fmt(self.syntax(), f)
1452 }
1453}
1454impl AstNode for RefExpr { 1179impl AstNode for RefExpr {
1455 fn can_cast(kind: SyntaxKind) -> bool { kind == REF_EXPR } 1180 fn can_cast(kind: SyntaxKind) -> bool { kind == REF_EXPR }
1456 fn cast(syntax: SyntaxNode) -> Option<Self> { 1181 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1473,11 +1198,6 @@ impl RefExpr {
1473pub struct PrefixExpr { 1198pub struct PrefixExpr {
1474 pub(crate) syntax: SyntaxNode, 1199 pub(crate) syntax: SyntaxNode,
1475} 1200}
1476impl std::fmt::Display for PrefixExpr {
1477 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1478 std::fmt::Display::fmt(self.syntax(), f)
1479 }
1480}
1481impl AstNode for PrefixExpr { 1201impl AstNode for PrefixExpr {
1482 fn can_cast(kind: SyntaxKind) -> bool { kind == PREFIX_EXPR } 1202 fn can_cast(kind: SyntaxKind) -> bool { kind == PREFIX_EXPR }
1483 fn cast(syntax: SyntaxNode) -> Option<Self> { 1203 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1498,11 +1218,6 @@ impl PrefixExpr {
1498pub struct BoxExpr { 1218pub struct BoxExpr {
1499 pub(crate) syntax: SyntaxNode, 1219 pub(crate) syntax: SyntaxNode,
1500} 1220}
1501impl std::fmt::Display for BoxExpr {
1502 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1503 std::fmt::Display::fmt(self.syntax(), f)
1504 }
1505}
1506impl AstNode for BoxExpr { 1221impl AstNode for BoxExpr {
1507 fn can_cast(kind: SyntaxKind) -> bool { kind == BOX_EXPR } 1222 fn can_cast(kind: SyntaxKind) -> bool { kind == BOX_EXPR }
1508 fn cast(syntax: SyntaxNode) -> Option<Self> { 1223 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1523,11 +1238,6 @@ impl BoxExpr {
1523pub struct RangeExpr { 1238pub struct RangeExpr {
1524 pub(crate) syntax: SyntaxNode, 1239 pub(crate) syntax: SyntaxNode,
1525} 1240}
1526impl std::fmt::Display for RangeExpr {
1527 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1528 std::fmt::Display::fmt(self.syntax(), f)
1529 }
1530}
1531impl AstNode for RangeExpr { 1241impl AstNode for RangeExpr {
1532 fn can_cast(kind: SyntaxKind) -> bool { kind == RANGE_EXPR } 1242 fn can_cast(kind: SyntaxKind) -> bool { kind == RANGE_EXPR }
1533 fn cast(syntax: SyntaxNode) -> Option<Self> { 1243 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1547,11 +1257,6 @@ impl RangeExpr {
1547pub struct BinExpr { 1257pub struct BinExpr {
1548 pub(crate) syntax: SyntaxNode, 1258 pub(crate) syntax: SyntaxNode,
1549} 1259}
1550impl std::fmt::Display for BinExpr {
1551 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1552 std::fmt::Display::fmt(self.syntax(), f)
1553 }
1554}
1555impl AstNode for BinExpr { 1260impl AstNode for BinExpr {
1556 fn can_cast(kind: SyntaxKind) -> bool { kind == BIN_EXPR } 1261 fn can_cast(kind: SyntaxKind) -> bool { kind == BIN_EXPR }
1557 fn cast(syntax: SyntaxNode) -> Option<Self> { 1262 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1571,11 +1276,6 @@ impl BinExpr {
1571pub struct Literal { 1276pub struct Literal {
1572 pub(crate) syntax: SyntaxNode, 1277 pub(crate) syntax: SyntaxNode,
1573} 1278}
1574impl std::fmt::Display for Literal {
1575 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1576 std::fmt::Display::fmt(self.syntax(), f)
1577 }
1578}
1579impl AstNode for Literal { 1279impl AstNode for Literal {
1580 fn can_cast(kind: SyntaxKind) -> bool { kind == LITERAL } 1280 fn can_cast(kind: SyntaxKind) -> bool { kind == LITERAL }
1581 fn cast(syntax: SyntaxNode) -> Option<Self> { 1281 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1594,11 +1294,6 @@ impl Literal {
1594pub struct MatchExpr { 1294pub struct MatchExpr {
1595 pub(crate) syntax: SyntaxNode, 1295 pub(crate) syntax: SyntaxNode,
1596} 1296}
1597impl std::fmt::Display for MatchExpr {
1598 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1599 std::fmt::Display::fmt(self.syntax(), f)
1600 }
1601}
1602impl AstNode for MatchExpr { 1297impl AstNode for MatchExpr {
1603 fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_EXPR } 1298 fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_EXPR }
1604 fn cast(syntax: SyntaxNode) -> Option<Self> { 1299 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1620,11 +1315,6 @@ impl MatchExpr {
1620pub struct MatchArmList { 1315pub struct MatchArmList {
1621 pub(crate) syntax: SyntaxNode, 1316 pub(crate) syntax: SyntaxNode,
1622} 1317}
1623impl std::fmt::Display for MatchArmList {
1624 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1625 std::fmt::Display::fmt(self.syntax(), f)
1626 }
1627}
1628impl AstNode for MatchArmList { 1318impl AstNode for MatchArmList {
1629 fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_ARM_LIST } 1319 fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_ARM_LIST }
1630 fn cast(syntax: SyntaxNode) -> Option<Self> { 1320 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1646,11 +1336,6 @@ impl MatchArmList {
1646pub struct MatchArm { 1336pub struct MatchArm {
1647 pub(crate) syntax: SyntaxNode, 1337 pub(crate) syntax: SyntaxNode,
1648} 1338}
1649impl std::fmt::Display for MatchArm {
1650 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1651 std::fmt::Display::fmt(self.syntax(), f)
1652 }
1653}
1654impl AstNode for MatchArm { 1339impl AstNode for MatchArm {
1655 fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_ARM } 1340 fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_ARM }
1656 fn cast(syntax: SyntaxNode) -> Option<Self> { 1341 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1673,11 +1358,6 @@ impl MatchArm {
1673pub struct MatchGuard { 1358pub struct MatchGuard {
1674 pub(crate) syntax: SyntaxNode, 1359 pub(crate) syntax: SyntaxNode,
1675} 1360}
1676impl std::fmt::Display for MatchGuard {
1677 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1678 std::fmt::Display::fmt(self.syntax(), f)
1679 }
1680}
1681impl AstNode for MatchGuard { 1361impl AstNode for MatchGuard {
1682 fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_GUARD } 1362 fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_GUARD }
1683 fn cast(syntax: SyntaxNode) -> Option<Self> { 1363 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1697,11 +1377,6 @@ impl MatchGuard {
1697pub struct RecordLit { 1377pub struct RecordLit {
1698 pub(crate) syntax: SyntaxNode, 1378 pub(crate) syntax: SyntaxNode,
1699} 1379}
1700impl std::fmt::Display for RecordLit {
1701 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1702 std::fmt::Display::fmt(self.syntax(), f)
1703 }
1704}
1705impl AstNode for RecordLit { 1380impl AstNode for RecordLit {
1706 fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_LIT } 1381 fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_LIT }
1707 fn cast(syntax: SyntaxNode) -> Option<Self> { 1382 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1721,11 +1396,6 @@ impl RecordLit {
1721pub struct RecordFieldList { 1396pub struct RecordFieldList {
1722 pub(crate) syntax: SyntaxNode, 1397 pub(crate) syntax: SyntaxNode,
1723} 1398}
1724impl std::fmt::Display for RecordFieldList {
1725 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1726 std::fmt::Display::fmt(self.syntax(), f)
1727 }
1728}
1729impl AstNode for RecordFieldList { 1399impl AstNode for RecordFieldList {
1730 fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD_LIST } 1400 fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD_LIST }
1731 fn cast(syntax: SyntaxNode) -> Option<Self> { 1401 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1748,11 +1418,6 @@ impl RecordFieldList {
1748pub struct RecordField { 1418pub struct RecordField {
1749 pub(crate) syntax: SyntaxNode, 1419 pub(crate) syntax: SyntaxNode,
1750} 1420}
1751impl std::fmt::Display for RecordField {
1752 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1753 std::fmt::Display::fmt(self.syntax(), f)
1754 }
1755}
1756impl AstNode for RecordField { 1421impl AstNode for RecordField {
1757 fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD } 1422 fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD }
1758 fn cast(syntax: SyntaxNode) -> Option<Self> { 1423 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1774,11 +1439,6 @@ impl RecordField {
1774pub struct OrPat { 1439pub struct OrPat {
1775 pub(crate) syntax: SyntaxNode, 1440 pub(crate) syntax: SyntaxNode,
1776} 1441}
1777impl std::fmt::Display for OrPat {
1778 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1779 std::fmt::Display::fmt(self.syntax(), f)
1780 }
1781}
1782impl AstNode for OrPat { 1442impl AstNode for OrPat {
1783 fn can_cast(kind: SyntaxKind) -> bool { kind == OR_PAT } 1443 fn can_cast(kind: SyntaxKind) -> bool { kind == OR_PAT }
1784 fn cast(syntax: SyntaxNode) -> Option<Self> { 1444 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1797,11 +1457,6 @@ impl OrPat {
1797pub struct ParenPat { 1457pub struct ParenPat {
1798 pub(crate) syntax: SyntaxNode, 1458 pub(crate) syntax: SyntaxNode,
1799} 1459}
1800impl std::fmt::Display for ParenPat {
1801 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1802 std::fmt::Display::fmt(self.syntax(), f)
1803 }
1804}
1805impl AstNode for ParenPat { 1460impl AstNode for ParenPat {
1806 fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_PAT } 1461 fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_PAT }
1807 fn cast(syntax: SyntaxNode) -> Option<Self> { 1462 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1822,11 +1477,6 @@ impl ParenPat {
1822pub struct RefPat { 1477pub struct RefPat {
1823 pub(crate) syntax: SyntaxNode, 1478 pub(crate) syntax: SyntaxNode,
1824} 1479}
1825impl std::fmt::Display for RefPat {
1826 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1827 std::fmt::Display::fmt(self.syntax(), f)
1828 }
1829}
1830impl AstNode for RefPat { 1480impl AstNode for RefPat {
1831 fn can_cast(kind: SyntaxKind) -> bool { kind == REF_PAT } 1481 fn can_cast(kind: SyntaxKind) -> bool { kind == REF_PAT }
1832 fn cast(syntax: SyntaxNode) -> Option<Self> { 1482 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1847,11 +1497,6 @@ impl RefPat {
1847pub struct BoxPat { 1497pub struct BoxPat {
1848 pub(crate) syntax: SyntaxNode, 1498 pub(crate) syntax: SyntaxNode,
1849} 1499}
1850impl std::fmt::Display for BoxPat {
1851 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1852 std::fmt::Display::fmt(self.syntax(), f)
1853 }
1854}
1855impl AstNode for BoxPat { 1500impl AstNode for BoxPat {
1856 fn can_cast(kind: SyntaxKind) -> bool { kind == BOX_PAT } 1501 fn can_cast(kind: SyntaxKind) -> bool { kind == BOX_PAT }
1857 fn cast(syntax: SyntaxNode) -> Option<Self> { 1502 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1871,11 +1516,6 @@ impl BoxPat {
1871pub struct BindPat { 1516pub struct BindPat {
1872 pub(crate) syntax: SyntaxNode, 1517 pub(crate) syntax: SyntaxNode,
1873} 1518}
1874impl std::fmt::Display for BindPat {
1875 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1876 std::fmt::Display::fmt(self.syntax(), f)
1877 }
1878}
1879impl AstNode for BindPat { 1519impl AstNode for BindPat {
1880 fn can_cast(kind: SyntaxKind) -> bool { kind == BIND_PAT } 1520 fn can_cast(kind: SyntaxKind) -> bool { kind == BIND_PAT }
1881 fn cast(syntax: SyntaxNode) -> Option<Self> { 1521 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1898,11 +1538,6 @@ impl BindPat {
1898pub struct PlaceholderPat { 1538pub struct PlaceholderPat {
1899 pub(crate) syntax: SyntaxNode, 1539 pub(crate) syntax: SyntaxNode,
1900} 1540}
1901impl std::fmt::Display for PlaceholderPat {
1902 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1903 std::fmt::Display::fmt(self.syntax(), f)
1904 }
1905}
1906impl AstNode for PlaceholderPat { 1541impl AstNode for PlaceholderPat {
1907 fn can_cast(kind: SyntaxKind) -> bool { kind == PLACEHOLDER_PAT } 1542 fn can_cast(kind: SyntaxKind) -> bool { kind == PLACEHOLDER_PAT }
1908 fn cast(syntax: SyntaxNode) -> Option<Self> { 1543 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1921,11 +1556,6 @@ impl PlaceholderPat {
1921pub struct DotDotPat { 1556pub struct DotDotPat {
1922 pub(crate) syntax: SyntaxNode, 1557 pub(crate) syntax: SyntaxNode,
1923} 1558}
1924impl std::fmt::Display for DotDotPat {
1925 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1926 std::fmt::Display::fmt(self.syntax(), f)
1927 }
1928}
1929impl AstNode for DotDotPat { 1559impl AstNode for DotDotPat {
1930 fn can_cast(kind: SyntaxKind) -> bool { kind == DOT_DOT_PAT } 1560 fn can_cast(kind: SyntaxKind) -> bool { kind == DOT_DOT_PAT }
1931 fn cast(syntax: SyntaxNode) -> Option<Self> { 1561 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1944,11 +1574,6 @@ impl DotDotPat {
1944pub struct PathPat { 1574pub struct PathPat {
1945 pub(crate) syntax: SyntaxNode, 1575 pub(crate) syntax: SyntaxNode,
1946} 1576}
1947impl std::fmt::Display for PathPat {
1948 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1949 std::fmt::Display::fmt(self.syntax(), f)
1950 }
1951}
1952impl AstNode for PathPat { 1577impl AstNode for PathPat {
1953 fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_PAT } 1578 fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_PAT }
1954 fn cast(syntax: SyntaxNode) -> Option<Self> { 1579 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1967,11 +1592,6 @@ impl PathPat {
1967pub struct SlicePat { 1592pub struct SlicePat {
1968 pub(crate) syntax: SyntaxNode, 1593 pub(crate) syntax: SyntaxNode,
1969} 1594}
1970impl std::fmt::Display for SlicePat {
1971 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1972 std::fmt::Display::fmt(self.syntax(), f)
1973 }
1974}
1975impl AstNode for SlicePat { 1595impl AstNode for SlicePat {
1976 fn can_cast(kind: SyntaxKind) -> bool { kind == SLICE_PAT } 1596 fn can_cast(kind: SyntaxKind) -> bool { kind == SLICE_PAT }
1977 fn cast(syntax: SyntaxNode) -> Option<Self> { 1597 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1992,11 +1612,6 @@ impl SlicePat {
1992pub struct RangePat { 1612pub struct RangePat {
1993 pub(crate) syntax: SyntaxNode, 1613 pub(crate) syntax: SyntaxNode,
1994} 1614}
1995impl std::fmt::Display for RangePat {
1996 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1997 std::fmt::Display::fmt(self.syntax(), f)
1998 }
1999}
2000impl AstNode for RangePat { 1615impl AstNode for RangePat {
2001 fn can_cast(kind: SyntaxKind) -> bool { kind == RANGE_PAT } 1616 fn can_cast(kind: SyntaxKind) -> bool { kind == RANGE_PAT }
2002 fn cast(syntax: SyntaxNode) -> Option<Self> { 1617 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2015,11 +1630,6 @@ impl RangePat {
2015pub struct LiteralPat { 1630pub struct LiteralPat {
2016 pub(crate) syntax: SyntaxNode, 1631 pub(crate) syntax: SyntaxNode,
2017} 1632}
2018impl std::fmt::Display for LiteralPat {
2019 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2020 std::fmt::Display::fmt(self.syntax(), f)
2021 }
2022}
2023impl AstNode for LiteralPat { 1633impl AstNode for LiteralPat {
2024 fn can_cast(kind: SyntaxKind) -> bool { kind == LITERAL_PAT } 1634 fn can_cast(kind: SyntaxKind) -> bool { kind == LITERAL_PAT }
2025 fn cast(syntax: SyntaxNode) -> Option<Self> { 1635 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2038,11 +1648,6 @@ impl LiteralPat {
2038pub struct MacroPat { 1648pub struct MacroPat {
2039 pub(crate) syntax: SyntaxNode, 1649 pub(crate) syntax: SyntaxNode,
2040} 1650}
2041impl std::fmt::Display for MacroPat {
2042 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2043 std::fmt::Display::fmt(self.syntax(), f)
2044 }
2045}
2046impl AstNode for MacroPat { 1651impl AstNode for MacroPat {
2047 fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_PAT } 1652 fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_PAT }
2048 fn cast(syntax: SyntaxNode) -> Option<Self> { 1653 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2061,11 +1666,6 @@ impl MacroPat {
2061pub struct RecordPat { 1666pub struct RecordPat {
2062 pub(crate) syntax: SyntaxNode, 1667 pub(crate) syntax: SyntaxNode,
2063} 1668}
2064impl std::fmt::Display for RecordPat {
2065 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2066 std::fmt::Display::fmt(self.syntax(), f)
2067 }
2068}
2069impl AstNode for RecordPat { 1669impl AstNode for RecordPat {
2070 fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_PAT } 1670 fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_PAT }
2071 fn cast(syntax: SyntaxNode) -> Option<Self> { 1671 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2087,11 +1687,6 @@ impl RecordPat {
2087pub struct RecordFieldPatList { 1687pub struct RecordFieldPatList {
2088 pub(crate) syntax: SyntaxNode, 1688 pub(crate) syntax: SyntaxNode,
2089} 1689}
2090impl std::fmt::Display for RecordFieldPatList {
2091 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2092 std::fmt::Display::fmt(self.syntax(), f)
2093 }
2094}
2095impl AstNode for RecordFieldPatList { 1690impl AstNode for RecordFieldPatList {
2096 fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD_PAT_LIST } 1691 fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD_PAT_LIST }
2097 fn cast(syntax: SyntaxNode) -> Option<Self> { 1692 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2117,11 +1712,6 @@ impl RecordFieldPatList {
2117pub struct RecordFieldPat { 1712pub struct RecordFieldPat {
2118 pub(crate) syntax: SyntaxNode, 1713 pub(crate) syntax: SyntaxNode,
2119} 1714}
2120impl std::fmt::Display for RecordFieldPat {
2121 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2122 std::fmt::Display::fmt(self.syntax(), f)
2123 }
2124}
2125impl AstNode for RecordFieldPat { 1715impl AstNode for RecordFieldPat {
2126 fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD_PAT } 1716 fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD_PAT }
2127 fn cast(syntax: SyntaxNode) -> Option<Self> { 1717 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2143,11 +1733,6 @@ impl RecordFieldPat {
2143pub struct TupleStructPat { 1733pub struct TupleStructPat {
2144 pub(crate) syntax: SyntaxNode, 1734 pub(crate) syntax: SyntaxNode,
2145} 1735}
2146impl std::fmt::Display for TupleStructPat {
2147 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2148 std::fmt::Display::fmt(self.syntax(), f)
2149 }
2150}
2151impl AstNode for TupleStructPat { 1736impl AstNode for TupleStructPat {
2152 fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_STRUCT_PAT } 1737 fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_STRUCT_PAT }
2153 fn cast(syntax: SyntaxNode) -> Option<Self> { 1738 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2169,11 +1754,6 @@ impl TupleStructPat {
2169pub struct TuplePat { 1754pub struct TuplePat {
2170 pub(crate) syntax: SyntaxNode, 1755 pub(crate) syntax: SyntaxNode,
2171} 1756}
2172impl std::fmt::Display for TuplePat {
2173 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2174 std::fmt::Display::fmt(self.syntax(), f)
2175 }
2176}
2177impl AstNode for TuplePat { 1757impl AstNode for TuplePat {
2178 fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_PAT } 1758 fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_PAT }
2179 fn cast(syntax: SyntaxNode) -> Option<Self> { 1759 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2194,11 +1774,6 @@ impl TuplePat {
2194pub struct Visibility { 1774pub struct Visibility {
2195 pub(crate) syntax: SyntaxNode, 1775 pub(crate) syntax: SyntaxNode,
2196} 1776}
2197impl std::fmt::Display for Visibility {
2198 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2199 std::fmt::Display::fmt(self.syntax(), f)
2200 }
2201}
2202impl AstNode for Visibility { 1777impl AstNode for Visibility {
2203 fn can_cast(kind: SyntaxKind) -> bool { kind == VISIBILITY } 1778 fn can_cast(kind: SyntaxKind) -> bool { kind == VISIBILITY }
2204 fn cast(syntax: SyntaxNode) -> Option<Self> { 1779 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2220,11 +1795,6 @@ impl Visibility {
2220pub struct Name { 1795pub struct Name {
2221 pub(crate) syntax: SyntaxNode, 1796 pub(crate) syntax: SyntaxNode,
2222} 1797}
2223impl std::fmt::Display for Name {
2224 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2225 std::fmt::Display::fmt(self.syntax(), f)
2226 }
2227}
2228impl AstNode for Name { 1798impl AstNode for Name {
2229 fn can_cast(kind: SyntaxKind) -> bool { kind == NAME } 1799 fn can_cast(kind: SyntaxKind) -> bool { kind == NAME }
2230 fn cast(syntax: SyntaxNode) -> Option<Self> { 1800 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2243,11 +1813,6 @@ impl Name {
2243pub struct NameRef { 1813pub struct NameRef {
2244 pub(crate) syntax: SyntaxNode, 1814 pub(crate) syntax: SyntaxNode,
2245} 1815}
2246impl std::fmt::Display for NameRef {
2247 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2248 std::fmt::Display::fmt(self.syntax(), f)
2249 }
2250}
2251impl AstNode for NameRef { 1816impl AstNode for NameRef {
2252 fn can_cast(kind: SyntaxKind) -> bool { kind == NAME_REF } 1817 fn can_cast(kind: SyntaxKind) -> bool { kind == NAME_REF }
2253 fn cast(syntax: SyntaxNode) -> Option<Self> { 1818 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2266,11 +1831,6 @@ impl NameRef {
2266pub struct MacroCall { 1831pub struct MacroCall {
2267 pub(crate) syntax: SyntaxNode, 1832 pub(crate) syntax: SyntaxNode,
2268} 1833}
2269impl std::fmt::Display for MacroCall {
2270 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2271 std::fmt::Display::fmt(self.syntax(), f)
2272 }
2273}
2274impl AstNode for MacroCall { 1834impl AstNode for MacroCall {
2275 fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_CALL } 1835 fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_CALL }
2276 fn cast(syntax: SyntaxNode) -> Option<Self> { 1836 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2295,11 +1855,6 @@ impl MacroCall {
2295pub struct Attr { 1855pub struct Attr {
2296 pub(crate) syntax: SyntaxNode, 1856 pub(crate) syntax: SyntaxNode,
2297} 1857}
2298impl std::fmt::Display for Attr {
2299 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2300 std::fmt::Display::fmt(self.syntax(), f)
2301 }
2302}
2303impl AstNode for Attr { 1858impl AstNode for Attr {
2304 fn can_cast(kind: SyntaxKind) -> bool { kind == ATTR } 1859 fn can_cast(kind: SyntaxKind) -> bool { kind == ATTR }
2305 fn cast(syntax: SyntaxNode) -> Option<Self> { 1860 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2324,11 +1879,6 @@ impl Attr {
2324pub struct TokenTree { 1879pub struct TokenTree {
2325 pub(crate) syntax: SyntaxNode, 1880 pub(crate) syntax: SyntaxNode,
2326} 1881}
2327impl std::fmt::Display for TokenTree {
2328 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2329 std::fmt::Display::fmt(self.syntax(), f)
2330 }
2331}
2332impl AstNode for TokenTree { 1882impl AstNode for TokenTree {
2333 fn can_cast(kind: SyntaxKind) -> bool { kind == TOKEN_TREE } 1883 fn can_cast(kind: SyntaxKind) -> bool { kind == TOKEN_TREE }
2334 fn cast(syntax: SyntaxNode) -> Option<Self> { 1884 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2345,11 +1895,6 @@ impl TokenTree {}
2345pub struct TypeParamList { 1895pub struct TypeParamList {
2346 pub(crate) syntax: SyntaxNode, 1896 pub(crate) syntax: SyntaxNode,
2347} 1897}
2348impl std::fmt::Display for TypeParamList {
2349 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2350 std::fmt::Display::fmt(self.syntax(), f)
2351 }
2352}
2353impl AstNode for TypeParamList { 1898impl AstNode for TypeParamList {
2354 fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_PARAM_LIST } 1899 fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_PARAM_LIST }
2355 fn cast(syntax: SyntaxNode) -> Option<Self> { 1900 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2373,11 +1918,6 @@ impl TypeParamList {
2373pub struct TypeParam { 1918pub struct TypeParam {
2374 pub(crate) syntax: SyntaxNode, 1919 pub(crate) syntax: SyntaxNode,
2375} 1920}
2376impl std::fmt::Display for TypeParam {
2377 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2378 std::fmt::Display::fmt(self.syntax(), f)
2379 }
2380}
2381impl AstNode for TypeParam { 1921impl AstNode for TypeParam {
2382 fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_PARAM } 1922 fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_PARAM }
2383 fn cast(syntax: SyntaxNode) -> Option<Self> { 1923 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2400,11 +1940,6 @@ impl TypeParam {
2400pub struct ConstParam { 1940pub struct ConstParam {
2401 pub(crate) syntax: SyntaxNode, 1941 pub(crate) syntax: SyntaxNode,
2402} 1942}
2403impl std::fmt::Display for ConstParam {
2404 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2405 std::fmt::Display::fmt(self.syntax(), f)
2406 }
2407}
2408impl AstNode for ConstParam { 1943impl AstNode for ConstParam {
2409 fn can_cast(kind: SyntaxKind) -> bool { kind == CONST_PARAM } 1944 fn can_cast(kind: SyntaxKind) -> bool { kind == CONST_PARAM }
2410 fn cast(syntax: SyntaxNode) -> Option<Self> { 1945 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2427,11 +1962,6 @@ impl ConstParam {
2427pub struct LifetimeParam { 1962pub struct LifetimeParam {
2428 pub(crate) syntax: SyntaxNode, 1963 pub(crate) syntax: SyntaxNode,
2429} 1964}
2430impl std::fmt::Display for LifetimeParam {
2431 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2432 std::fmt::Display::fmt(self.syntax(), f)
2433 }
2434}
2435impl AstNode for LifetimeParam { 1965impl AstNode for LifetimeParam {
2436 fn can_cast(kind: SyntaxKind) -> bool { kind == LIFETIME_PARAM } 1966 fn can_cast(kind: SyntaxKind) -> bool { kind == LIFETIME_PARAM }
2437 fn cast(syntax: SyntaxNode) -> Option<Self> { 1967 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2451,11 +1981,6 @@ impl LifetimeParam {
2451pub struct TypeBound { 1981pub struct TypeBound {
2452 pub(crate) syntax: SyntaxNode, 1982 pub(crate) syntax: SyntaxNode,
2453} 1983}
2454impl std::fmt::Display for TypeBound {
2455 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2456 std::fmt::Display::fmt(self.syntax(), f)
2457 }
2458}
2459impl AstNode for TypeBound { 1984impl AstNode for TypeBound {
2460 fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_BOUND } 1985 fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_BOUND }
2461 fn cast(syntax: SyntaxNode) -> Option<Self> { 1986 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2476,11 +2001,6 @@ impl TypeBound {
2476pub struct TypeBoundList { 2001pub struct TypeBoundList {
2477 pub(crate) syntax: SyntaxNode, 2002 pub(crate) syntax: SyntaxNode,
2478} 2003}
2479impl std::fmt::Display for TypeBoundList {
2480 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2481 std::fmt::Display::fmt(self.syntax(), f)
2482 }
2483}
2484impl AstNode for TypeBoundList { 2004impl AstNode for TypeBoundList {
2485 fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_BOUND_LIST } 2005 fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_BOUND_LIST }
2486 fn cast(syntax: SyntaxNode) -> Option<Self> { 2006 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2499,11 +2019,6 @@ impl TypeBoundList {
2499pub struct WherePred { 2019pub struct WherePred {
2500 pub(crate) syntax: SyntaxNode, 2020 pub(crate) syntax: SyntaxNode,
2501} 2021}
2502impl std::fmt::Display for WherePred {
2503 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2504 std::fmt::Display::fmt(self.syntax(), f)
2505 }
2506}
2507impl AstNode for WherePred { 2022impl AstNode for WherePred {
2508 fn can_cast(kind: SyntaxKind) -> bool { kind == WHERE_PRED } 2023 fn can_cast(kind: SyntaxKind) -> bool { kind == WHERE_PRED }
2509 fn cast(syntax: SyntaxNode) -> Option<Self> { 2024 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2524,11 +2039,6 @@ impl WherePred {
2524pub struct WhereClause { 2039pub struct WhereClause {
2525 pub(crate) syntax: SyntaxNode, 2040 pub(crate) syntax: SyntaxNode,
2526} 2041}
2527impl std::fmt::Display for WhereClause {
2528 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2529 std::fmt::Display::fmt(self.syntax(), f)
2530 }
2531}
2532impl AstNode for WhereClause { 2042impl AstNode for WhereClause {
2533 fn can_cast(kind: SyntaxKind) -> bool { kind == WHERE_CLAUSE } 2043 fn can_cast(kind: SyntaxKind) -> bool { kind == WHERE_CLAUSE }
2534 fn cast(syntax: SyntaxNode) -> Option<Self> { 2044 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2548,11 +2058,6 @@ impl WhereClause {
2548pub struct Abi { 2058pub struct Abi {
2549 pub(crate) syntax: SyntaxNode, 2059 pub(crate) syntax: SyntaxNode,
2550} 2060}
2551impl std::fmt::Display for Abi {
2552 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2553 std::fmt::Display::fmt(self.syntax(), f)
2554 }
2555}
2556impl AstNode for Abi { 2061impl AstNode for Abi {
2557 fn can_cast(kind: SyntaxKind) -> bool { kind == ABI } 2062 fn can_cast(kind: SyntaxKind) -> bool { kind == ABI }
2558 fn cast(syntax: SyntaxNode) -> Option<Self> { 2063 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2571,11 +2076,6 @@ impl Abi {
2571pub struct ExprStmt { 2076pub struct ExprStmt {
2572 pub(crate) syntax: SyntaxNode, 2077 pub(crate) syntax: SyntaxNode,
2573} 2078}
2574impl std::fmt::Display for ExprStmt {
2575 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2576 std::fmt::Display::fmt(self.syntax(), f)
2577 }
2578}
2579impl AstNode for ExprStmt { 2079impl AstNode for ExprStmt {
2580 fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_STMT } 2080 fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_STMT }
2581 fn cast(syntax: SyntaxNode) -> Option<Self> { 2081 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2596,11 +2096,6 @@ impl ExprStmt {
2596pub struct LetStmt { 2096pub struct LetStmt {
2597 pub(crate) syntax: SyntaxNode, 2097 pub(crate) syntax: SyntaxNode,
2598} 2098}
2599impl std::fmt::Display for LetStmt {
2600 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2601 std::fmt::Display::fmt(self.syntax(), f)
2602 }
2603}
2604impl AstNode for LetStmt { 2099impl AstNode for LetStmt {
2605 fn can_cast(kind: SyntaxKind) -> bool { kind == LET_STMT } 2100 fn can_cast(kind: SyntaxKind) -> bool { kind == LET_STMT }
2606 fn cast(syntax: SyntaxNode) -> Option<Self> { 2101 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2624,11 +2119,6 @@ impl LetStmt {
2624pub struct Condition { 2119pub struct Condition {
2625 pub(crate) syntax: SyntaxNode, 2120 pub(crate) syntax: SyntaxNode,
2626} 2121}
2627impl std::fmt::Display for Condition {
2628 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2629 std::fmt::Display::fmt(self.syntax(), f)
2630 }
2631}
2632impl AstNode for Condition { 2122impl AstNode for Condition {
2633 fn can_cast(kind: SyntaxKind) -> bool { kind == CONDITION } 2123 fn can_cast(kind: SyntaxKind) -> bool { kind == CONDITION }
2634 fn cast(syntax: SyntaxNode) -> Option<Self> { 2124 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2650,11 +2140,6 @@ impl Condition {
2650pub struct Block { 2140pub struct Block {
2651 pub(crate) syntax: SyntaxNode, 2141 pub(crate) syntax: SyntaxNode,
2652} 2142}
2653impl std::fmt::Display for Block {
2654 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2655 std::fmt::Display::fmt(self.syntax(), f)
2656 }
2657}
2658impl AstNode for Block { 2143impl AstNode for Block {
2659 fn can_cast(kind: SyntaxKind) -> bool { kind == BLOCK } 2144 fn can_cast(kind: SyntaxKind) -> bool { kind == BLOCK }
2660 fn cast(syntax: SyntaxNode) -> Option<Self> { 2145 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2678,11 +2163,6 @@ impl Block {
2678pub struct ParamList { 2163pub struct ParamList {
2679 pub(crate) syntax: SyntaxNode, 2164 pub(crate) syntax: SyntaxNode,
2680} 2165}
2681impl std::fmt::Display for ParamList {
2682 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2683 std::fmt::Display::fmt(self.syntax(), f)
2684 }
2685}
2686impl AstNode for ParamList { 2166impl AstNode for ParamList {
2687 fn can_cast(kind: SyntaxKind) -> bool { kind == PARAM_LIST } 2167 fn can_cast(kind: SyntaxKind) -> bool { kind == PARAM_LIST }
2688 fn cast(syntax: SyntaxNode) -> Option<Self> { 2168 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2704,11 +2184,6 @@ impl ParamList {
2704pub struct SelfParam { 2184pub struct SelfParam {
2705 pub(crate) syntax: SyntaxNode, 2185 pub(crate) syntax: SyntaxNode,
2706} 2186}
2707impl std::fmt::Display for SelfParam {
2708 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2709 std::fmt::Display::fmt(self.syntax(), f)
2710 }
2711}
2712impl AstNode for SelfParam { 2187impl AstNode for SelfParam {
2713 fn can_cast(kind: SyntaxKind) -> bool { kind == SELF_PARAM } 2188 fn can_cast(kind: SyntaxKind) -> bool { kind == SELF_PARAM }
2714 fn cast(syntax: SyntaxNode) -> Option<Self> { 2189 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2731,11 +2206,6 @@ impl SelfParam {
2731pub struct Param { 2206pub struct Param {
2732 pub(crate) syntax: SyntaxNode, 2207 pub(crate) syntax: SyntaxNode,
2733} 2208}
2734impl std::fmt::Display for Param {
2735 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2736 std::fmt::Display::fmt(self.syntax(), f)
2737 }
2738}
2739impl AstNode for Param { 2209impl AstNode for Param {
2740 fn can_cast(kind: SyntaxKind) -> bool { kind == PARAM } 2210 fn can_cast(kind: SyntaxKind) -> bool { kind == PARAM }
2741 fn cast(syntax: SyntaxNode) -> Option<Self> { 2211 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2757,11 +2227,6 @@ impl Param {
2757pub struct UseItem { 2227pub struct UseItem {
2758 pub(crate) syntax: SyntaxNode, 2228 pub(crate) syntax: SyntaxNode,
2759} 2229}
2760impl std::fmt::Display for UseItem {
2761 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2762 std::fmt::Display::fmt(self.syntax(), f)
2763 }
2764}
2765impl AstNode for UseItem { 2230impl AstNode for UseItem {
2766 fn can_cast(kind: SyntaxKind) -> bool { kind == USE_ITEM } 2231 fn can_cast(kind: SyntaxKind) -> bool { kind == USE_ITEM }
2767 fn cast(syntax: SyntaxNode) -> Option<Self> { 2232 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2783,11 +2248,6 @@ impl UseItem {
2783pub struct UseTree { 2248pub struct UseTree {
2784 pub(crate) syntax: SyntaxNode, 2249 pub(crate) syntax: SyntaxNode,
2785} 2250}
2786impl std::fmt::Display for UseTree {
2787 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2788 std::fmt::Display::fmt(self.syntax(), f)
2789 }
2790}
2791impl AstNode for UseTree { 2251impl AstNode for UseTree {
2792 fn can_cast(kind: SyntaxKind) -> bool { kind == USE_TREE } 2252 fn can_cast(kind: SyntaxKind) -> bool { kind == USE_TREE }
2793 fn cast(syntax: SyntaxNode) -> Option<Self> { 2253 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2809,11 +2269,6 @@ impl UseTree {
2809pub struct Alias { 2269pub struct Alias {
2810 pub(crate) syntax: SyntaxNode, 2270 pub(crate) syntax: SyntaxNode,
2811} 2271}
2812impl std::fmt::Display for Alias {
2813 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2814 std::fmt::Display::fmt(self.syntax(), f)
2815 }
2816}
2817impl AstNode for Alias { 2272impl AstNode for Alias {
2818 fn can_cast(kind: SyntaxKind) -> bool { kind == ALIAS } 2273 fn can_cast(kind: SyntaxKind) -> bool { kind == ALIAS }
2819 fn cast(syntax: SyntaxNode) -> Option<Self> { 2274 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2833,11 +2288,6 @@ impl Alias {
2833pub struct UseTreeList { 2288pub struct UseTreeList {
2834 pub(crate) syntax: SyntaxNode, 2289 pub(crate) syntax: SyntaxNode,
2835} 2290}
2836impl std::fmt::Display for UseTreeList {
2837 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2838 std::fmt::Display::fmt(self.syntax(), f)
2839 }
2840}
2841impl AstNode for UseTreeList { 2291impl AstNode for UseTreeList {
2842 fn can_cast(kind: SyntaxKind) -> bool { kind == USE_TREE_LIST } 2292 fn can_cast(kind: SyntaxKind) -> bool { kind == USE_TREE_LIST }
2843 fn cast(syntax: SyntaxNode) -> Option<Self> { 2293 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2858,11 +2308,6 @@ impl UseTreeList {
2858pub struct ExternCrateItem { 2308pub struct ExternCrateItem {
2859 pub(crate) syntax: SyntaxNode, 2309 pub(crate) syntax: SyntaxNode,
2860} 2310}
2861impl std::fmt::Display for ExternCrateItem {
2862 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2863 std::fmt::Display::fmt(self.syntax(), f)
2864 }
2865}
2866impl AstNode for ExternCrateItem { 2311impl AstNode for ExternCrateItem {
2867 fn can_cast(kind: SyntaxKind) -> bool { kind == EXTERN_CRATE_ITEM } 2312 fn can_cast(kind: SyntaxKind) -> bool { kind == EXTERN_CRATE_ITEM }
2868 fn cast(syntax: SyntaxNode) -> Option<Self> { 2313 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2886,11 +2331,6 @@ impl ExternCrateItem {
2886pub struct ArgList { 2331pub struct ArgList {
2887 pub(crate) syntax: SyntaxNode, 2332 pub(crate) syntax: SyntaxNode,
2888} 2333}
2889impl std::fmt::Display for ArgList {
2890 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2891 std::fmt::Display::fmt(self.syntax(), f)
2892 }
2893}
2894impl AstNode for ArgList { 2334impl AstNode for ArgList {
2895 fn can_cast(kind: SyntaxKind) -> bool { kind == ARG_LIST } 2335 fn can_cast(kind: SyntaxKind) -> bool { kind == ARG_LIST }
2896 fn cast(syntax: SyntaxNode) -> Option<Self> { 2336 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2911,11 +2351,6 @@ impl ArgList {
2911pub struct Path { 2351pub struct Path {
2912 pub(crate) syntax: SyntaxNode, 2352 pub(crate) syntax: SyntaxNode,
2913} 2353}
2914impl std::fmt::Display for Path {
2915 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2916 std::fmt::Display::fmt(self.syntax(), f)
2917 }
2918}
2919impl AstNode for Path { 2354impl AstNode for Path {
2920 fn can_cast(kind: SyntaxKind) -> bool { kind == PATH } 2355 fn can_cast(kind: SyntaxKind) -> bool { kind == PATH }
2921 fn cast(syntax: SyntaxNode) -> Option<Self> { 2356 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2935,11 +2370,6 @@ impl Path {
2935pub struct PathSegment { 2370pub struct PathSegment {
2936 pub(crate) syntax: SyntaxNode, 2371 pub(crate) syntax: SyntaxNode,
2937} 2372}
2938impl std::fmt::Display for PathSegment {
2939 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2940 std::fmt::Display::fmt(self.syntax(), f)
2941 }
2942}
2943impl AstNode for PathSegment { 2373impl AstNode for PathSegment {
2944 fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_SEGMENT } 2374 fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_SEGMENT }
2945 fn cast(syntax: SyntaxNode) -> Option<Self> { 2375 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2965,11 +2395,6 @@ impl PathSegment {
2965pub struct TypeArgList { 2395pub struct TypeArgList {
2966 pub(crate) syntax: SyntaxNode, 2396 pub(crate) syntax: SyntaxNode,
2967} 2397}
2968impl std::fmt::Display for TypeArgList {
2969 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2970 std::fmt::Display::fmt(self.syntax(), f)
2971 }
2972}
2973impl AstNode for TypeArgList { 2398impl AstNode for TypeArgList {
2974 fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_ARG_LIST } 2399 fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_ARG_LIST }
2975 fn cast(syntax: SyntaxNode) -> Option<Self> { 2400 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2995,11 +2420,6 @@ impl TypeArgList {
2995pub struct TypeArg { 2420pub struct TypeArg {
2996 pub(crate) syntax: SyntaxNode, 2421 pub(crate) syntax: SyntaxNode,
2997} 2422}
2998impl std::fmt::Display for TypeArg {
2999 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3000 std::fmt::Display::fmt(self.syntax(), f)
3001 }
3002}
3003impl AstNode for TypeArg { 2423impl AstNode for TypeArg {
3004 fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_ARG } 2424 fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_ARG }
3005 fn cast(syntax: SyntaxNode) -> Option<Self> { 2425 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -3018,11 +2438,6 @@ impl TypeArg {
3018pub struct AssocTypeArg { 2438pub struct AssocTypeArg {
3019 pub(crate) syntax: SyntaxNode, 2439 pub(crate) syntax: SyntaxNode,
3020} 2440}
3021impl std::fmt::Display for AssocTypeArg {
3022 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3023 std::fmt::Display::fmt(self.syntax(), f)
3024 }
3025}
3026impl AstNode for AssocTypeArg { 2441impl AstNode for AssocTypeArg {
3027 fn can_cast(kind: SyntaxKind) -> bool { kind == ASSOC_TYPE_ARG } 2442 fn can_cast(kind: SyntaxKind) -> bool { kind == ASSOC_TYPE_ARG }
3028 fn cast(syntax: SyntaxNode) -> Option<Self> { 2443 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -3044,11 +2459,6 @@ impl AssocTypeArg {
3044pub struct LifetimeArg { 2459pub struct LifetimeArg {
3045 pub(crate) syntax: SyntaxNode, 2460 pub(crate) syntax: SyntaxNode,
3046} 2461}
3047impl std::fmt::Display for LifetimeArg {
3048 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3049 std::fmt::Display::fmt(self.syntax(), f)
3050 }
3051}
3052impl AstNode for LifetimeArg { 2462impl AstNode for LifetimeArg {
3053 fn can_cast(kind: SyntaxKind) -> bool { kind == LIFETIME_ARG } 2463 fn can_cast(kind: SyntaxKind) -> bool { kind == LIFETIME_ARG }
3054 fn cast(syntax: SyntaxNode) -> Option<Self> { 2464 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -3067,11 +2477,6 @@ impl LifetimeArg {
3067pub struct ConstArg { 2477pub struct ConstArg {
3068 pub(crate) syntax: SyntaxNode, 2478 pub(crate) syntax: SyntaxNode,
3069} 2479}
3070impl std::fmt::Display for ConstArg {
3071 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3072 std::fmt::Display::fmt(self.syntax(), f)
3073 }
3074}
3075impl AstNode for ConstArg { 2480impl AstNode for ConstArg {
3076 fn can_cast(kind: SyntaxKind) -> bool { kind == CONST_ARG } 2481 fn can_cast(kind: SyntaxKind) -> bool { kind == CONST_ARG }
3077 fn cast(syntax: SyntaxNode) -> Option<Self> { 2482 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -3092,11 +2497,6 @@ impl ConstArg {
3092pub struct MacroItems { 2497pub struct MacroItems {
3093 pub(crate) syntax: SyntaxNode, 2498 pub(crate) syntax: SyntaxNode,
3094} 2499}
3095impl std::fmt::Display for MacroItems {
3096 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3097 std::fmt::Display::fmt(self.syntax(), f)
3098 }
3099}
3100impl AstNode for MacroItems { 2500impl AstNode for MacroItems {
3101 fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_ITEMS } 2501 fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_ITEMS }
3102 fn cast(syntax: SyntaxNode) -> Option<Self> { 2502 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -3115,11 +2515,6 @@ impl MacroItems {}
3115pub struct MacroStmts { 2515pub struct MacroStmts {
3116 pub(crate) syntax: SyntaxNode, 2516 pub(crate) syntax: SyntaxNode,
3117} 2517}
3118impl std::fmt::Display for MacroStmts {
3119 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3120 std::fmt::Display::fmt(self.syntax(), f)
3121 }
3122}
3123impl AstNode for MacroStmts { 2518impl AstNode for MacroStmts {
3124 fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_STMTS } 2519 fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_STMTS }
3125 fn cast(syntax: SyntaxNode) -> Option<Self> { 2520 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -3139,11 +2534,6 @@ impl MacroStmts {
3139pub struct ExternItemList { 2534pub struct ExternItemList {
3140 pub(crate) syntax: SyntaxNode, 2535 pub(crate) syntax: SyntaxNode,
3141} 2536}
3142impl std::fmt::Display for ExternItemList {
3143 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3144 std::fmt::Display::fmt(self.syntax(), f)
3145 }
3146}
3147impl AstNode for ExternItemList { 2537impl AstNode for ExternItemList {
3148 fn can_cast(kind: SyntaxKind) -> bool { kind == EXTERN_ITEM_LIST } 2538 fn can_cast(kind: SyntaxKind) -> bool { kind == EXTERN_ITEM_LIST }
3149 fn cast(syntax: SyntaxNode) -> Option<Self> { 2539 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -3166,11 +2556,6 @@ impl ExternItemList {
3166pub struct ExternBlock { 2556pub struct ExternBlock {
3167 pub(crate) syntax: SyntaxNode, 2557 pub(crate) syntax: SyntaxNode,
3168} 2558}
3169impl std::fmt::Display for ExternBlock {
3170 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3171 std::fmt::Display::fmt(self.syntax(), f)
3172 }
3173}
3174impl AstNode for ExternBlock { 2559impl AstNode for ExternBlock {
3175 fn can_cast(kind: SyntaxKind) -> bool { kind == EXTERN_BLOCK } 2560 fn can_cast(kind: SyntaxKind) -> bool { kind == EXTERN_BLOCK }
3176 fn cast(syntax: SyntaxNode) -> Option<Self> { 2561 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -3190,11 +2575,6 @@ impl ExternBlock {
3190pub struct MetaItem { 2575pub struct MetaItem {
3191 pub(crate) syntax: SyntaxNode, 2576 pub(crate) syntax: SyntaxNode,
3192} 2577}
3193impl std::fmt::Display for MetaItem {
3194 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3195 std::fmt::Display::fmt(self.syntax(), f)
3196 }
3197}
3198impl AstNode for MetaItem { 2578impl AstNode for MetaItem {
3199 fn can_cast(kind: SyntaxKind) -> bool { kind == META_ITEM } 2579 fn can_cast(kind: SyntaxKind) -> bool { kind == META_ITEM }
3200 fn cast(syntax: SyntaxNode) -> Option<Self> { 2580 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -3216,11 +2596,6 @@ impl MetaItem {
3216pub struct MacroDef { 2596pub struct MacroDef {
3217 pub(crate) syntax: SyntaxNode, 2597 pub(crate) syntax: SyntaxNode,
3218} 2598}
3219impl std::fmt::Display for MacroDef {
3220 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3221 std::fmt::Display::fmt(self.syntax(), f)
3222 }
3223}
3224impl AstNode for MacroDef { 2599impl AstNode for MacroDef {
3225 fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_DEF } 2600 fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_DEF }
3226 fn cast(syntax: SyntaxNode) -> Option<Self> { 2601 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -3251,11 +2626,6 @@ impl From<EnumDef> for NominalDef {
3251impl From<UnionDef> for NominalDef { 2626impl From<UnionDef> for NominalDef {
3252 fn from(node: UnionDef) -> NominalDef { NominalDef::UnionDef(node) } 2627 fn from(node: UnionDef) -> NominalDef { NominalDef::UnionDef(node) }
3253} 2628}
3254impl std::fmt::Display for NominalDef {
3255 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3256 std::fmt::Display::fmt(self.syntax(), f)
3257 }
3258}
3259impl AstNode for NominalDef { 2629impl AstNode for NominalDef {
3260 fn can_cast(kind: SyntaxKind) -> bool { 2630 fn can_cast(kind: SyntaxKind) -> bool {
3261 match kind { 2631 match kind {
@@ -3298,11 +2668,6 @@ impl From<TypeParam> for GenericParam {
3298impl From<ConstParam> for GenericParam { 2668impl From<ConstParam> for GenericParam {
3299 fn from(node: ConstParam) -> GenericParam { GenericParam::ConstParam(node) } 2669 fn from(node: ConstParam) -> GenericParam { GenericParam::ConstParam(node) }
3300} 2670}
3301impl std::fmt::Display for GenericParam {
3302 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3303 std::fmt::Display::fmt(self.syntax(), f)
3304 }
3305}
3306impl AstNode for GenericParam { 2671impl AstNode for GenericParam {
3307 fn can_cast(kind: SyntaxKind) -> bool { 2672 fn can_cast(kind: SyntaxKind) -> bool {
3308 match kind { 2673 match kind {
@@ -3346,11 +2711,6 @@ impl From<ConstArg> for GenericArg {
3346impl From<AssocTypeArg> for GenericArg { 2711impl From<AssocTypeArg> for GenericArg {
3347 fn from(node: AssocTypeArg) -> GenericArg { GenericArg::AssocTypeArg(node) } 2712 fn from(node: AssocTypeArg) -> GenericArg { GenericArg::AssocTypeArg(node) }
3348} 2713}
3349impl std::fmt::Display for GenericArg {
3350 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3351 std::fmt::Display::fmt(self.syntax(), f)
3352 }
3353}
3354impl AstNode for GenericArg { 2714impl AstNode for GenericArg {
3355 fn can_cast(kind: SyntaxKind) -> bool { 2715 fn can_cast(kind: SyntaxKind) -> bool {
3356 match kind { 2716 match kind {
@@ -3432,11 +2792,6 @@ impl From<ImplTraitType> for TypeRef {
3432impl From<DynTraitType> for TypeRef { 2792impl From<DynTraitType> for TypeRef {
3433 fn from(node: DynTraitType) -> TypeRef { TypeRef::DynTraitType(node) } 2793 fn from(node: DynTraitType) -> TypeRef { TypeRef::DynTraitType(node) }
3434} 2794}
3435impl std::fmt::Display for TypeRef {
3436 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3437 std::fmt::Display::fmt(self.syntax(), f)
3438 }
3439}
3440impl AstNode for TypeRef { 2795impl AstNode for TypeRef {
3441 fn can_cast(kind: SyntaxKind) -> bool { 2796 fn can_cast(kind: SyntaxKind) -> bool {
3442 match kind { 2797 match kind {
@@ -3542,11 +2897,6 @@ impl From<MacroCall> for ModuleItem {
3542impl From<ExternBlock> for ModuleItem { 2897impl From<ExternBlock> for ModuleItem {
3543 fn from(node: ExternBlock) -> ModuleItem { ModuleItem::ExternBlock(node) } 2898 fn from(node: ExternBlock) -> ModuleItem { ModuleItem::ExternBlock(node) }
3544} 2899}
3545impl std::fmt::Display for ModuleItem {
3546 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3547 std::fmt::Display::fmt(self.syntax(), f)
3548 }
3549}
3550impl AstNode for ModuleItem { 2900impl AstNode for ModuleItem {
3551 fn can_cast(kind: SyntaxKind) -> bool { 2901 fn can_cast(kind: SyntaxKind) -> bool {
3552 match kind { 2902 match kind {
@@ -3613,11 +2963,6 @@ impl From<TypeAliasDef> for ImplItem {
3613impl From<ConstDef> for ImplItem { 2963impl From<ConstDef> for ImplItem {
3614 fn from(node: ConstDef) -> ImplItem { ImplItem::ConstDef(node) } 2964 fn from(node: ConstDef) -> ImplItem { ImplItem::ConstDef(node) }
3615} 2965}
3616impl std::fmt::Display for ImplItem {
3617 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3618 std::fmt::Display::fmt(self.syntax(), f)
3619 }
3620}
3621impl AstNode for ImplItem { 2966impl AstNode for ImplItem {
3622 fn can_cast(kind: SyntaxKind) -> bool { 2967 fn can_cast(kind: SyntaxKind) -> bool {
3623 match kind { 2968 match kind {
@@ -3655,11 +3000,6 @@ impl From<FnDef> for ExternItem {
3655impl From<StaticDef> for ExternItem { 3000impl From<StaticDef> for ExternItem {
3656 fn from(node: StaticDef) -> ExternItem { ExternItem::StaticDef(node) } 3001 fn from(node: StaticDef) -> ExternItem { ExternItem::StaticDef(node) }
3657} 3002}
3658impl std::fmt::Display for ExternItem {
3659 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3660 std::fmt::Display::fmt(self.syntax(), f)
3661 }
3662}
3663impl AstNode for ExternItem { 3003impl AstNode for ExternItem {
3664 fn can_cast(kind: SyntaxKind) -> bool { 3004 fn can_cast(kind: SyntaxKind) -> bool {
3665 match kind { 3005 match kind {
@@ -3812,11 +3152,6 @@ impl From<MacroCall> for Expr {
3812impl From<BoxExpr> for Expr { 3152impl From<BoxExpr> for Expr {
3813 fn from(node: BoxExpr) -> Expr { Expr::BoxExpr(node) } 3153 fn from(node: BoxExpr) -> Expr { Expr::BoxExpr(node) }
3814} 3154}
3815impl std::fmt::Display for Expr {
3816 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3817 std::fmt::Display::fmt(self.syntax(), f)
3818 }
3819}
3820impl AstNode for Expr { 3155impl AstNode for Expr {
3821 fn can_cast(kind: SyntaxKind) -> bool { 3156 fn can_cast(kind: SyntaxKind) -> bool {
3822 match kind { 3157 match kind {
@@ -3966,11 +3301,6 @@ impl From<LiteralPat> for Pat {
3966impl From<MacroPat> for Pat { 3301impl From<MacroPat> for Pat {
3967 fn from(node: MacroPat) -> Pat { Pat::MacroPat(node) } 3302 fn from(node: MacroPat) -> Pat { Pat::MacroPat(node) }
3968} 3303}
3969impl std::fmt::Display for Pat {
3970 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3971 std::fmt::Display::fmt(self.syntax(), f)
3972 }
3973}
3974impl AstNode for Pat { 3304impl AstNode for Pat {
3975 fn can_cast(kind: SyntaxKind) -> bool { 3305 fn can_cast(kind: SyntaxKind) -> bool {
3976 match kind { 3306 match kind {
@@ -4032,11 +3362,6 @@ impl From<RecordFieldPat> for RecordInnerPat {
4032impl From<BindPat> for RecordInnerPat { 3362impl From<BindPat> for RecordInnerPat {
4033 fn from(node: BindPat) -> RecordInnerPat { RecordInnerPat::BindPat(node) } 3363 fn from(node: BindPat) -> RecordInnerPat { RecordInnerPat::BindPat(node) }
4034} 3364}
4035impl std::fmt::Display for RecordInnerPat {
4036 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4037 std::fmt::Display::fmt(self.syntax(), f)
4038 }
4039}
4040impl AstNode for RecordInnerPat { 3365impl AstNode for RecordInnerPat {
4041 fn can_cast(kind: SyntaxKind) -> bool { 3366 fn can_cast(kind: SyntaxKind) -> bool {
4042 match kind { 3367 match kind {
@@ -4070,11 +3395,6 @@ impl From<Literal> for AttrInput {
4070impl From<TokenTree> for AttrInput { 3395impl From<TokenTree> for AttrInput {
4071 fn from(node: TokenTree) -> AttrInput { AttrInput::TokenTree(node) } 3396 fn from(node: TokenTree) -> AttrInput { AttrInput::TokenTree(node) }
4072} 3397}
4073impl std::fmt::Display for AttrInput {
4074 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4075 std::fmt::Display::fmt(self.syntax(), f)
4076 }
4077}
4078impl AstNode for AttrInput { 3398impl AstNode for AttrInput {
4079 fn can_cast(kind: SyntaxKind) -> bool { 3399 fn can_cast(kind: SyntaxKind) -> bool {
4080 match kind { 3400 match kind {
@@ -4108,11 +3428,6 @@ impl From<LetStmt> for Stmt {
4108impl From<ExprStmt> for Stmt { 3428impl From<ExprStmt> for Stmt {
4109 fn from(node: ExprStmt) -> Stmt { Stmt::ExprStmt(node) } 3429 fn from(node: ExprStmt) -> Stmt { Stmt::ExprStmt(node) }
4110} 3430}
4111impl std::fmt::Display for Stmt {
4112 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4113 std::fmt::Display::fmt(self.syntax(), f)
4114 }
4115}
4116impl AstNode for Stmt { 3431impl AstNode for Stmt {
4117 fn can_cast(kind: SyntaxKind) -> bool { 3432 fn can_cast(kind: SyntaxKind) -> bool {
4118 match kind { 3433 match kind {
@@ -4146,11 +3461,6 @@ impl From<RecordFieldDefList> for FieldDefList {
4146impl From<TupleFieldDefList> for FieldDefList { 3461impl From<TupleFieldDefList> for FieldDefList {
4147 fn from(node: TupleFieldDefList) -> FieldDefList { FieldDefList::TupleFieldDefList(node) } 3462 fn from(node: TupleFieldDefList) -> FieldDefList { FieldDefList::TupleFieldDefList(node) }
4148} 3463}
4149impl std::fmt::Display for FieldDefList {
4150 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4151 std::fmt::Display::fmt(self.syntax(), f)
4152 }
4153}
4154impl AstNode for FieldDefList { 3464impl AstNode for FieldDefList {
4155 fn can_cast(kind: SyntaxKind) -> bool { 3465 fn can_cast(kind: SyntaxKind) -> bool {
4156 match kind { 3466 match kind {
@@ -4175,3 +3485,693 @@ impl AstNode for FieldDefList {
4175 } 3485 }
4176 } 3486 }
4177} 3487}
3488impl std::fmt::Display for NominalDef {
3489 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3490 std::fmt::Display::fmt(self.syntax(), f)
3491 }
3492}
3493impl std::fmt::Display for GenericParam {
3494 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3495 std::fmt::Display::fmt(self.syntax(), f)
3496 }
3497}
3498impl std::fmt::Display for GenericArg {
3499 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3500 std::fmt::Display::fmt(self.syntax(), f)
3501 }
3502}
3503impl std::fmt::Display for TypeRef {
3504 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3505 std::fmt::Display::fmt(self.syntax(), f)
3506 }
3507}
3508impl std::fmt::Display for ModuleItem {
3509 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3510 std::fmt::Display::fmt(self.syntax(), f)
3511 }
3512}
3513impl std::fmt::Display for ImplItem {
3514 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3515 std::fmt::Display::fmt(self.syntax(), f)
3516 }
3517}
3518impl std::fmt::Display for ExternItem {
3519 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3520 std::fmt::Display::fmt(self.syntax(), f)
3521 }
3522}
3523impl std::fmt::Display for Expr {
3524 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3525 std::fmt::Display::fmt(self.syntax(), f)
3526 }
3527}
3528impl std::fmt::Display for Pat {
3529 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3530 std::fmt::Display::fmt(self.syntax(), f)
3531 }
3532}
3533impl std::fmt::Display for RecordInnerPat {
3534 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3535 std::fmt::Display::fmt(self.syntax(), f)
3536 }
3537}
3538impl std::fmt::Display for AttrInput {
3539 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3540 std::fmt::Display::fmt(self.syntax(), f)
3541 }
3542}
3543impl std::fmt::Display for Stmt {
3544 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3545 std::fmt::Display::fmt(self.syntax(), f)
3546 }
3547}
3548impl std::fmt::Display for FieldDefList {
3549 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3550 std::fmt::Display::fmt(self.syntax(), f)
3551 }
3552}
3553impl std::fmt::Display for SourceFile {
3554 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3555 std::fmt::Display::fmt(self.syntax(), f)
3556 }
3557}
3558impl std::fmt::Display for FnDef {
3559 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3560 std::fmt::Display::fmt(self.syntax(), f)
3561 }
3562}
3563impl std::fmt::Display for RetType {
3564 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3565 std::fmt::Display::fmt(self.syntax(), f)
3566 }
3567}
3568impl std::fmt::Display for StructDef {
3569 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3570 std::fmt::Display::fmt(self.syntax(), f)
3571 }
3572}
3573impl std::fmt::Display for UnionDef {
3574 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3575 std::fmt::Display::fmt(self.syntax(), f)
3576 }
3577}
3578impl std::fmt::Display for RecordFieldDefList {
3579 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3580 std::fmt::Display::fmt(self.syntax(), f)
3581 }
3582}
3583impl std::fmt::Display for RecordFieldDef {
3584 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3585 std::fmt::Display::fmt(self.syntax(), f)
3586 }
3587}
3588impl std::fmt::Display for TupleFieldDefList {
3589 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3590 std::fmt::Display::fmt(self.syntax(), f)
3591 }
3592}
3593impl std::fmt::Display for TupleFieldDef {
3594 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3595 std::fmt::Display::fmt(self.syntax(), f)
3596 }
3597}
3598impl std::fmt::Display for EnumDef {
3599 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3600 std::fmt::Display::fmt(self.syntax(), f)
3601 }
3602}
3603impl std::fmt::Display for EnumVariantList {
3604 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3605 std::fmt::Display::fmt(self.syntax(), f)
3606 }
3607}
3608impl std::fmt::Display for EnumVariant {
3609 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3610 std::fmt::Display::fmt(self.syntax(), f)
3611 }
3612}
3613impl std::fmt::Display for TraitDef {
3614 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3615 std::fmt::Display::fmt(self.syntax(), f)
3616 }
3617}
3618impl std::fmt::Display for Module {
3619 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3620 std::fmt::Display::fmt(self.syntax(), f)
3621 }
3622}
3623impl std::fmt::Display for ItemList {
3624 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3625 std::fmt::Display::fmt(self.syntax(), f)
3626 }
3627}
3628impl std::fmt::Display for ConstDef {
3629 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3630 std::fmt::Display::fmt(self.syntax(), f)
3631 }
3632}
3633impl std::fmt::Display for StaticDef {
3634 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3635 std::fmt::Display::fmt(self.syntax(), f)
3636 }
3637}
3638impl std::fmt::Display for TypeAliasDef {
3639 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3640 std::fmt::Display::fmt(self.syntax(), f)
3641 }
3642}
3643impl std::fmt::Display for ImplDef {
3644 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3645 std::fmt::Display::fmt(self.syntax(), f)
3646 }
3647}
3648impl std::fmt::Display for ParenType {
3649 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3650 std::fmt::Display::fmt(self.syntax(), f)
3651 }
3652}
3653impl std::fmt::Display for TupleType {
3654 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3655 std::fmt::Display::fmt(self.syntax(), f)
3656 }
3657}
3658impl std::fmt::Display for NeverType {
3659 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3660 std::fmt::Display::fmt(self.syntax(), f)
3661 }
3662}
3663impl std::fmt::Display for PathType {
3664 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3665 std::fmt::Display::fmt(self.syntax(), f)
3666 }
3667}
3668impl std::fmt::Display for PointerType {
3669 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3670 std::fmt::Display::fmt(self.syntax(), f)
3671 }
3672}
3673impl std::fmt::Display for ArrayType {
3674 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3675 std::fmt::Display::fmt(self.syntax(), f)
3676 }
3677}
3678impl std::fmt::Display for SliceType {
3679 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3680 std::fmt::Display::fmt(self.syntax(), f)
3681 }
3682}
3683impl std::fmt::Display for ReferenceType {
3684 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3685 std::fmt::Display::fmt(self.syntax(), f)
3686 }
3687}
3688impl std::fmt::Display for PlaceholderType {
3689 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3690 std::fmt::Display::fmt(self.syntax(), f)
3691 }
3692}
3693impl std::fmt::Display for FnPointerType {
3694 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3695 std::fmt::Display::fmt(self.syntax(), f)
3696 }
3697}
3698impl std::fmt::Display for ForType {
3699 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3700 std::fmt::Display::fmt(self.syntax(), f)
3701 }
3702}
3703impl std::fmt::Display for ImplTraitType {
3704 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3705 std::fmt::Display::fmt(self.syntax(), f)
3706 }
3707}
3708impl std::fmt::Display for DynTraitType {
3709 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3710 std::fmt::Display::fmt(self.syntax(), f)
3711 }
3712}
3713impl std::fmt::Display for TupleExpr {
3714 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3715 std::fmt::Display::fmt(self.syntax(), f)
3716 }
3717}
3718impl std::fmt::Display for ArrayExpr {
3719 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3720 std::fmt::Display::fmt(self.syntax(), f)
3721 }
3722}
3723impl std::fmt::Display for ParenExpr {
3724 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3725 std::fmt::Display::fmt(self.syntax(), f)
3726 }
3727}
3728impl std::fmt::Display for PathExpr {
3729 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3730 std::fmt::Display::fmt(self.syntax(), f)
3731 }
3732}
3733impl std::fmt::Display for LambdaExpr {
3734 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3735 std::fmt::Display::fmt(self.syntax(), f)
3736 }
3737}
3738impl std::fmt::Display for IfExpr {
3739 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3740 std::fmt::Display::fmt(self.syntax(), f)
3741 }
3742}
3743impl std::fmt::Display for LoopExpr {
3744 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3745 std::fmt::Display::fmt(self.syntax(), f)
3746 }
3747}
3748impl std::fmt::Display for TryBlockExpr {
3749 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3750 std::fmt::Display::fmt(self.syntax(), f)
3751 }
3752}
3753impl std::fmt::Display for ForExpr {
3754 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3755 std::fmt::Display::fmt(self.syntax(), f)
3756 }
3757}
3758impl std::fmt::Display for WhileExpr {
3759 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3760 std::fmt::Display::fmt(self.syntax(), f)
3761 }
3762}
3763impl std::fmt::Display for ContinueExpr {
3764 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3765 std::fmt::Display::fmt(self.syntax(), f)
3766 }
3767}
3768impl std::fmt::Display for BreakExpr {
3769 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3770 std::fmt::Display::fmt(self.syntax(), f)
3771 }
3772}
3773impl std::fmt::Display for Label {
3774 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3775 std::fmt::Display::fmt(self.syntax(), f)
3776 }
3777}
3778impl std::fmt::Display for BlockExpr {
3779 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3780 std::fmt::Display::fmt(self.syntax(), f)
3781 }
3782}
3783impl std::fmt::Display for ReturnExpr {
3784 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3785 std::fmt::Display::fmt(self.syntax(), f)
3786 }
3787}
3788impl std::fmt::Display for CallExpr {
3789 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3790 std::fmt::Display::fmt(self.syntax(), f)
3791 }
3792}
3793impl std::fmt::Display for MethodCallExpr {
3794 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3795 std::fmt::Display::fmt(self.syntax(), f)
3796 }
3797}
3798impl std::fmt::Display for IndexExpr {
3799 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3800 std::fmt::Display::fmt(self.syntax(), f)
3801 }
3802}
3803impl std::fmt::Display for FieldExpr {
3804 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3805 std::fmt::Display::fmt(self.syntax(), f)
3806 }
3807}
3808impl std::fmt::Display for AwaitExpr {
3809 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3810 std::fmt::Display::fmt(self.syntax(), f)
3811 }
3812}
3813impl std::fmt::Display for TryExpr {
3814 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3815 std::fmt::Display::fmt(self.syntax(), f)
3816 }
3817}
3818impl std::fmt::Display for CastExpr {
3819 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3820 std::fmt::Display::fmt(self.syntax(), f)
3821 }
3822}
3823impl std::fmt::Display for RefExpr {
3824 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3825 std::fmt::Display::fmt(self.syntax(), f)
3826 }
3827}
3828impl std::fmt::Display for PrefixExpr {
3829 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3830 std::fmt::Display::fmt(self.syntax(), f)
3831 }
3832}
3833impl std::fmt::Display for BoxExpr {
3834 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3835 std::fmt::Display::fmt(self.syntax(), f)
3836 }
3837}
3838impl std::fmt::Display for RangeExpr {
3839 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3840 std::fmt::Display::fmt(self.syntax(), f)
3841 }
3842}
3843impl std::fmt::Display for BinExpr {
3844 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3845 std::fmt::Display::fmt(self.syntax(), f)
3846 }
3847}
3848impl std::fmt::Display for Literal {
3849 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3850 std::fmt::Display::fmt(self.syntax(), f)
3851 }
3852}
3853impl std::fmt::Display for MatchExpr {
3854 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3855 std::fmt::Display::fmt(self.syntax(), f)
3856 }
3857}
3858impl std::fmt::Display for MatchArmList {
3859 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3860 std::fmt::Display::fmt(self.syntax(), f)
3861 }
3862}
3863impl std::fmt::Display for MatchArm {
3864 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3865 std::fmt::Display::fmt(self.syntax(), f)
3866 }
3867}
3868impl std::fmt::Display for MatchGuard {
3869 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3870 std::fmt::Display::fmt(self.syntax(), f)
3871 }
3872}
3873impl std::fmt::Display for RecordLit {
3874 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3875 std::fmt::Display::fmt(self.syntax(), f)
3876 }
3877}
3878impl std::fmt::Display for RecordFieldList {
3879 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3880 std::fmt::Display::fmt(self.syntax(), f)
3881 }
3882}
3883impl std::fmt::Display for RecordField {
3884 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3885 std::fmt::Display::fmt(self.syntax(), f)
3886 }
3887}
3888impl std::fmt::Display for OrPat {
3889 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3890 std::fmt::Display::fmt(self.syntax(), f)
3891 }
3892}
3893impl std::fmt::Display for ParenPat {
3894 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3895 std::fmt::Display::fmt(self.syntax(), f)
3896 }
3897}
3898impl std::fmt::Display for RefPat {
3899 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3900 std::fmt::Display::fmt(self.syntax(), f)
3901 }
3902}
3903impl std::fmt::Display for BoxPat {
3904 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3905 std::fmt::Display::fmt(self.syntax(), f)
3906 }
3907}
3908impl std::fmt::Display for BindPat {
3909 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3910 std::fmt::Display::fmt(self.syntax(), f)
3911 }
3912}
3913impl std::fmt::Display for PlaceholderPat {
3914 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3915 std::fmt::Display::fmt(self.syntax(), f)
3916 }
3917}
3918impl std::fmt::Display for DotDotPat {
3919 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3920 std::fmt::Display::fmt(self.syntax(), f)
3921 }
3922}
3923impl std::fmt::Display for PathPat {
3924 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3925 std::fmt::Display::fmt(self.syntax(), f)
3926 }
3927}
3928impl std::fmt::Display for SlicePat {
3929 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3930 std::fmt::Display::fmt(self.syntax(), f)
3931 }
3932}
3933impl std::fmt::Display for RangePat {
3934 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3935 std::fmt::Display::fmt(self.syntax(), f)
3936 }
3937}
3938impl std::fmt::Display for LiteralPat {
3939 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3940 std::fmt::Display::fmt(self.syntax(), f)
3941 }
3942}
3943impl std::fmt::Display for MacroPat {
3944 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3945 std::fmt::Display::fmt(self.syntax(), f)
3946 }
3947}
3948impl std::fmt::Display for RecordPat {
3949 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3950 std::fmt::Display::fmt(self.syntax(), f)
3951 }
3952}
3953impl std::fmt::Display for RecordFieldPatList {
3954 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3955 std::fmt::Display::fmt(self.syntax(), f)
3956 }
3957}
3958impl std::fmt::Display for RecordFieldPat {
3959 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3960 std::fmt::Display::fmt(self.syntax(), f)
3961 }
3962}
3963impl std::fmt::Display for TupleStructPat {
3964 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3965 std::fmt::Display::fmt(self.syntax(), f)
3966 }
3967}
3968impl std::fmt::Display for TuplePat {
3969 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3970 std::fmt::Display::fmt(self.syntax(), f)
3971 }
3972}
3973impl std::fmt::Display for Visibility {
3974 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3975 std::fmt::Display::fmt(self.syntax(), f)
3976 }
3977}
3978impl std::fmt::Display for Name {
3979 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3980 std::fmt::Display::fmt(self.syntax(), f)
3981 }
3982}
3983impl std::fmt::Display for NameRef {
3984 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3985 std::fmt::Display::fmt(self.syntax(), f)
3986 }
3987}
3988impl std::fmt::Display for MacroCall {
3989 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3990 std::fmt::Display::fmt(self.syntax(), f)
3991 }
3992}
3993impl std::fmt::Display for Attr {
3994 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3995 std::fmt::Display::fmt(self.syntax(), f)
3996 }
3997}
3998impl std::fmt::Display for TokenTree {
3999 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4000 std::fmt::Display::fmt(self.syntax(), f)
4001 }
4002}
4003impl std::fmt::Display for TypeParamList {
4004 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4005 std::fmt::Display::fmt(self.syntax(), f)
4006 }
4007}
4008impl std::fmt::Display for TypeParam {
4009 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4010 std::fmt::Display::fmt(self.syntax(), f)
4011 }
4012}
4013impl std::fmt::Display for ConstParam {
4014 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4015 std::fmt::Display::fmt(self.syntax(), f)
4016 }
4017}
4018impl std::fmt::Display for LifetimeParam {
4019 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4020 std::fmt::Display::fmt(self.syntax(), f)
4021 }
4022}
4023impl std::fmt::Display for TypeBound {
4024 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4025 std::fmt::Display::fmt(self.syntax(), f)
4026 }
4027}
4028impl std::fmt::Display for TypeBoundList {
4029 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4030 std::fmt::Display::fmt(self.syntax(), f)
4031 }
4032}
4033impl std::fmt::Display for WherePred {
4034 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4035 std::fmt::Display::fmt(self.syntax(), f)
4036 }
4037}
4038impl std::fmt::Display for WhereClause {
4039 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4040 std::fmt::Display::fmt(self.syntax(), f)
4041 }
4042}
4043impl std::fmt::Display for Abi {
4044 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4045 std::fmt::Display::fmt(self.syntax(), f)
4046 }
4047}
4048impl std::fmt::Display for ExprStmt {
4049 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4050 std::fmt::Display::fmt(self.syntax(), f)
4051 }
4052}
4053impl std::fmt::Display for LetStmt {
4054 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4055 std::fmt::Display::fmt(self.syntax(), f)
4056 }
4057}
4058impl std::fmt::Display for Condition {
4059 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4060 std::fmt::Display::fmt(self.syntax(), f)
4061 }
4062}
4063impl std::fmt::Display for Block {
4064 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4065 std::fmt::Display::fmt(self.syntax(), f)
4066 }
4067}
4068impl std::fmt::Display for ParamList {
4069 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4070 std::fmt::Display::fmt(self.syntax(), f)
4071 }
4072}
4073impl std::fmt::Display for SelfParam {
4074 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4075 std::fmt::Display::fmt(self.syntax(), f)
4076 }
4077}
4078impl std::fmt::Display for Param {
4079 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4080 std::fmt::Display::fmt(self.syntax(), f)
4081 }
4082}
4083impl std::fmt::Display for UseItem {
4084 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4085 std::fmt::Display::fmt(self.syntax(), f)
4086 }
4087}
4088impl std::fmt::Display for UseTree {
4089 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4090 std::fmt::Display::fmt(self.syntax(), f)
4091 }
4092}
4093impl std::fmt::Display for Alias {
4094 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4095 std::fmt::Display::fmt(self.syntax(), f)
4096 }
4097}
4098impl std::fmt::Display for UseTreeList {
4099 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4100 std::fmt::Display::fmt(self.syntax(), f)
4101 }
4102}
4103impl std::fmt::Display for ExternCrateItem {
4104 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4105 std::fmt::Display::fmt(self.syntax(), f)
4106 }
4107}
4108impl std::fmt::Display for ArgList {
4109 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4110 std::fmt::Display::fmt(self.syntax(), f)
4111 }
4112}
4113impl std::fmt::Display for Path {
4114 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4115 std::fmt::Display::fmt(self.syntax(), f)
4116 }
4117}
4118impl std::fmt::Display for PathSegment {
4119 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4120 std::fmt::Display::fmt(self.syntax(), f)
4121 }
4122}
4123impl std::fmt::Display for TypeArgList {
4124 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4125 std::fmt::Display::fmt(self.syntax(), f)
4126 }
4127}
4128impl std::fmt::Display for TypeArg {
4129 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4130 std::fmt::Display::fmt(self.syntax(), f)
4131 }
4132}
4133impl std::fmt::Display for AssocTypeArg {
4134 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4135 std::fmt::Display::fmt(self.syntax(), f)
4136 }
4137}
4138impl std::fmt::Display for LifetimeArg {
4139 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4140 std::fmt::Display::fmt(self.syntax(), f)
4141 }
4142}
4143impl std::fmt::Display for ConstArg {
4144 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4145 std::fmt::Display::fmt(self.syntax(), f)
4146 }
4147}
4148impl std::fmt::Display for MacroItems {
4149 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4150 std::fmt::Display::fmt(self.syntax(), f)
4151 }
4152}
4153impl std::fmt::Display for MacroStmts {
4154 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4155 std::fmt::Display::fmt(self.syntax(), f)
4156 }
4157}
4158impl std::fmt::Display for ExternItemList {
4159 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4160 std::fmt::Display::fmt(self.syntax(), f)
4161 }
4162}
4163impl std::fmt::Display for ExternBlock {
4164 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4165 std::fmt::Display::fmt(self.syntax(), f)
4166 }
4167}
4168impl std::fmt::Display for MetaItem {
4169 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4170 std::fmt::Display::fmt(self.syntax(), f)
4171 }
4172}
4173impl std::fmt::Display for MacroDef {
4174 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4175 std::fmt::Display::fmt(self.syntax(), f)
4176 }
4177}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-04 00:02:15 +0000