git.delta.rocks / jrsonnet / refs/commits / 3248f25fe079

55
6SourceFile = Expr6SourceFile = Expr
77
8ExprBinary =8SuffixIndex =
9    lhs:LhsExpr9    '?'?
10    BinaryOperator
11    rhs:Expr
12ExprUnary =
13    UnaryOperator
14    rhs:Expr
15ExprSlice =
16    Expr
17    SliceDesc
18ExprIndex =
19    Expr
20    '.'10    '.'
21    index:Name11    index:Name
22ExprIndexExpr =12SuffixIndexExpr =
23    base:LhsExpr13    ('?' '.')?
24    '['14    '['
25    index:Expr15    index:Expr
26    ']'16    ']'
27ExprApply =17SuffixSlice =
28    Expr18    SliceDesc
19SuffixApply =
29    ArgsDesc20    ArgsDesc
30    'tailstrict'?21    'tailstrict'?
22Suffix =
23    SuffixIndex
24|   SuffixIndexExpr
25|   SuffixSlice
26|   SuffixApply
27
28StmtLocal =
29    'local'
30    (Bind (',' Bind)* ','?)
31    ';'
32StmtAssert =
33    Assertion
34    ';'
35Stmt =
36    StmtLocal
37|   StmtAssert
38
39ExprBinary =
40    lhs:Expr
41    BinaryOperator
42    rhs:Expr
43ExprUnary =
44    UnaryOperator
45    rhs:Expr
31ExprObjExtend =46ExprObjExtend =
32    LhsExpr
33    Expr47    Expr
48    Expr
34ExprParened =49ExprParened =
35    '('50    '('
36    Expr51    Expr
79    ParamsDesc94    ParamsDesc
80    ')'95    ')'
81    Expr96    Expr
82ExprAssert =
83    Assertion
84    ';'
85    Expr
86ExprError =97ExprError =
87    'error'98    'error'
88    Expr99    Expr
89100
90StmtLocal =
91    'local'
92    (Bind (',' Bind)* ','?)
93    ';'
94
95Expr =101Expr =
96    StmtLocal*102    Stmt*
97    ExprBase103    ExprBase
104    Suffix*
105
98ExprBase =106ExprBase =
99    ExprBinary107    ExprBinary
100|   ExprUnary108|   ExprUnary
101|   ExprSlice
102|   ExprIndex
103|   ExprIndexExpr
104|   ExprApply
105|   ExprObjExtend109|   ExprObjExtend
106|   ExprParened110|   ExprParened
107|   ExprString111|   ExprString
114|   ExprVar118|   ExprVar
115|   ExprIfThenElse119|   ExprIfThenElse
116|   ExprFunction120|   ExprFunction
117|   ExprAssert
118|   ExprError121|   ExprError
119122
120BinaryOperator =123BinaryOperator =
121    '||' | '&&'124    '||' | '??' | '&&'
122|   '|' | '^' | '&'125|   '|' | '^' | '&'
123|   '==' | '!=' | '<' | '>' | '<=' | '>=' | 'in'126|   '==' | '!=' | '<' | '>' | '<=' | '>=' | 'in'
124|   '<<' | '>>'127|   '<<' | '>>'
242245
243ForSpec =246ForSpec =
244    'for'247    'for'
245    bind:Name248    bind:Destruct
246    'in'249    'in'
247    Expr250    Expr
248IfSpec =251IfSpec =
278281
279Assertion =282Assertion =
280    'assert'283    'assert'
281    condition:LhsExpr284    condition:Expr
282    (285    (
283        ':'286        ':'
284        message:Expr287        message:Expr
336// Aliases used to resolve node type conflicts339// Aliases used to resolve node type conflicts
337TrueExpr=Expr340TrueExpr=Expr
338FalseExpr=Expr341FalseExpr=Expr
339LhsExpr=Expr
340342
341// Trivia - tokens which will be implicitly skipped for parser343// Trivia - tokens which will be implicitly skipped for parser
342Trivia =344Trivia =

23	pub(crate) syntax: SyntaxNode,23	pub(crate) syntax: SyntaxNode,
24}24}
25impl Expr {25impl Expr {
26	pub fn stmt_locals(&self) -> AstChildren<StmtLocal> {26	pub fn stmts(&self) -> AstChildren<Stmt> {
27		support::children(&self.syntax)27		support::children(&self.syntax)
28	}28	}
29	pub fn expr_base(&self) -> Option<ExprBase> {29	pub fn expr_base(&self) -> Option<ExprBase> {
30		support::child(&self.syntax)30		support::child(&self.syntax)
31	}31	}
32	pub fn suffixs(&self) -> AstChildren<Suffix> {
33		support::children(&self.syntax)
34	}
32}35}
3336
34#[derive(Debug, Clone, PartialEq, Eq, Hash)]37#[derive(Debug, Clone, PartialEq, Eq, Hash)]
35pub struct ExprBinary {38pub struct SuffixIndex {
36	pub(crate) syntax: SyntaxNode,39	pub(crate) syntax: SyntaxNode,
37}40}
38impl ExprBinary {41impl SuffixIndex {
39	pub fn lhs(&self) -> Option<LhsExpr> {42	pub fn question_mark_token(&self) -> Option<SyntaxToken> {
40		support::child(&self.syntax)43		support::token(&self.syntax, T![?])
41	}44	}
42	pub fn binary_operator(&self) -> Option<BinaryOperator> {45	pub fn dot_token(&self) -> Option<SyntaxToken> {
43		support::token_child(&self.syntax)46		support::token(&self.syntax, T![.])
44	}47	}
45	pub fn rhs(&self) -> Option<Expr> {48	pub fn index(&self) -> Option<Name> {
46		support::child(&self.syntax)49		support::child(&self.syntax)
47	}50	}
48}51}
4952
50#[derive(Debug, Clone, PartialEq, Eq, Hash)]53#[derive(Debug, Clone, PartialEq, Eq, Hash)]
51pub struct LhsExpr {54pub struct Name {
52	pub(crate) syntax: SyntaxNode,55	pub(crate) syntax: SyntaxNode,
53}56}
54impl LhsExpr {57impl Name {
55	pub fn expr(&self) -> Option<Expr> {58	pub fn ident_lit(&self) -> Option<SyntaxToken> {
56		support::child(&self.syntax)59		support::token(&self.syntax, IDENT)
57	}60	}
58}61}
5962
60#[derive(Debug, Clone, PartialEq, Eq, Hash)]63#[derive(Debug, Clone, PartialEq, Eq, Hash)]
61pub struct ExprUnary {64pub struct SuffixIndexExpr {
62	pub(crate) syntax: SyntaxNode,65	pub(crate) syntax: SyntaxNode,
63}66}
64impl ExprUnary {67impl SuffixIndexExpr {
65	pub fn unary_operator(&self) -> Option<UnaryOperator> {68	pub fn question_mark_token(&self) -> Option<SyntaxToken> {
66		support::token_child(&self.syntax)69		support::token(&self.syntax, T![?])
67	}70	}
71	pub fn dot_token(&self) -> Option<SyntaxToken> {
72		support::token(&self.syntax, T![.])
73	}
74	pub fn l_brack_token(&self) -> Option<SyntaxToken> {
75		support::token(&self.syntax, T!['['])
76	}
68	pub fn rhs(&self) -> Option<Expr> {77	pub fn index(&self) -> Option<Expr> {
69		support::child(&self.syntax)78		support::child(&self.syntax)
70	}79	}
80	pub fn r_brack_token(&self) -> Option<SyntaxToken> {
81		support::token(&self.syntax, T![']'])
82	}
71}83}
7284
73#[derive(Debug, Clone, PartialEq, Eq, Hash)]85#[derive(Debug, Clone, PartialEq, Eq, Hash)]
74pub struct ExprSlice {86pub struct SuffixSlice {
75	pub(crate) syntax: SyntaxNode,87	pub(crate) syntax: SyntaxNode,
76}88}
77impl ExprSlice {89impl SuffixSlice {
78	pub fn expr(&self) -> Option<Expr> {
79		support::child(&self.syntax)
80	}
81	pub fn slice_desc(&self) -> Option<SliceDesc> {90	pub fn slice_desc(&self) -> Option<SliceDesc> {
82		support::child(&self.syntax)91		support::child(&self.syntax)
83	}92	}
109}118}
110119
111#[derive(Debug, Clone, PartialEq, Eq, Hash)]120#[derive(Debug, Clone, PartialEq, Eq, Hash)]
112pub struct ExprIndex {121pub struct SuffixApply {
113	pub(crate) syntax: SyntaxNode,122	pub(crate) syntax: SyntaxNode,
114}123}
115impl ExprIndex {
116	pub fn expr(&self) -> Option<Expr> {
117		support::child(&self.syntax)
118	}
119	pub fn dot_token(&self) -> Option<SyntaxToken> {
120		support::token(&self.syntax, T![.])
121	}
122	pub fn index(&self) -> Option<Name> {
123		support::child(&self.syntax)
124	}
125}
126
127#[derive(Debug, Clone, PartialEq, Eq, Hash)]
128pub struct Name {
129	pub(crate) syntax: SyntaxNode,
130}
131impl Name {
132	pub fn ident_lit(&self) -> Option<SyntaxToken> {
133		support::token(&self.syntax, IDENT)
134	}
135}
136
137#[derive(Debug, Clone, PartialEq, Eq, Hash)]
138pub struct ExprIndexExpr {
139	pub(crate) syntax: SyntaxNode,
140}
141impl ExprIndexExpr {
142	pub fn base(&self) -> Option<LhsExpr> {
143		support::child(&self.syntax)
144	}
145	pub fn l_brack_token(&self) -> Option<SyntaxToken> {
146		support::token(&self.syntax, T!['['])
147	}
148	pub fn index(&self) -> Option<Expr> {
149		support::child(&self.syntax)
150	}
151	pub fn r_brack_token(&self) -> Option<SyntaxToken> {
152		support::token(&self.syntax, T![']'])
153	}
154}
155
156#[derive(Debug, Clone, PartialEq, Eq, Hash)]
157pub struct ExprApply {
158	pub(crate) syntax: SyntaxNode,
159}
160impl ExprApply {124impl SuffixApply {
161	pub fn expr(&self) -> Option<Expr> {
162		support::child(&self.syntax)
163	}
164	pub fn args_desc(&self) -> Option<ArgsDesc> {125	pub fn args_desc(&self) -> Option<ArgsDesc> {
165		support::child(&self.syntax)126		support::child(&self.syntax)
166	}127	}
185	}146	}
186}147}
148
149#[derive(Debug, Clone, PartialEq, Eq, Hash)]
150pub struct StmtLocal {
151	pub(crate) syntax: SyntaxNode,
152}
153impl StmtLocal {
154	pub fn local_kw_token(&self) -> Option<SyntaxToken> {
155		support::token(&self.syntax, T![local])
156	}
157	pub fn binds(&self) -> AstChildren<Bind> {
158		support::children(&self.syntax)
159	}
160	pub fn semi_token(&self) -> Option<SyntaxToken> {
161		support::token(&self.syntax, T![;])
162	}
163}
164
165#[derive(Debug, Clone, PartialEq, Eq, Hash)]
166pub struct StmtAssert {
167	pub(crate) syntax: SyntaxNode,
168}
169impl StmtAssert {
170	pub fn assertion(&self) -> Option<Assertion> {
171		support::child(&self.syntax)
172	}
173	pub fn semi_token(&self) -> Option<SyntaxToken> {
174		support::token(&self.syntax, T![;])
175	}
176}
177
178#[derive(Debug, Clone, PartialEq, Eq, Hash)]
179pub struct Assertion {
180	pub(crate) syntax: SyntaxNode,
181}
182impl Assertion {
183	pub fn assert_kw_token(&self) -> Option<SyntaxToken> {
184		support::token(&self.syntax, T![assert])
185	}
186	pub fn condition(&self) -> Option<Expr> {
187		support::child(&self.syntax)
188	}
189	pub fn colon_token(&self) -> Option<SyntaxToken> {
190		support::token(&self.syntax, T![:])
191	}
192	pub fn message(&self) -> Option<Expr> {
193		support::child(&self.syntax)
194	}
195}
196
197#[derive(Debug, Clone, PartialEq, Eq, Hash)]
198pub struct ExprBinary {
199	pub(crate) syntax: SyntaxNode,
200}
201impl ExprBinary {
202	pub fn lhs(&self) -> Option<Expr> {
203		support::child(&self.syntax)
204	}
205	pub fn binary_operator(&self) -> Option<BinaryOperator> {
206		support::token_child(&self.syntax)
207	}
208	pub fn rhs(&self) -> Option<Expr> {
209		support::child(&self.syntax)
210	}
211}
212
213#[derive(Debug, Clone, PartialEq, Eq, Hash)]
214pub struct ExprUnary {
215	pub(crate) syntax: SyntaxNode,
216}
217impl ExprUnary {
218	pub fn unary_operator(&self) -> Option<UnaryOperator> {
219		support::token_child(&self.syntax)
220	}
221	pub fn rhs(&self) -> Option<Expr> {
222		support::child(&self.syntax)
223	}
224}
187225
188#[derive(Debug, Clone, PartialEq, Eq, Hash)]226#[derive(Debug, Clone, PartialEq, Eq, Hash)]
189pub struct ExprObjExtend {227pub struct ExprObjExtend {
190	pub(crate) syntax: SyntaxNode,228	pub(crate) syntax: SyntaxNode,
191}229}
192impl ExprObjExtend {230impl ExprObjExtend {
193	pub fn lhs_expr(&self) -> Option<LhsExpr> {
194		support::child(&self.syntax)
195	}
196	pub fn expr(&self) -> Option<Expr> {231	pub fn expr(&self) -> Option<Expr> {
197		support::child(&self.syntax)232		support::child(&self.syntax)
198	}233	}
398	}433	}
399}434}
400
401#[derive(Debug, Clone, PartialEq, Eq, Hash)]
402pub struct ExprAssert {
403	pub(crate) syntax: SyntaxNode,
404}
405impl ExprAssert {
406	pub fn assertion(&self) -> Option<Assertion> {
407		support::child(&self.syntax)
408	}
409	pub fn semi_token(&self) -> Option<SyntaxToken> {
410		support::token(&self.syntax, T![;])
411	}
412	pub fn expr(&self) -> Option<Expr> {
413		support::child(&self.syntax)
414	}
415}
416
417#[derive(Debug, Clone, PartialEq, Eq, Hash)]
418pub struct Assertion {
419	pub(crate) syntax: SyntaxNode,
420}
421impl Assertion {
422	pub fn assert_kw_token(&self) -> Option<SyntaxToken> {
423		support::token(&self.syntax, T![assert])
424	}
425	pub fn condition(&self) -> Option<LhsExpr> {
426		support::child(&self.syntax)
427	}
428	pub fn colon_token(&self) -> Option<SyntaxToken> {
429		support::token(&self.syntax, T![:])
430	}
431	pub fn message(&self) -> Option<Expr> {
432		support::child(&self.syntax)
433	}
434}
435435
436#[derive(Debug, Clone, PartialEq, Eq, Hash)]436#[derive(Debug, Clone, PartialEq, Eq, Hash)]
437pub struct ExprError {437pub struct ExprError {
446	}446	}
447}447}
448
449#[derive(Debug, Clone, PartialEq, Eq, Hash)]
450pub struct StmtLocal {
451	pub(crate) syntax: SyntaxNode,
452}
453impl StmtLocal {
454	pub fn local_kw_token(&self) -> Option<SyntaxToken> {
455		support::token(&self.syntax, T![local])
456	}
457	pub fn binds(&self) -> AstChildren<Bind> {
458		support::children(&self.syntax)
459	}
460	pub fn semi_token(&self) -> Option<SyntaxToken> {
461		support::token(&self.syntax, T![;])
462	}
463}
464448
465#[derive(Debug, Clone, PartialEq, Eq, Hash)]449#[derive(Debug, Clone, PartialEq, Eq, Hash)]
466pub struct SliceDescEnd {450pub struct SliceDescEnd {
641	pub fn for_kw_token(&self) -> Option<SyntaxToken> {625	pub fn for_kw_token(&self) -> Option<SyntaxToken> {
642		support::token(&self.syntax, T![for])626		support::token(&self.syntax, T![for])
643	}627	}
644	pub fn bind(&self) -> Option<Name> {628	pub fn bind(&self) -> Option<Destruct> {
645		support::child(&self.syntax)629		support::child(&self.syntax)
646	}630	}
647	pub fn in_kw_token(&self) -> Option<SyntaxToken> {631	pub fn in_kw_token(&self) -> Option<SyntaxToken> {
819	}803	}
820}804}
805
806#[derive(Debug, Clone, PartialEq, Eq, Hash)]
807pub enum Suffix {
808	SuffixIndex(SuffixIndex),
809	SuffixIndexExpr(SuffixIndexExpr),
810	SuffixSlice(SuffixSlice),
811	SuffixApply(SuffixApply),
812}
813
814#[derive(Debug, Clone, PartialEq, Eq, Hash)]
815pub enum Bind {
816	BindDestruct(BindDestruct),
817	BindFunction(BindFunction),
818}
819
820#[derive(Debug, Clone, PartialEq, Eq, Hash)]
821pub enum Stmt {
822	StmtLocal(StmtLocal),
823	StmtAssert(StmtAssert),
824}
821825
822#[derive(Debug, Clone, PartialEq, Eq, Hash)]826#[derive(Debug, Clone, PartialEq, Eq, Hash)]
823pub enum ObjBody {827pub enum ObjBody {
831	IfSpec(IfSpec),835	IfSpec(IfSpec),
832}836}
833
834#[derive(Debug, Clone, PartialEq, Eq, Hash)]
835pub enum Bind {
836	BindDestruct(BindDestruct),
837	BindFunction(BindFunction),
838}
839837
840#[derive(Debug, Clone, PartialEq, Eq, Hash)]838#[derive(Debug, Clone, PartialEq, Eq, Hash)]
841pub enum ExprBase {839pub enum ExprBase {
842	ExprBinary(ExprBinary),840	ExprBinary(ExprBinary),
843	ExprUnary(ExprUnary),841	ExprUnary(ExprUnary),
844	ExprSlice(ExprSlice),
845	ExprIndex(ExprIndex),
846	ExprIndexExpr(ExprIndexExpr),
847	ExprApply(ExprApply),
848	ExprObjExtend(ExprObjExtend),842	ExprObjExtend(ExprObjExtend),
849	ExprParened(ExprParened),843	ExprParened(ExprParened),
850	ExprString(ExprString),844	ExprString(ExprString),
857	ExprVar(ExprVar),851	ExprVar(ExprVar),
858	ExprIfThenElse(ExprIfThenElse),852	ExprIfThenElse(ExprIfThenElse),
859	ExprFunction(ExprFunction),853	ExprFunction(ExprFunction),
860	ExprAssert(ExprAssert),
861	ExprError(ExprError),854	ExprError(ExprError),
862}855}
863856
905#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]898#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
906pub enum BinaryOperatorKind {899pub enum BinaryOperatorKind {
907	Or,900	Or,
901	NullCoaelse,
908	And,902	And,
909	BitOr,903	BitOr,
910	BitXor,904	BitXor,
1078		&self.syntax1072		&self.syntax
1079	}1073	}
1080}1074}
1075impl AstNode for SuffixIndex {
1076	fn can_cast(kind: SyntaxKind) -> bool {
1077		kind == SUFFIX_INDEX
1078	}
1079	fn cast(syntax: SyntaxNode) -> Option<Self> {
1080		if Self::can_cast(syntax.kind()) {
1081			Some(Self { syntax })
1082		} else {
1083			None
1084		}
1085	}
1086	fn syntax(&self) -> &SyntaxNode {
1087		&self.syntax
1088	}
1089}
1090impl AstNode for Name {
1091	fn can_cast(kind: SyntaxKind) -> bool {
1092		kind == NAME
1093	}
1094	fn cast(syntax: SyntaxNode) -> Option<Self> {
1095		if Self::can_cast(syntax.kind()) {
1096			Some(Self { syntax })
1097		} else {
1098			None
1099		}
1100	}
1101	fn syntax(&self) -> &SyntaxNode {
1102		&self.syntax
1103	}
1104}
1105impl AstNode for SuffixIndexExpr {
1106	fn can_cast(kind: SyntaxKind) -> bool {
1107		kind == SUFFIX_INDEX_EXPR
1108	}
1109	fn cast(syntax: SyntaxNode) -> Option<Self> {
1110		if Self::can_cast(syntax.kind()) {
1111			Some(Self { syntax })
1112		} else {
1113			None
1114		}
1115	}
1116	fn syntax(&self) -> &SyntaxNode {
1117		&self.syntax
1118	}
1119}
1120impl AstNode for SuffixSlice {
1121	fn can_cast(kind: SyntaxKind) -> bool {
1122		kind == SUFFIX_SLICE
1123	}
1124	fn cast(syntax: SyntaxNode) -> Option<Self> {
1125		if Self::can_cast(syntax.kind()) {
1126			Some(Self { syntax })
1127		} else {
1128			None
1129		}
1130	}
1131	fn syntax(&self) -> &SyntaxNode {
1132		&self.syntax
1133	}
1134}
1135impl AstNode for SliceDesc {
1136	fn can_cast(kind: SyntaxKind) -> bool {
1137		kind == SLICE_DESC
1138	}
1139	fn cast(syntax: SyntaxNode) -> Option<Self> {
1140		if Self::can_cast(syntax.kind()) {
1141			Some(Self { syntax })
1142		} else {
1143			None
1144		}
1145	}
1146	fn syntax(&self) -> &SyntaxNode {
1147		&self.syntax
1148	}
1149}
1150impl AstNode for SuffixApply {
1151	fn can_cast(kind: SyntaxKind) -> bool {
1152		kind == SUFFIX_APPLY
1153	}
1154	fn cast(syntax: SyntaxNode) -> Option<Self> {
1155		if Self::can_cast(syntax.kind()) {
1156			Some(Self { syntax })
1157		} else {
1158			None
1159		}
1160	}
1161	fn syntax(&self) -> &SyntaxNode {
1162		&self.syntax
1163	}
1164}
1165impl AstNode for ArgsDesc {
1166	fn can_cast(kind: SyntaxKind) -> bool {
1167		kind == ARGS_DESC
1168	}
1169	fn cast(syntax: SyntaxNode) -> Option<Self> {
1170		if Self::can_cast(syntax.kind()) {
1171			Some(Self { syntax })
1172		} else {
1173			None
1174		}
1175	}
1176	fn syntax(&self) -> &SyntaxNode {
1177		&self.syntax
1178	}
1179}
1180impl AstNode for StmtLocal {
1181	fn can_cast(kind: SyntaxKind) -> bool {
1182		kind == STMT_LOCAL
1183	}
1184	fn cast(syntax: SyntaxNode) -> Option<Self> {
1185		if Self::can_cast(syntax.kind()) {
1186			Some(Self { syntax })
1187		} else {
1188			None
1189		}
1190	}
1191	fn syntax(&self) -> &SyntaxNode {
1192		&self.syntax
1193	}
1194}
1195impl AstNode for StmtAssert {
1196	fn can_cast(kind: SyntaxKind) -> bool {
1197		kind == STMT_ASSERT
1198	}
1199	fn cast(syntax: SyntaxNode) -> Option<Self> {
1200		if Self::can_cast(syntax.kind()) {
1201			Some(Self { syntax })
1202		} else {
1203			None
1204		}
1205	}
1206	fn syntax(&self) -> &SyntaxNode {
1207		&self.syntax
1208	}
1209}
1210impl AstNode for Assertion {
1211	fn can_cast(kind: SyntaxKind) -> bool {
1212		kind == ASSERTION
1213	}
1214	fn cast(syntax: SyntaxNode) -> Option<Self> {
1215		if Self::can_cast(syntax.kind()) {
1216			Some(Self { syntax })
1217		} else {
1218			None
1219		}
1220	}
1221	fn syntax(&self) -> &SyntaxNode {
1222		&self.syntax
1223	}
1224}
1081impl AstNode for ExprBinary {1225impl AstNode for ExprBinary {
1082	fn can_cast(kind: SyntaxKind) -> bool {1226	fn can_cast(kind: SyntaxKind) -> bool {
1083		kind == EXPR_BINARY1227		kind == EXPR_BINARY
1093		&self.syntax1237		&self.syntax
1094	}1238	}
1095}1239}
1096impl AstNode for LhsExpr {
1097	fn can_cast(kind: SyntaxKind) -> bool {
1098		kind == LHS_EXPR
1099	}
1100	fn cast(syntax: SyntaxNode) -> Option<Self> {
1101		if Self::can_cast(syntax.kind()) {
1102			Some(Self { syntax })
1103		} else {
1104			None
1105		}
1106	}
1107	fn syntax(&self) -> &SyntaxNode {
1108		&self.syntax
1109	}
1110}
1111impl AstNode for ExprUnary {1240impl AstNode for ExprUnary {
1112	fn can_cast(kind: SyntaxKind) -> bool {1241	fn can_cast(kind: SyntaxKind) -> bool {
1113		kind == EXPR_UNARY1242		kind == EXPR_UNARY
1123		&self.syntax1252		&self.syntax
1124	}1253	}
1125}1254}
1126impl AstNode for ExprSlice {
1127	fn can_cast(kind: SyntaxKind) -> bool {
1128		kind == EXPR_SLICE
1129	}
1130	fn cast(syntax: SyntaxNode) -> Option<Self> {
1131		if Self::can_cast(syntax.kind()) {
1132			Some(Self { syntax })
1133		} else {
1134			None
1135		}
1136	}
1137	fn syntax(&self) -> &SyntaxNode {
1138		&self.syntax
1139	}
1140}
1141impl AstNode for SliceDesc {
1142	fn can_cast(kind: SyntaxKind) -> bool {
1143		kind == SLICE_DESC
1144	}
1145	fn cast(syntax: SyntaxNode) -> Option<Self> {
1146		if Self::can_cast(syntax.kind()) {
1147			Some(Self { syntax })
1148		} else {
1149			None
1150		}
1151	}
1152	fn syntax(&self) -> &SyntaxNode {
1153		&self.syntax
1154	}
1155}
1156impl AstNode for ExprIndex {
1157	fn can_cast(kind: SyntaxKind) -> bool {
1158		kind == EXPR_INDEX
1159	}
1160	fn cast(syntax: SyntaxNode) -> Option<Self> {
1161		if Self::can_cast(syntax.kind()) {
1162			Some(Self { syntax })
1163		} else {
1164			None
1165		}
1166	}
1167	fn syntax(&self) -> &SyntaxNode {
1168		&self.syntax
1169	}
1170}
1171impl AstNode for Name {
1172	fn can_cast(kind: SyntaxKind) -> bool {
1173		kind == NAME
1174	}
1175	fn cast(syntax: SyntaxNode) -> Option<Self> {
1176		if Self::can_cast(syntax.kind()) {
1177			Some(Self { syntax })
1178		} else {
1179			None
1180		}
1181	}
1182	fn syntax(&self) -> &SyntaxNode {
1183		&self.syntax
1184	}
1185}
1186impl AstNode for ExprIndexExpr {
1187	fn can_cast(kind: SyntaxKind) -> bool {
1188		kind == EXPR_INDEX_EXPR
1189	}
1190	fn cast(syntax: SyntaxNode) -> Option<Self> {
1191		if Self::can_cast(syntax.kind()) {
1192			Some(Self { syntax })
1193		} else {
1194			None
1195		}
1196	}
1197	fn syntax(&self) -> &SyntaxNode {
1198		&self.syntax
1199	}
1200}
1201impl AstNode for ExprApply {
1202	fn can_cast(kind: SyntaxKind) -> bool {
1203		kind == EXPR_APPLY
1204	}
1205	fn cast(syntax: SyntaxNode) -> Option<Self> {
1206		if Self::can_cast(syntax.kind()) {
1207			Some(Self { syntax })
1208		} else {
1209			None
1210		}
1211	}
1212	fn syntax(&self) -> &SyntaxNode {
1213		&self.syntax
1214	}
1215}
1216impl AstNode for ArgsDesc {
1217	fn can_cast(kind: SyntaxKind) -> bool {
1218		kind == ARGS_DESC
1219	}
1220	fn cast(syntax: SyntaxNode) -> Option<Self> {
1221		if Self::can_cast(syntax.kind()) {
1222			Some(Self { syntax })
1223		} else {
1224			None
1225		}
1226	}
1227	fn syntax(&self) -> &SyntaxNode {
1228		&self.syntax
1229	}
1230}
1231impl AstNode for ExprObjExtend {1255impl AstNode for ExprObjExtend {
1232	fn can_cast(kind: SyntaxKind) -> bool {1256	fn can_cast(kind: SyntaxKind) -> bool {
1233		kind == EXPR_OBJ_EXTEND1257		kind == EXPR_OBJ_EXTEND
1453		&self.syntax1477		&self.syntax
1454	}1478	}
1455}1479}
1456impl AstNode for ExprAssert {
1457	fn can_cast(kind: SyntaxKind) -> bool {
1458		kind == EXPR_ASSERT
1459	}
1460	fn cast(syntax: SyntaxNode) -> Option<Self> {
1461		if Self::can_cast(syntax.kind()) {
1462			Some(Self { syntax })
1463		} else {
1464			None
1465		}
1466	}
1467	fn syntax(&self) -> &SyntaxNode {
1468		&self.syntax
1469	}
1470}
1471impl AstNode for Assertion {
1472	fn can_cast(kind: SyntaxKind) -> bool {
1473		kind == ASSERTION
1474	}
1475	fn cast(syntax: SyntaxNode) -> Option<Self> {
1476		if Self::can_cast(syntax.kind()) {
1477			Some(Self { syntax })
1478		} else {
1479			None
1480		}
1481	}
1482	fn syntax(&self) -> &SyntaxNode {
1483		&self.syntax
1484	}
1485}
1486impl AstNode for ExprError {1480impl AstNode for ExprError {
1487	fn can_cast(kind: SyntaxKind) -> bool {1481	fn can_cast(kind: SyntaxKind) -> bool {
1488		kind == EXPR_ERROR1482		kind == EXPR_ERROR
1498		&self.syntax1492		&self.syntax
1499	}1493	}
1500}1494}
1501impl AstNode for StmtLocal {
1502	fn can_cast(kind: SyntaxKind) -> bool {
1503		kind == STMT_LOCAL
1504	}
1505	fn cast(syntax: SyntaxNode) -> Option<Self> {
1506		if Self::can_cast(syntax.kind()) {
1507			Some(Self { syntax })
1508		} else {
1509			None
1510		}
1511	}
1512	fn syntax(&self) -> &SyntaxNode {
1513		&self.syntax
1514	}
1515}
1516impl AstNode for SliceDescEnd {1495impl AstNode for SliceDescEnd {
1517	fn can_cast(kind: SyntaxKind) -> bool {1496	fn can_cast(kind: SyntaxKind) -> bool {
1518		kind == SLICE_DESC_END1497		kind == SLICE_DESC_END
1873		&self.syntax1852		&self.syntax
1874	}1853	}
1875}1854}
1855impl From<SuffixIndex> for Suffix {
1856	fn from(node: SuffixIndex) -> Suffix {
1857		Suffix::SuffixIndex(node)
1858	}
1859}
1860impl From<SuffixIndexExpr> for Suffix {
1861	fn from(node: SuffixIndexExpr) -> Suffix {
1862		Suffix::SuffixIndexExpr(node)
1863	}
1864}
1865impl From<SuffixSlice> for Suffix {
1866	fn from(node: SuffixSlice) -> Suffix {
1867		Suffix::SuffixSlice(node)
1868	}
1869}
1870impl From<SuffixApply> for Suffix {
1871	fn from(node: SuffixApply) -> Suffix {
1872		Suffix::SuffixApply(node)
1873	}
1874}
1875impl AstNode for Suffix {
1876	fn can_cast(kind: SyntaxKind) -> bool {
1877		match kind {
1878			SUFFIX_INDEX | SUFFIX_INDEX_EXPR | SUFFIX_SLICE | SUFFIX_APPLY => true,
1879			_ => false,
1880		}
1881	}
1882	fn cast(syntax: SyntaxNode) -> Option<Self> {
1883		let res = match syntax.kind() {
1884			SUFFIX_INDEX => Suffix::SuffixIndex(SuffixIndex { syntax }),
1885			SUFFIX_INDEX_EXPR => Suffix::SuffixIndexExpr(SuffixIndexExpr { syntax }),
1886			SUFFIX_SLICE => Suffix::SuffixSlice(SuffixSlice { syntax }),
1887			SUFFIX_APPLY => Suffix::SuffixApply(SuffixApply { syntax }),
1888			_ => return None,
1889		};
1890		Some(res)
1891	}
1892	fn syntax(&self) -> &SyntaxNode {
1893		match self {
1894			Suffix::SuffixIndex(it) => &it.syntax,
1895			Suffix::SuffixIndexExpr(it) => &it.syntax,
1896			Suffix::SuffixSlice(it) => &it.syntax,
1897			Suffix::SuffixApply(it) => &it.syntax,
1898		}
1899	}
1900}
1901impl From<BindDestruct> for Bind {
1902	fn from(node: BindDestruct) -> Bind {
1903		Bind::BindDestruct(node)
1904	}
1905}
1906impl From<BindFunction> for Bind {
1907	fn from(node: BindFunction) -> Bind {
1908		Bind::BindFunction(node)
1909	}
1910}
1911impl AstNode for Bind {
1912	fn can_cast(kind: SyntaxKind) -> bool {
1913		match kind {
1914			BIND_DESTRUCT | BIND_FUNCTION => true,
1915			_ => false,
1916		}
1917	}
1918	fn cast(syntax: SyntaxNode) -> Option<Self> {
1919		let res = match syntax.kind() {
1920			BIND_DESTRUCT => Bind::BindDestruct(BindDestruct { syntax }),
1921			BIND_FUNCTION => Bind::BindFunction(BindFunction { syntax }),
1922			_ => return None,
1923		};
1924		Some(res)
1925	}
1926	fn syntax(&self) -> &SyntaxNode {
1927		match self {
1928			Bind::BindDestruct(it) => &it.syntax,
1929			Bind::BindFunction(it) => &it.syntax,
1930		}
1931	}
1932}
1933impl From<StmtLocal> for Stmt {
1934	fn from(node: StmtLocal) -> Stmt {
1935		Stmt::StmtLocal(node)
1936	}
1937}
1938impl From<StmtAssert> for Stmt {
1939	fn from(node: StmtAssert) -> Stmt {
1940		Stmt::StmtAssert(node)
1941	}
1942}
1943impl AstNode for Stmt {
1944	fn can_cast(kind: SyntaxKind) -> bool {
1945		match kind {
1946			STMT_LOCAL | STMT_ASSERT => true,
1947			_ => false,
1948		}
1949	}
1950	fn cast(syntax: SyntaxNode) -> Option<Self> {
1951		let res = match syntax.kind() {
1952			STMT_LOCAL => Stmt::StmtLocal(StmtLocal { syntax }),
1953			STMT_ASSERT => Stmt::StmtAssert(StmtAssert { syntax }),
1954			_ => return None,
1955		};
1956		Some(res)
1957	}
1958	fn syntax(&self) -> &SyntaxNode {
1959		match self {
1960			Stmt::StmtLocal(it) => &it.syntax,
1961			Stmt::StmtAssert(it) => &it.syntax,
1962		}
1963	}
1964}
1876impl From<ObjBodyComp> for ObjBody {1965impl From<ObjBodyComp> for ObjBody {
1877	fn from(node: ObjBodyComp) -> ObjBody {1966	fn from(node: ObjBodyComp) -> ObjBody {
1878		ObjBody::ObjBodyComp(node)1967		ObjBody::ObjBodyComp(node)
1937		}2026		}
1938	}2027	}
1939}2028}
1940impl From<BindDestruct> for Bind {
1941	fn from(node: BindDestruct) -> Bind {
1942		Bind::BindDestruct(node)
1943	}
1944}
1945impl From<BindFunction> for Bind {
1946	fn from(node: BindFunction) -> Bind {
1947		Bind::BindFunction(node)
1948	}
1949}
1950impl AstNode for Bind {
1951	fn can_cast(kind: SyntaxKind) -> bool {
1952		match kind {
1953			BIND_DESTRUCT | BIND_FUNCTION => true,
1954			_ => false,
1955		}
1956	}
1957	fn cast(syntax: SyntaxNode) -> Option<Self> {
1958		let res = match syntax.kind() {
1959			BIND_DESTRUCT => Bind::BindDestruct(BindDestruct { syntax }),
1960			BIND_FUNCTION => Bind::BindFunction(BindFunction { syntax }),
1961			_ => return None,
1962		};
1963		Some(res)
1964	}
1965	fn syntax(&self) -> &SyntaxNode {
1966		match self {
1967			Bind::BindDestruct(it) => &it.syntax,
1968			Bind::BindFunction(it) => &it.syntax,
1969		}
1970	}
1971}
1972impl From<ExprBinary> for ExprBase {2029impl From<ExprBinary> for ExprBase {
1973	fn from(node: ExprBinary) -> ExprBase {2030	fn from(node: ExprBinary) -> ExprBase {
1974		ExprBase::ExprBinary(node)2031		ExprBase::ExprBinary(node)
1979		ExprBase::ExprUnary(node)2036		ExprBase::ExprUnary(node)
1980	}2037	}
1981}2038}
1982impl From<ExprSlice> for ExprBase {
1983	fn from(node: ExprSlice) -> ExprBase {
1984		ExprBase::ExprSlice(node)
1985	}
1986}
1987impl From<ExprIndex> for ExprBase {
1988	fn from(node: ExprIndex) -> ExprBase {
1989		ExprBase::ExprIndex(node)
1990	}
1991}
1992impl From<ExprIndexExpr> for ExprBase {
1993	fn from(node: ExprIndexExpr) -> ExprBase {
1994		ExprBase::ExprIndexExpr(node)
1995	}
1996}
1997impl From<ExprApply> for ExprBase {
1998	fn from(node: ExprApply) -> ExprBase {
1999		ExprBase::ExprApply(node)
2000	}
2001}
2002impl From<ExprObjExtend> for ExprBase {2039impl From<ExprObjExtend> for ExprBase {
2003	fn from(node: ExprObjExtend) -> ExprBase {2040	fn from(node: ExprObjExtend) -> ExprBase {
2004		ExprBase::ExprObjExtend(node)2041		ExprBase::ExprObjExtend(node)
2059		ExprBase::ExprFunction(node)2096		ExprBase::ExprFunction(node)
2060	}2097	}
2061}2098}
2062impl From<ExprAssert> for ExprBase {
2063	fn from(node: ExprAssert) -> ExprBase {
2064		ExprBase::ExprAssert(node)
2065	}
2066}
2067impl From<ExprError> for ExprBase {2099impl From<ExprError> for ExprBase {
2068	fn from(node: ExprError) -> ExprBase {2100	fn from(node: ExprError) -> ExprBase {
2069		ExprBase::ExprError(node)2101		ExprBase::ExprError(node)
2072impl AstNode for ExprBase {2104impl AstNode for ExprBase {
2073	fn can_cast(kind: SyntaxKind) -> bool {2105	fn can_cast(kind: SyntaxKind) -> bool {
2074		match kind {2106		match kind {
2075			EXPR_BINARY | EXPR_UNARY | EXPR_SLICE | EXPR_INDEX | EXPR_INDEX_EXPR | EXPR_APPLY2107			EXPR_BINARY | EXPR_UNARY | EXPR_OBJ_EXTEND | EXPR_PARENED | EXPR_STRING
2076			| EXPR_OBJ_EXTEND | EXPR_PARENED | EXPR_STRING | EXPR_NUMBER | EXPR_LITERAL2108			| EXPR_NUMBER | EXPR_LITERAL | EXPR_ARRAY | EXPR_OBJECT | EXPR_ARRAY_COMP
2077			| EXPR_ARRAY | EXPR_OBJECT | EXPR_ARRAY_COMP | EXPR_IMPORT | EXPR_VAR2109			| EXPR_IMPORT | EXPR_VAR | EXPR_IF_THEN_ELSE | EXPR_FUNCTION | EXPR_ERROR => true,
2078			| EXPR_IF_THEN_ELSE | EXPR_FUNCTION | EXPR_ASSERT | EXPR_ERROR => true,
2079			_ => false,2110			_ => false,
2080		}2111		}
2081	}2112	}
2082	fn cast(syntax: SyntaxNode) -> Option<Self> {2113	fn cast(syntax: SyntaxNode) -> Option<Self> {
2083		let res = match syntax.kind() {2114		let res = match syntax.kind() {
2084			EXPR_BINARY => ExprBase::ExprBinary(ExprBinary { syntax }),2115			EXPR_BINARY => ExprBase::ExprBinary(ExprBinary { syntax }),
2085			EXPR_UNARY => ExprBase::ExprUnary(ExprUnary { syntax }),2116			EXPR_UNARY => ExprBase::ExprUnary(ExprUnary { syntax }),
2086			EXPR_SLICE => ExprBase::ExprSlice(ExprSlice { syntax }),
2087			EXPR_INDEX => ExprBase::ExprIndex(ExprIndex { syntax }),
2088			EXPR_INDEX_EXPR => ExprBase::ExprIndexExpr(ExprIndexExpr { syntax }),
2089			EXPR_APPLY => ExprBase::ExprApply(ExprApply { syntax }),
2090			EXPR_OBJ_EXTEND => ExprBase::ExprObjExtend(ExprObjExtend { syntax }),2117			EXPR_OBJ_EXTEND => ExprBase::ExprObjExtend(ExprObjExtend { syntax }),
2091			EXPR_PARENED => ExprBase::ExprParened(ExprParened { syntax }),2118			EXPR_PARENED => ExprBase::ExprParened(ExprParened { syntax }),
2092			EXPR_STRING => ExprBase::ExprString(ExprString { syntax }),2119			EXPR_STRING => ExprBase::ExprString(ExprString { syntax }),
2099			EXPR_VAR => ExprBase::ExprVar(ExprVar { syntax }),2126			EXPR_VAR => ExprBase::ExprVar(ExprVar { syntax }),
2100			EXPR_IF_THEN_ELSE => ExprBase::ExprIfThenElse(ExprIfThenElse { syntax }),2127			EXPR_IF_THEN_ELSE => ExprBase::ExprIfThenElse(ExprIfThenElse { syntax }),
2101			EXPR_FUNCTION => ExprBase::ExprFunction(ExprFunction { syntax }),2128			EXPR_FUNCTION => ExprBase::ExprFunction(ExprFunction { syntax }),
2102			EXPR_ASSERT => ExprBase::ExprAssert(ExprAssert { syntax }),
2103			EXPR_ERROR => ExprBase::ExprError(ExprError { syntax }),2129			EXPR_ERROR => ExprBase::ExprError(ExprError { syntax }),
2104			_ => return None,2130			_ => return None,
2105		};2131		};
2109		match self {2135		match self {
2110			ExprBase::ExprBinary(it) => &it.syntax,2136			ExprBase::ExprBinary(it) => &it.syntax,
2111			ExprBase::ExprUnary(it) => &it.syntax,2137			ExprBase::ExprUnary(it) => &it.syntax,
2112			ExprBase::ExprSlice(it) => &it.syntax,
2113			ExprBase::ExprIndex(it) => &it.syntax,
2114			ExprBase::ExprIndexExpr(it) => &it.syntax,
2115			ExprBase::ExprApply(it) => &it.syntax,
2116			ExprBase::ExprObjExtend(it) => &it.syntax,2138			ExprBase::ExprObjExtend(it) => &it.syntax,
2117			ExprBase::ExprParened(it) => &it.syntax,2139			ExprBase::ExprParened(it) => &it.syntax,
2118			ExprBase::ExprString(it) => &it.syntax,2140			ExprBase::ExprString(it) => &it.syntax,
2125			ExprBase::ExprVar(it) => &it.syntax,2147			ExprBase::ExprVar(it) => &it.syntax,
2126			ExprBase::ExprIfThenElse(it) => &it.syntax,2148			ExprBase::ExprIfThenElse(it) => &it.syntax,
2127			ExprBase::ExprFunction(it) => &it.syntax,2149			ExprBase::ExprFunction(it) => &it.syntax,
2128			ExprBase::ExprAssert(it) => &it.syntax,
2129			ExprBase::ExprError(it) => &it.syntax,2150			ExprBase::ExprError(it) => &it.syntax,
2130		}2151		}
2131	}2152	}
2344impl BinaryOperatorKind {2365impl BinaryOperatorKind {
2345	fn can_cast(kind: SyntaxKind) -> bool {2366	fn can_cast(kind: SyntaxKind) -> bool {
2346		match kind {2367		match kind {
2347			OR | AND | BIT_OR | BIT_XOR | BIT_AND | EQ | NE | LT | GT | LE | GE | IN_KW | LHS2368			OR | NULL_COAELSE | AND | BIT_OR | BIT_XOR | BIT_AND | EQ | NE | LT | GT | LE | GE
2348			| RHS | PLUS | MINUS | MUL | DIV | MODULO | META_OBJECT_APPLY | ERROR_NO_OPERATOR => true,2369			| IN_KW | LHS | RHS | PLUS | MINUS | MUL | DIV | MODULO | META_OBJECT_APPLY
2370			| ERROR_NO_OPERATOR => true,
2349			_ => false,2371			_ => false,
2350		}2372		}
2351	}2373	}
2352	pub fn cast(kind: SyntaxKind) -> Option<Self> {2374	pub fn cast(kind: SyntaxKind) -> Option<Self> {
2353		let res = match kind {2375		let res = match kind {
2354			OR => Self::Or,2376			OR => Self::Or,
2377			NULL_COAELSE => Self::NullCoaelse,
2355			AND => Self::And,2378			AND => Self::And,
2356			BIT_OR => Self::BitOr,2379			BIT_OR => Self::BitOr,
2357			BIT_XOR => Self::BitXor,2380			BIT_XOR => Self::BitXor,
2742		std::fmt::Display::fmt(self.syntax(), f)2765		std::fmt::Display::fmt(self.syntax(), f)
2743	}2766	}
2744}2767}
2768impl std::fmt::Display for Suffix {
2769	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2770		std::fmt::Display::fmt(self.syntax(), f)
2771	}
2772}
2773impl std::fmt::Display for Bind {
2774	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2775		std::fmt::Display::fmt(self.syntax(), f)
2776	}
2777}
2778impl std::fmt::Display for Stmt {
2779	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2780		std::fmt::Display::fmt(self.syntax(), f)
2781	}
2782}
2745impl std::fmt::Display for ObjBody {2783impl std::fmt::Display for ObjBody {
2746	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2784	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2747		std::fmt::Display::fmt(self.syntax(), f)2785		std::fmt::Display::fmt(self.syntax(), f)
2752		std::fmt::Display::fmt(self.syntax(), f)2790		std::fmt::Display::fmt(self.syntax(), f)
2753	}2791	}
2754}2792}
2755impl std::fmt::Display for Bind {
2756	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2757		std::fmt::Display::fmt(self.syntax(), f)
2758	}
2759}
2760impl std::fmt::Display for ExprBase {2793impl std::fmt::Display for ExprBase {
2761	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2794	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2762		std::fmt::Display::fmt(self.syntax(), f)2795		std::fmt::Display::fmt(self.syntax(), f)
2797		std::fmt::Display::fmt(self.syntax(), f)2830		std::fmt::Display::fmt(self.syntax(), f)
2798	}2831	}
2799}2832}
2833impl std::fmt::Display for SuffixIndex {
2834	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2835		std::fmt::Display::fmt(self.syntax(), f)
2836	}
2837}
2838impl std::fmt::Display for Name {
2839	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2840		std::fmt::Display::fmt(self.syntax(), f)
2841	}
2842}
2843impl std::fmt::Display for SuffixIndexExpr {
2844	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2845		std::fmt::Display::fmt(self.syntax(), f)
2846	}
2847}
2848impl std::fmt::Display for SuffixSlice {
2849	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2850		std::fmt::Display::fmt(self.syntax(), f)
2851	}
2852}
2853impl std::fmt::Display for SliceDesc {
2854	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2855		std::fmt::Display::fmt(self.syntax(), f)
2856	}
2857}
2858impl std::fmt::Display for SuffixApply {
2859	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2860		std::fmt::Display::fmt(self.syntax(), f)
2861	}
2862}
2863impl std::fmt::Display for ArgsDesc {
2864	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2865		std::fmt::Display::fmt(self.syntax(), f)
2866	}
2867}
2868impl std::fmt::Display for StmtLocal {
2869	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2870		std::fmt::Display::fmt(self.syntax(), f)
2871	}
2872}
2873impl std::fmt::Display for StmtAssert {
2874	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2875		std::fmt::Display::fmt(self.syntax(), f)
2876	}
2877}
2878impl std::fmt::Display for Assertion {
2879	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2880		std::fmt::Display::fmt(self.syntax(), f)
2881	}
2882}
2800impl std::fmt::Display for ExprBinary {2883impl std::fmt::Display for ExprBinary {
2801	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2884	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2802		std::fmt::Display::fmt(self.syntax(), f)2885		std::fmt::Display::fmt(self.syntax(), f)
2803	}2886	}
2804}2887}
2805impl std::fmt::Display for LhsExpr {
2806	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2807		std::fmt::Display::fmt(self.syntax(), f)
2808	}
2809}
2810impl std::fmt::Display for ExprUnary {2888impl std::fmt::Display for ExprUnary {
2811	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2889	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2812		std::fmt::Display::fmt(self.syntax(), f)2890		std::fmt::Display::fmt(self.syntax(), f)
2813	}2891	}
2814}2892}
2815impl std::fmt::Display for ExprSlice {
2816	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2817		std::fmt::Display::fmt(self.syntax(), f)
2818	}
2819}
2820impl std::fmt::Display for SliceDesc {
2821	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2822		std::fmt::Display::fmt(self.syntax(), f)
2823	}
2824}
2825impl std::fmt::Display for ExprIndex {
2826	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2827		std::fmt::Display::fmt(self.syntax(), f)
2828	}
2829}
2830impl std::fmt::Display for Name {
2831	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2832		std::fmt::Display::fmt(self.syntax(), f)
2833	}
2834}
2835impl std::fmt::Display for ExprIndexExpr {
2836	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2837		std::fmt::Display::fmt(self.syntax(), f)
2838	}
2839}
2840impl std::fmt::Display for ExprApply {
2841	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2842		std::fmt::Display::fmt(self.syntax(), f)
2843	}
2844}
2845impl std::fmt::Display for ArgsDesc {
2846	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2847		std::fmt::Display::fmt(self.syntax(), f)
2848	}
2849}
2850impl std::fmt::Display for ExprObjExtend {2893impl std::fmt::Display for ExprObjExtend {
2851	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2894	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2852		std::fmt::Display::fmt(self.syntax(), f)2895		std::fmt::Display::fmt(self.syntax(), f)
2922		std::fmt::Display::fmt(self.syntax(), f)2965		std::fmt::Display::fmt(self.syntax(), f)
2923	}2966	}
2924}2967}
2925impl std::fmt::Display for ExprAssert {
2926	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2927		std::fmt::Display::fmt(self.syntax(), f)
2928	}
2929}
2930impl std::fmt::Display for Assertion {
2931	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2932		std::fmt::Display::fmt(self.syntax(), f)
2933	}
2934}
2935impl std::fmt::Display for ExprError {2968impl std::fmt::Display for ExprError {
2936	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2969	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2937		std::fmt::Display::fmt(self.syntax(), f)2970		std::fmt::Display::fmt(self.syntax(), f)
2938	}2971	}
2939}2972}
2940impl std::fmt::Display for StmtLocal {
2941	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2942		std::fmt::Display::fmt(self.syntax(), f)
2943	}
2944}
2945impl std::fmt::Display for SliceDescEnd {2973impl std::fmt::Display for SliceDescEnd {
2946	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2974	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2947		std::fmt::Display::fmt(self.syntax(), f)2975		std::fmt::Display::fmt(self.syntax(), f)